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