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

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