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, got = 0, segs = 0;
3581         gfp_t priority;
3582         struct st_buffer *tb;
3583
3584         if (from_initialization)
3585                 priority = GFP_ATOMIC;
3586         else
3587                 priority = GFP_KERNEL;
3588
3589         i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3590                 max_sg * sizeof(struct st_buf_fragment);
3591         tb = kmalloc(i, priority);
3592         if (!tb) {
3593                 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3594                 return NULL;
3595         }
3596         memset(tb, 0, i);
3597         tb->frp_segs = tb->orig_frp_segs = segs;
3598         tb->use_sg = max_sg;
3599         if (segs > 0)
3600                 tb->b_data = page_address(tb->sg[0].page);
3601         tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
3602
3603         tb->in_use = 1;
3604         tb->dma = need_dma;
3605         tb->buffer_size = got;
3606
3607         return tb;
3608 }
3609
3610
3611 /* Try to allocate enough space in the tape buffer */
3612 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3613 {
3614         int segs, nbr, max_segs, b_size, order, got;
3615         gfp_t priority;
3616
3617         if (new_size <= STbuffer->buffer_size)
3618                 return 1;
3619
3620         if (STbuffer->buffer_size <= PAGE_SIZE)
3621                 normalize_buffer(STbuffer);  /* Avoid extra segment */
3622
3623         max_segs = STbuffer->use_sg;
3624         nbr = max_segs - STbuffer->frp_segs;
3625         if (nbr <= 0)
3626                 return 0;
3627
3628         priority = GFP_KERNEL | __GFP_NOWARN;
3629         if (need_dma)
3630                 priority |= GFP_DMA;
3631         for (b_size = PAGE_SIZE, order=0;
3632              b_size < new_size - STbuffer->buffer_size;
3633              order++, b_size *= 2)
3634                 ;  /* empty */
3635
3636         for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3637              segs < max_segs && got < new_size;) {
3638                 STbuffer->frp[segs].page = alloc_pages(priority, order);
3639                 if (STbuffer->frp[segs].page == NULL) {
3640                         if (new_size - got <= (max_segs - segs) * b_size / 2) {
3641                                 b_size /= 2; /* Large enough for the rest of the buffers */
3642                                 order--;
3643                                 continue;
3644                         }
3645                         DEB(STbuffer->buffer_size = got);
3646                         normalize_buffer(STbuffer);
3647                         return 0;
3648                 }
3649                 STbuffer->frp[segs].length = b_size;
3650                 STbuffer->frp_segs += 1;
3651                 got += b_size;
3652                 STbuffer->buffer_size = got;
3653                 segs++;
3654         }
3655         STbuffer->b_data = page_address(STbuffer->frp[0].page);
3656
3657         return 1;
3658 }
3659
3660
3661 /* Release the extra buffer */
3662 static void normalize_buffer(struct st_buffer * STbuffer)
3663 {
3664         int i, order;
3665
3666         for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3667                 order = get_order(STbuffer->frp[i].length);
3668                 __free_pages(STbuffer->frp[i].page, order);
3669                 STbuffer->buffer_size -= STbuffer->frp[i].length;
3670         }
3671         STbuffer->frp_segs = STbuffer->orig_frp_segs;
3672         STbuffer->frp_sg_current = 0;
3673 }
3674
3675
3676 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3677    negative error code. */
3678 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3679 {
3680         int i, cnt, res, offset;
3681
3682         for (i = 0, offset = st_bp->buffer_bytes;
3683              i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3684                 offset -= st_bp->frp[i].length;
3685         if (i == st_bp->frp_segs) {     /* Should never happen */
3686                 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3687                 return (-EIO);
3688         }
3689         for (; i < st_bp->frp_segs && do_count > 0; i++) {
3690                 cnt = st_bp->frp[i].length - offset < do_count ?
3691                     st_bp->frp[i].length - offset : do_count;
3692                 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3693                 if (res)
3694                         return (-EFAULT);
3695                 do_count -= cnt;
3696                 st_bp->buffer_bytes += cnt;
3697                 ubp += cnt;
3698                 offset = 0;
3699         }
3700         if (do_count) /* Should never happen */
3701                 return (-EIO);
3702
3703         return 0;
3704 }
3705
3706
3707 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3708    negative error code. */
3709 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3710 {
3711         int i, cnt, res, offset;
3712
3713         for (i = 0, offset = st_bp->read_pointer;
3714              i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3715                 offset -= st_bp->frp[i].length;
3716         if (i == st_bp->frp_segs) {     /* Should never happen */
3717                 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3718                 return (-EIO);
3719         }
3720         for (; i < st_bp->frp_segs && do_count > 0; i++) {
3721                 cnt = st_bp->frp[i].length - offset < do_count ?
3722                     st_bp->frp[i].length - offset : do_count;
3723                 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3724                 if (res)
3725                         return (-EFAULT);
3726                 do_count -= cnt;
3727                 st_bp->buffer_bytes -= cnt;
3728                 st_bp->read_pointer += cnt;
3729                 ubp += cnt;
3730                 offset = 0;
3731         }
3732         if (do_count) /* Should never happen */
3733                 return (-EIO);
3734
3735         return 0;
3736 }
3737
3738
3739 /* Move data towards start of buffer */
3740 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3741 {
3742         int src_seg, dst_seg, src_offset = 0, dst_offset;
3743         int count, total;
3744
3745         if (offset == 0)
3746                 return;
3747
3748         total=st_bp->buffer_bytes - offset;
3749         for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3750                 src_offset = offset;
3751                 if (src_offset < st_bp->frp[src_seg].length)
3752                         break;
3753                 offset -= st_bp->frp[src_seg].length;
3754         }
3755
3756         st_bp->buffer_bytes = st_bp->read_pointer = total;
3757         for (dst_seg=dst_offset=0; total > 0; ) {
3758                 count = min(st_bp->frp[dst_seg].length - dst_offset,
3759                             st_bp->frp[src_seg].length - src_offset);
3760                 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3761                         page_address(st_bp->frp[src_seg].page) + src_offset, count);
3762                 src_offset += count;
3763                 if (src_offset >= st_bp->frp[src_seg].length) {
3764                         src_seg++;
3765                         src_offset = 0;
3766                 }
3767                 dst_offset += count;
3768                 if (dst_offset >= st_bp->frp[dst_seg].length) {
3769                         dst_seg++;
3770                         dst_offset = 0;
3771                 }
3772                 total -= count;
3773         }
3774 }
3775
3776
3777 /* Fill the s/g list up to the length required for this transfer */
3778 static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
3779 {
3780         int i;
3781         unsigned int count;
3782         struct scatterlist *sg;
3783         struct st_buf_fragment *frp;
3784
3785         if (length == STbp->frp_sg_current)
3786                 return;   /* work already done */
3787
3788         sg = &(STbp->sg[0]);
3789         frp = STbp->frp;
3790         for (i=count=0; count < length; i++) {
3791                 sg[i].page = frp[i].page;
3792                 if (length - count > frp[i].length)
3793                         sg[i].length = frp[i].length;
3794                 else
3795                         sg[i].length = length - count;
3796                 count += sg[i].length;
3797                 sg[i].offset = 0;
3798         }
3799         STbp->sg_segs = i;
3800         STbp->frp_sg_current = length;
3801 }
3802
3803
3804 /* Validate the options from command line or module parameters */
3805 static void validate_options(void)
3806 {
3807         if (buffer_kbs > 0)
3808                 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3809         if (max_sg_segs >= ST_FIRST_SG)
3810                 st_max_sg_segs = max_sg_segs;
3811 }
3812
3813 #ifndef MODULE
3814 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3815  */
3816 static int __init st_setup(char *str)
3817 {
3818         int i, len, ints[5];
3819         char *stp;
3820
3821         stp = get_options(str, ARRAY_SIZE(ints), ints);
3822
3823         if (ints[0] > 0) {
3824                 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3825                         if (parms[i].val)
3826                                 *parms[i].val = ints[i + 1];
3827         } else {
3828                 while (stp != NULL) {
3829                         for (i = 0; i < ARRAY_SIZE(parms); i++) {
3830                                 len = strlen(parms[i].name);
3831                                 if (!strncmp(stp, parms[i].name, len) &&
3832                                     (*(stp + len) == ':' || *(stp + len) == '=')) {
3833                                         if (parms[i].val)
3834                                                 *parms[i].val =
3835                                                         simple_strtoul(stp + len + 1, NULL, 0);
3836                                         else
3837                                                 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3838                                                        parms[i].name);
3839                                         break;
3840                                 }
3841                         }
3842                         if (i >= sizeof(parms) / sizeof(struct st_dev_parm))
3843                                  printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3844                                         stp);
3845                         stp = strchr(stp, ',');
3846                         if (stp)
3847                                 stp++;
3848                 }
3849         }
3850
3851         validate_options();
3852
3853         return 1;
3854 }
3855
3856 __setup("st=", st_setup);
3857
3858 #endif
3859
3860 static struct file_operations st_fops =
3861 {
3862         .owner =        THIS_MODULE,
3863         .read =         st_read,
3864         .write =        st_write,
3865         .ioctl =        st_ioctl,
3866 #ifdef CONFIG_COMPAT
3867         .compat_ioctl = st_compat_ioctl,
3868 #endif
3869         .open =         st_open,
3870         .flush =        st_flush,
3871         .release =      st_release,
3872 };
3873
3874 static int st_probe(struct device *dev)
3875 {
3876         struct scsi_device *SDp = to_scsi_device(dev);
3877         struct gendisk *disk = NULL;
3878         struct cdev *cdev = NULL;
3879         struct scsi_tape *tpnt = NULL;
3880         struct st_modedef *STm;
3881         struct st_partstat *STps;
3882         struct st_buffer *buffer;
3883         int i, j, mode, dev_num, error;
3884         char *stp;
3885         u64 bounce_limit;
3886
3887         if (SDp->type != TYPE_TAPE)
3888                 return -ENODEV;
3889         if ((stp = st_incompatible(SDp))) {
3890                 printk(KERN_INFO
3891                        "st: Found incompatible tape at scsi%d, channel %d, id %d, lun %d\n",
3892                        SDp->host->host_no, SDp->channel, SDp->id, SDp->lun);
3893                 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3894                 return -ENODEV;
3895         }
3896
3897         i = SDp->host->sg_tablesize;
3898         if (st_max_sg_segs < i)
3899                 i = st_max_sg_segs;
3900         buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i);
3901         if (buffer == NULL) {
3902                 printk(KERN_ERR
3903                        "st: Can't allocate new tape buffer. Device not attached.\n");
3904                 goto out;
3905         }
3906
3907         disk = alloc_disk(1);
3908         if (!disk) {
3909                 printk(KERN_ERR "st: out of memory. Device not attached.\n");
3910                 goto out_buffer_free;
3911         }
3912
3913         write_lock(&st_dev_arr_lock);
3914         if (st_nr_dev >= st_dev_max) {
3915                 struct scsi_tape **tmp_da;
3916                 int tmp_dev_max;
3917
3918                 tmp_dev_max = max(st_nr_dev * 2, 8);
3919                 if (tmp_dev_max > ST_MAX_TAPES)
3920                         tmp_dev_max = ST_MAX_TAPES;
3921                 if (tmp_dev_max <= st_nr_dev) {
3922                         write_unlock(&st_dev_arr_lock);
3923                         printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
3924                                ST_MAX_TAPES);
3925                         goto out_put_disk;
3926                 }
3927
3928                 tmp_da = kmalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
3929                 if (tmp_da == NULL) {
3930                         write_unlock(&st_dev_arr_lock);
3931                         printk(KERN_ERR "st: Can't extend device array.\n");
3932                         goto out_put_disk;
3933                 }
3934
3935                 memset(tmp_da, 0, tmp_dev_max * sizeof(struct scsi_tape *));
3936                 if (scsi_tapes != NULL) {
3937                         memcpy(tmp_da, scsi_tapes,
3938                                st_dev_max * sizeof(struct scsi_tape *));
3939                         kfree(scsi_tapes);
3940                 }
3941                 scsi_tapes = tmp_da;
3942
3943                 st_dev_max = tmp_dev_max;
3944         }
3945
3946         for (i = 0; i < st_dev_max; i++)
3947                 if (scsi_tapes[i] == NULL)
3948                         break;
3949         if (i >= st_dev_max)
3950                 panic("scsi_devices corrupt (st)");
3951
3952         tpnt = kmalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
3953         if (tpnt == NULL) {
3954                 write_unlock(&st_dev_arr_lock);
3955                 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
3956                 goto out_put_disk;
3957         }
3958         memset(tpnt, 0, sizeof(struct scsi_tape));
3959         kref_init(&tpnt->kref);
3960         tpnt->disk = disk;
3961         sprintf(disk->disk_name, "st%d", i);
3962         disk->private_data = &tpnt->driver;
3963         disk->queue = SDp->request_queue;
3964         tpnt->driver = &st_template;
3965         scsi_tapes[i] = tpnt;
3966         dev_num = i;
3967
3968         tpnt->device = SDp;
3969         if (SDp->scsi_level <= 2)
3970                 tpnt->tape_type = MT_ISSCSI1;
3971         else
3972                 tpnt->tape_type = MT_ISSCSI2;
3973
3974         tpnt->buffer = buffer;
3975         tpnt->buffer->last_SRpnt = NULL;
3976
3977         tpnt->inited = 0;
3978         tpnt->dirty = 0;
3979         tpnt->in_use = 0;
3980         tpnt->drv_buffer = 1;   /* Try buffering if no mode sense */
3981         tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
3982         tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
3983         tpnt->density = 0;
3984         tpnt->do_auto_lock = ST_AUTO_LOCK;
3985         tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
3986         tpnt->can_partitions = 0;
3987         tpnt->two_fm = ST_TWO_FM;
3988         tpnt->fast_mteom = ST_FAST_MTEOM;
3989         tpnt->scsi2_logical = ST_SCSI2LOGICAL;
3990         tpnt->immediate = ST_NOWAIT;
3991         tpnt->default_drvbuffer = 0xff;         /* No forced buffering */
3992         tpnt->partition = 0;
3993         tpnt->new_partition = 0;
3994         tpnt->nbr_partitions = 0;
3995         tpnt->device->timeout = ST_TIMEOUT;
3996         tpnt->long_timeout = ST_LONG_TIMEOUT;
3997         tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
3998
3999         bounce_limit = scsi_calculate_bounce_limit(SDp->host) >> PAGE_SHIFT;
4000         if (bounce_limit > ULONG_MAX)
4001                 bounce_limit = ULONG_MAX;
4002         tpnt->max_pfn = bounce_limit;
4003
4004         for (i = 0; i < ST_NBR_MODES; i++) {
4005                 STm = &(tpnt->modes[i]);
4006                 STm->defined = 0;
4007                 STm->sysv = ST_SYSV;
4008                 STm->defaults_for_writes = 0;
4009                 STm->do_async_writes = ST_ASYNC_WRITES;
4010                 STm->do_buffer_writes = ST_BUFFER_WRITES;
4011                 STm->do_read_ahead = ST_READ_AHEAD;
4012                 STm->default_compression = ST_DONT_TOUCH;
4013                 STm->default_blksize = (-1);    /* No forced size */
4014                 STm->default_density = (-1);    /* No forced density */
4015         }
4016
4017         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4018                 STps = &(tpnt->ps[i]);
4019                 STps->rw = ST_IDLE;
4020                 STps->eof = ST_NOEOF;
4021                 STps->at_sm = 0;
4022                 STps->last_block_valid = 0;
4023                 STps->drv_block = (-1);
4024                 STps->drv_file = (-1);
4025         }
4026
4027         tpnt->current_mode = 0;
4028         tpnt->modes[0].defined = 1;
4029
4030         tpnt->density_changed = tpnt->compression_changed =
4031             tpnt->blksize_changed = 0;
4032         init_MUTEX(&tpnt->lock);
4033
4034         st_nr_dev++;
4035         write_unlock(&st_dev_arr_lock);
4036
4037         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4038                 STm = &(tpnt->modes[mode]);
4039                 for (j=0; j < 2; j++) {
4040                         cdev = cdev_alloc();
4041                         if (!cdev) {
4042                                 printk(KERN_ERR
4043                                        "st%d: out of memory. Device not attached.\n",
4044                                        dev_num);
4045                                 goto out_free_tape;
4046                         }
4047                         cdev->owner = THIS_MODULE;
4048                         cdev->ops = &st_fops;
4049
4050                         error = cdev_add(cdev,
4051                                          MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4052                                          1);
4053                         if (error) {
4054                                 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4055                                        dev_num, j ? "non" : "auto", mode);
4056                                 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4057                                 goto out_free_tape;
4058                         }
4059                         STm->cdevs[j] = cdev;
4060
4061                 }
4062                 do_create_class_files(tpnt, dev_num, mode);
4063         }
4064
4065         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4066                 /* Make sure that the minor numbers corresponding to the four
4067                    first modes always get the same names */
4068                 i = mode << (4 - ST_NBR_MODE_BITS);
4069                 /*  Rewind entry  */
4070                 devfs_mk_cdev(MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, 0)),
4071                               S_IFCHR | S_IRUGO | S_IWUGO,
4072                               "%s/mt%s", SDp->devfs_name, st_formats[i]);
4073                 /*  No-rewind entry  */
4074                 devfs_mk_cdev(MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, 1)),
4075                               S_IFCHR | S_IRUGO | S_IWUGO,
4076                               "%s/mt%sn", SDp->devfs_name, st_formats[i]);
4077         }
4078         disk->number = devfs_register_tape(SDp->devfs_name);
4079
4080         printk(KERN_WARNING
4081         "Attached scsi tape %s at scsi%d, channel %d, id %d, lun %d\n",
4082                tape_name(tpnt), SDp->host->host_no, SDp->channel, SDp->id, SDp->lun);
4083         printk(KERN_WARNING "%s: try direct i/o: %s (alignment %d B), max page reachable by HBA %lu\n",
4084                tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4085                queue_dma_alignment(SDp->request_queue) + 1, tpnt->max_pfn);
4086
4087         return 0;
4088
4089 out_free_tape:
4090         for (mode=0; mode < ST_NBR_MODES; mode++) {
4091                 STm = &(tpnt->modes[mode]);
4092                 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4093                                   "tape");
4094                 for (j=0; j < 2; j++) {
4095                         if (STm->cdevs[j]) {
4096                                 if (cdev == STm->cdevs[j])
4097                                         cdev = NULL;
4098                                 class_device_destroy(st_sysfs_class,
4099                                                      MKDEV(SCSI_TAPE_MAJOR,
4100                                                            TAPE_MINOR(i, mode, j)));
4101                                 cdev_del(STm->cdevs[j]);
4102                         }
4103                 }
4104         }
4105         if (cdev)
4106                 cdev_del(cdev);
4107         write_lock(&st_dev_arr_lock);
4108         scsi_tapes[dev_num] = NULL;
4109         st_nr_dev--;
4110         write_unlock(&st_dev_arr_lock);
4111 out_put_disk:
4112         put_disk(disk);
4113         if (tpnt)
4114                 kfree(tpnt);
4115 out_buffer_free:
4116         kfree(buffer);
4117 out:
4118         return -ENODEV;
4119 };
4120
4121
4122 static int st_remove(struct device *dev)
4123 {
4124         struct scsi_device *SDp = to_scsi_device(dev);
4125         struct scsi_tape *tpnt;
4126         int i, j, mode;
4127
4128         write_lock(&st_dev_arr_lock);
4129         for (i = 0; i < st_dev_max; i++) {
4130                 tpnt = scsi_tapes[i];
4131                 if (tpnt != NULL && tpnt->device == SDp) {
4132                         scsi_tapes[i] = NULL;
4133                         st_nr_dev--;
4134                         write_unlock(&st_dev_arr_lock);
4135                         devfs_unregister_tape(tpnt->disk->number);
4136                         sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4137                                           "tape");
4138                         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4139                                 j = mode << (4 - ST_NBR_MODE_BITS);
4140                                 devfs_remove("%s/mt%s", SDp->devfs_name, st_formats[j]);
4141                                 devfs_remove("%s/mt%sn", SDp->devfs_name, st_formats[j]);
4142                                 for (j=0; j < 2; j++) {
4143                                         class_device_destroy(st_sysfs_class,
4144                                                              MKDEV(SCSI_TAPE_MAJOR,
4145                                                                    TAPE_MINOR(i, mode, j)));
4146                                         cdev_del(tpnt->modes[mode].cdevs[j]);
4147                                         tpnt->modes[mode].cdevs[j] = NULL;
4148                                 }
4149                         }
4150
4151                         down(&st_ref_sem);
4152                         kref_put(&tpnt->kref, scsi_tape_release);
4153                         up(&st_ref_sem);
4154                         return 0;
4155                 }
4156         }
4157
4158         write_unlock(&st_dev_arr_lock);
4159         return 0;
4160 }
4161
4162 /**
4163  *      scsi_tape_release - Called to free the Scsi_Tape structure
4164  *      @kref: pointer to embedded kref
4165  *
4166  *      st_ref_sem must be held entering this routine.  Because it is
4167  *      called on last put, you should always use the scsi_tape_get()
4168  *      scsi_tape_put() helpers which manipulate the semaphore directly
4169  *      and never do a direct kref_put().
4170  **/
4171 static void scsi_tape_release(struct kref *kref)
4172 {
4173         struct scsi_tape *tpnt = to_scsi_tape(kref);
4174         struct gendisk *disk = tpnt->disk;
4175
4176         tpnt->device = NULL;
4177
4178         if (tpnt->buffer) {
4179                 tpnt->buffer->orig_frp_segs = 0;
4180                 normalize_buffer(tpnt->buffer);
4181                 kfree(tpnt->buffer);
4182         }
4183
4184         disk->private_data = NULL;
4185         put_disk(disk);
4186         kfree(tpnt);
4187         return;
4188 }
4189
4190 static void st_intr(struct scsi_cmnd *SCpnt)
4191 {
4192         scsi_io_completion(SCpnt, (SCpnt->result ? 0: SCpnt->bufflen), 1);
4193 }
4194
4195 /*
4196  * st_init_command: only called via the scsi_cmd_ioctl (block SG_IO)
4197  * interface for REQ_BLOCK_PC commands.
4198  */
4199 static int st_init_command(struct scsi_cmnd *SCpnt)
4200 {
4201         struct request *rq;
4202
4203         if (!(SCpnt->request->flags & REQ_BLOCK_PC))
4204                 return 0;
4205
4206         rq = SCpnt->request;
4207         if (sizeof(rq->cmd) > sizeof(SCpnt->cmnd))
4208                 return 0;
4209
4210         memcpy(SCpnt->cmnd, rq->cmd, sizeof(SCpnt->cmnd));
4211         SCpnt->cmd_len = rq->cmd_len;
4212
4213         if (rq_data_dir(rq) == WRITE)
4214                 SCpnt->sc_data_direction = DMA_TO_DEVICE;
4215         else if (rq->data_len)
4216                 SCpnt->sc_data_direction = DMA_FROM_DEVICE;
4217         else
4218                 SCpnt->sc_data_direction = DMA_NONE;
4219
4220         SCpnt->timeout_per_command = rq->timeout;
4221         SCpnt->transfersize = rq->data_len;
4222         SCpnt->done = st_intr;
4223         return 1;
4224 }
4225
4226 static int __init init_st(void)
4227 {
4228         validate_options();
4229
4230         printk(KERN_INFO
4231                 "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4232                 verstr, st_fixed_buffer_size, st_max_sg_segs);
4233
4234         st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
4235         if (IS_ERR(st_sysfs_class)) {
4236                 st_sysfs_class = NULL;
4237                 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4238                 return 1;
4239         }
4240
4241         if (!register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4242                                     ST_MAX_TAPE_ENTRIES, "st")) {
4243                 if (scsi_register_driver(&st_template.gendrv) == 0) {
4244                         do_create_driverfs_files();
4245                         return 0;
4246                 }
4247                 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4248                                          ST_MAX_TAPE_ENTRIES);
4249         }
4250         class_destroy(st_sysfs_class);
4251
4252         printk(KERN_ERR "Unable to get major %d for SCSI tapes\n", SCSI_TAPE_MAJOR);
4253         return 1;
4254 }
4255
4256 static void __exit exit_st(void)
4257 {
4258         do_remove_driverfs_files();
4259         scsi_unregister_driver(&st_template.gendrv);
4260         unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4261                                  ST_MAX_TAPE_ENTRIES);
4262         class_destroy(st_sysfs_class);
4263         kfree(scsi_tapes);
4264         printk(KERN_INFO "st: Unloaded.\n");
4265 }
4266
4267 module_init(init_st);
4268 module_exit(exit_st);
4269
4270
4271 /* The sysfs driver interface. Read-only at the moment */
4272 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4273 {
4274         return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4275 }
4276 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4277
4278 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4279 {
4280         return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4281 }
4282 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4283
4284 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4285 {
4286         return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4287 }
4288 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4289
4290 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4291 {
4292         return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4293 }
4294 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4295
4296 static void do_create_driverfs_files(void)
4297 {
4298         struct device_driver *driverfs = &st_template.gendrv;
4299
4300         driver_create_file(driverfs, &driver_attr_try_direct_io);
4301         driver_create_file(driverfs, &driver_attr_fixed_buffer_size);
4302         driver_create_file(driverfs, &driver_attr_max_sg_segs);
4303         driver_create_file(driverfs, &driver_attr_version);
4304 }
4305
4306 static void do_remove_driverfs_files(void)
4307 {
4308         struct device_driver *driverfs = &st_template.gendrv;
4309
4310         driver_remove_file(driverfs, &driver_attr_version);
4311         driver_remove_file(driverfs, &driver_attr_max_sg_segs);
4312         driver_remove_file(driverfs, &driver_attr_fixed_buffer_size);
4313         driver_remove_file(driverfs, &driver_attr_try_direct_io);
4314 }
4315
4316
4317 /* The sysfs simple class interface */
4318 static ssize_t st_defined_show(struct class_device *class_dev, char *buf)
4319 {
4320         struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4321         ssize_t l = 0;
4322
4323         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4324         return l;
4325 }
4326
4327 CLASS_DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4328
4329 static ssize_t st_defblk_show(struct class_device *class_dev, char *buf)
4330 {
4331         struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4332         ssize_t l = 0;
4333
4334         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4335         return l;
4336 }
4337
4338 CLASS_DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4339
4340 static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf)
4341 {
4342         struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4343         ssize_t l = 0;
4344         char *fmt;
4345
4346         fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4347         l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4348         return l;
4349 }
4350
4351 CLASS_DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4352
4353 static ssize_t st_defcompression_show(struct class_device *class_dev, char *buf)
4354 {
4355         struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4356         ssize_t l = 0;
4357
4358         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4359         return l;
4360 }
4361
4362 CLASS_DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4363
4364 static void do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4365 {
4366         int i, rew, error;
4367         char name[10];
4368         struct class_device *st_class_member;
4369
4370         if (!st_sysfs_class)
4371                 return;
4372
4373         for (rew=0; rew < 2; rew++) {
4374                 /* Make sure that the minor numbers corresponding to the four
4375                    first modes always get the same names */
4376                 i = mode << (4 - ST_NBR_MODE_BITS);
4377                 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4378                          STp->disk->disk_name, st_formats[i]);
4379                 st_class_member =
4380                         class_device_create(st_sysfs_class, NULL,
4381                                             MKDEV(SCSI_TAPE_MAJOR,
4382                                                   TAPE_MINOR(dev_num, mode, rew)),
4383                                             &STp->device->sdev_gendev, "%s", name);
4384                 if (IS_ERR(st_class_member)) {
4385                         printk(KERN_WARNING "st%d: class_device_create failed\n",
4386                                dev_num);
4387                         goto out;
4388                 }
4389                 class_set_devdata(st_class_member, &STp->modes[mode]);
4390
4391                 class_device_create_file(st_class_member,
4392                                          &class_device_attr_defined);
4393                 class_device_create_file(st_class_member,
4394                                          &class_device_attr_default_blksize);
4395                 class_device_create_file(st_class_member,
4396                                          &class_device_attr_default_density);
4397                 class_device_create_file(st_class_member,
4398                                          &class_device_attr_default_compression);
4399                 if (mode == 0 && rew == 0) {
4400                         error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4401                                                   &st_class_member->kobj,
4402                                                   "tape");
4403                         if (error) {
4404                                 printk(KERN_ERR
4405                                        "st%d: Can't create sysfs link from SCSI device.\n",
4406                                        dev_num);
4407                         }
4408                 }
4409         }
4410  out:
4411         return;
4412 }
4413
4414
4415 /* Pin down user pages and put them into a scatter gather list. Returns <= 0 if
4416    - mapping of all pages not successful
4417    - any page is above max_pfn
4418    (i.e., either completely successful or fails)
4419 */
4420 static int st_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4421                              unsigned long uaddr, size_t count, int rw,
4422                              unsigned long max_pfn)
4423 {
4424         int i, nr_pages;
4425
4426         nr_pages = sgl_map_user_pages(sgl, max_pages, uaddr, count, rw);
4427         if (nr_pages <= 0)
4428                 return nr_pages;
4429
4430         for (i=0; i < nr_pages; i++) {
4431                 if (page_to_pfn(sgl[i].page) > max_pfn)
4432                         goto out_unmap;
4433         }
4434         return nr_pages;
4435
4436  out_unmap:
4437         sgl_unmap_user_pages(sgl, nr_pages, 0);
4438         return 0;
4439 }
4440
4441
4442 /* The following functions may be useful for a larger audience. */
4443 static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4444                               unsigned long uaddr, size_t count, int rw)
4445 {
4446         unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4447         unsigned long start = uaddr >> PAGE_SHIFT;
4448         const int nr_pages = end - start;
4449         int res, i, j;
4450         struct page **pages;
4451
4452         /* User attempted Overflow! */
4453         if ((uaddr + count) < uaddr)
4454                 return -EINVAL;
4455
4456         /* Too big */
4457         if (nr_pages > max_pages)
4458                 return -ENOMEM;
4459
4460         /* Hmm? */
4461         if (count == 0)
4462                 return 0;
4463
4464         if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4465                 return -ENOMEM;
4466
4467         /* Try to fault in all of the necessary pages */
4468         down_read(&current->mm->mmap_sem);
4469         /* rw==READ means read from drive, write into memory area */
4470         res = get_user_pages(
4471                 current,
4472                 current->mm,
4473                 uaddr,
4474                 nr_pages,
4475                 rw == READ,
4476                 0, /* don't force */
4477                 pages,
4478                 NULL);
4479         up_read(&current->mm->mmap_sem);
4480
4481         /* Errors and no page mapped should return here */
4482         if (res < nr_pages)
4483                 goto out_unmap;
4484
4485         for (i=0; i < nr_pages; i++) {
4486                 /* FIXME: flush superflous for rw==READ,
4487                  * probably wrong function for rw==WRITE
4488                  */
4489                 flush_dcache_page(pages[i]);
4490         }
4491
4492         /* Populate the scatter/gather list */
4493         sgl[0].page = pages[0];
4494         sgl[0].offset = uaddr & ~PAGE_MASK;
4495         if (nr_pages > 1) {
4496                 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4497                 count -= sgl[0].length;
4498                 for (i=1; i < nr_pages ; i++) {
4499                         sgl[i].offset = 0;
4500                         sgl[i].page = pages[i];
4501                         sgl[i].length = count < PAGE_SIZE ? count : PAGE_SIZE;
4502                         count -= PAGE_SIZE;
4503                 }
4504         }
4505         else {
4506                 sgl[0].length = count;
4507         }
4508
4509         kfree(pages);
4510         return nr_pages;
4511
4512  out_unmap:
4513         if (res > 0) {
4514                 for (j=0; j < res; j++)
4515                         page_cache_release(pages[j]);
4516         }
4517         kfree(pages);
4518         return res;
4519 }
4520
4521
4522 /* And unmap them... */
4523 static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4524                                 int dirtied)
4525 {
4526         int i;
4527
4528         for (i=0; i < nr_pages; i++) {
4529                 struct page *page = sgl[i].page;
4530
4531                 /* XXX: just for debug. Remove when PageReserved is removed */
4532                 BUG_ON(PageReserved(page));
4533                 if (dirtied)
4534                         SetPageDirty(page);
4535                 /* FIXME: cache flush missing for rw==READ
4536                  * FIXME: call the correct reference counting function
4537                  */
4538                 page_cache_release(page);
4539         }
4540
4541         return 0;
4542 }