drivers/scsi/st.c

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