SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/scsi/st.c

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