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

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