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

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