Merge branch 'linus'
[linux-2.6.git] / 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 - 2007 Kai Makisara
13    email Kai.Makisara@kolumbus.fi
14
15    Some small formal changes - aeb, 950809
16
17    Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
18  */
19
20 static const char *verstr = "20070203";
21
22 #include <linux/module.h>
23
24 #include <linux/fs.h>
25 #include <linux/kernel.h>
26 #include <linux/sched.h>
27 #include <linux/mm.h>
28 #include <linux/init.h>
29 #include <linux/string.h>
30 #include <linux/errno.h>
31 #include <linux/mtio.h>
32 #include <linux/cdrom.h>
33 #include <linux/ioctl.h>
34 #include <linux/fcntl.h>
35 #include <linux/spinlock.h>
36 #include <linux/blkdev.h>
37 #include <linux/moduleparam.h>
38 #include <linux/cdev.h>
39 #include <linux/delay.h>
40 #include <linux/mutex.h>
41
42 #include <asm/uaccess.h>
43 #include <asm/dma.h>
44 #include <asm/system.h>
45
46 #include <scsi/scsi.h>
47 #include <scsi/scsi_dbg.h>
48 #include <scsi/scsi_device.h>
49 #include <scsi/scsi_driver.h>
50 #include <scsi/scsi_eh.h>
51 #include <scsi/scsi_host.h>
52 #include <scsi/scsi_ioctl.h>
53 #include <scsi/sg.h>
54
55
56 /* The driver prints some debugging information on the console if DEBUG
57    is defined and non-zero. */
58 #define DEBUG 0
59
60 #if DEBUG
61 /* The message level for the debug messages is currently set to KERN_NOTICE
62    so that people can easily see the messages. Later when the debugging messages
63    in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
64 #define ST_DEB_MSG  KERN_NOTICE
65 #define DEB(a) a
66 #define DEBC(a) if (debugging) { a ; }
67 #else
68 #define DEB(a)
69 #define DEBC(a)
70 #endif
71
72 #define ST_KILOBYTE 1024
73
74 #include "st_options.h"
75 #include "st.h"
76
77 static int buffer_kbs;
78 static int max_sg_segs;
79 static int try_direct_io = TRY_DIRECT_IO;
80 static int try_rdio = 1;
81 static int try_wdio = 1;
82
83 static int st_dev_max;
84 static int st_nr_dev;
85
86 static struct class *st_sysfs_class;
87
88 MODULE_AUTHOR("Kai Makisara");
89 MODULE_DESCRIPTION("SCSI tape (st) driver");
90 MODULE_LICENSE("GPL");
91 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
92
93 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
94  * of sysfs parameters (which module_param doesn't yet support).
95  * Sysfs parameters defined explicitly later.
96  */
97 module_param_named(buffer_kbs, buffer_kbs, int, 0);
98 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
99 module_param_named(max_sg_segs, max_sg_segs, int, 0);
100 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
101 module_param_named(try_direct_io, try_direct_io, int, 0);
102 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
103
104 /* Extra parameters for testing */
105 module_param_named(try_rdio, try_rdio, int, 0);
106 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
107 module_param_named(try_wdio, try_wdio, int, 0);
108 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
109
110 #ifndef MODULE
111 static int write_threshold_kbs;  /* retained for compatibility */
112 static struct st_dev_parm {
113         char *name;
114         int *val;
115 } parms[] __initdata = {
116         {
117                 "buffer_kbs", &buffer_kbs
118         },
119         {       /* Retained for compatibility with 2.4 */
120                 "write_threshold_kbs", &write_threshold_kbs
121         },
122         {
123                 "max_sg_segs", NULL
124         },
125         {
126                 "try_direct_io", &try_direct_io
127         }
128 };
129 #endif
130
131 /* Restrict the number of modes so that names for all are assigned */
132 #if ST_NBR_MODES > 16
133 #error "Maximum number of modes is 16"
134 #endif
135 /* Bit reversed order to get same names for same minors with all
136    mode counts */
137 static const char *st_formats[] = {
138         "",  "r", "k", "s", "l", "t", "o", "u",
139         "m", "v", "p", "x", "a", "y", "q", "z"}; 
140
141 /* The default definitions have been moved to st_options.h */
142
143 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
144
145 /* The buffer size should fit into the 24 bits for length in the
146    6-byte SCSI read and write commands. */
147 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
148 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
149 #endif
150
151 static int debugging = DEBUG;
152
153 #define MAX_RETRIES 0
154 #define MAX_WRITE_RETRIES 0
155 #define MAX_READY_RETRIES 0
156 #define NO_TAPE  NOT_READY
157
158 #define ST_TIMEOUT (900 * HZ)
159 #define ST_LONG_TIMEOUT (14000 * HZ)
160
161 /* Remove mode bits and auto-rewind bit (7) */
162 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
163     (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
164 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
165
166 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
167 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
168   (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
169
170 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
171    24 bits) */
172 #define SET_DENS_AND_BLK 0x10001
173
174 static DEFINE_RWLOCK(st_dev_arr_lock);
175
176 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
177 static int st_max_sg_segs = ST_MAX_SG;
178
179 static struct scsi_tape **scsi_tapes = NULL;
180
181 static int modes_defined;
182
183 static struct st_buffer *new_tape_buffer(int, int, int);
184 static int enlarge_buffer(struct st_buffer *, int, int);
185 static void normalize_buffer(struct st_buffer *);
186 static int append_to_buffer(const char __user *, struct st_buffer *, int);
187 static int from_buffer(struct st_buffer *, char __user *, int);
188 static void move_buffer_data(struct st_buffer *, int);
189 static void buf_to_sg(struct st_buffer *, unsigned int);
190
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
198 static int do_create_driverfs_files(void);
199 static void do_remove_driverfs_files(void);
200 static int do_create_class_files(struct scsi_tape *, int, int);
201
202 static struct scsi_driver st_template = {
203         .owner                  = THIS_MODULE,
204         .gendrv = {
205                 .name           = "st",
206                 .probe          = st_probe,
207                 .remove         = st_remove,
208         },
209 };
210
211 static int st_compression(struct scsi_tape *, int);
212
213 static int find_partition(struct scsi_tape *);
214 static int switch_partition(struct scsi_tape *);
215
216 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
217
218 static void scsi_tape_release(struct kref *);
219
220 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
221
222 static DEFINE_MUTEX(st_ref_mutex);
223
224 \f
225 #include "osst_detect.h"
226 #ifndef SIGS_FROM_OSST
227 #define SIGS_FROM_OSST \
228         {"OnStream", "SC-", "", "osst"}, \
229         {"OnStream", "DI-", "", "osst"}, \
230         {"OnStream", "DP-", "", "osst"}, \
231         {"OnStream", "USB", "", "osst"}, \
232         {"OnStream", "FW-", "", "osst"}
233 #endif
234
235 static struct scsi_tape *scsi_tape_get(int dev)
236 {
237         struct scsi_tape *STp = NULL;
238
239         mutex_lock(&st_ref_mutex);
240         write_lock(&st_dev_arr_lock);
241
242         if (dev < st_dev_max && scsi_tapes != NULL)
243                 STp = scsi_tapes[dev];
244         if (!STp) goto out;
245
246         kref_get(&STp->kref);
247
248         if (!STp->device)
249                 goto out_put;
250
251         if (scsi_device_get(STp->device))
252                 goto out_put;
253
254         goto out;
255
256 out_put:
257         kref_put(&STp->kref, scsi_tape_release);
258         STp = NULL;
259 out:
260         write_unlock(&st_dev_arr_lock);
261         mutex_unlock(&st_ref_mutex);
262         return STp;
263 }
264
265 static void scsi_tape_put(struct scsi_tape *STp)
266 {
267         struct scsi_device *sdev = STp->device;
268
269         mutex_lock(&st_ref_mutex);
270         kref_put(&STp->kref, scsi_tape_release);
271         scsi_device_put(sdev);
272         mutex_unlock(&st_ref_mutex);
273 }
274
275 struct st_reject_data {
276         char *vendor;
277         char *model;
278         char *rev;
279         char *driver_hint; /* Name of the correct driver, NULL if unknown */
280 };
281
282 static struct st_reject_data reject_list[] = {
283         /* {"XXX", "Yy-", "", NULL},  example */
284         SIGS_FROM_OSST,
285         {NULL, }};
286
287 /* If the device signature is on the list of incompatible drives, the
288    function returns a pointer to the name of the correct driver (if known) */
289 static char * st_incompatible(struct scsi_device* SDp)
290 {
291         struct st_reject_data *rp;
292
293         for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
294                 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
295                     !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
296                     !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
297                         if (rp->driver_hint)
298                                 return rp->driver_hint;
299                         else
300                                 return "unknown";
301                 }
302         return NULL;
303 }
304 \f
305
306 static inline char *tape_name(struct scsi_tape *tape)
307 {
308         return tape->disk->disk_name;
309 }
310
311
312 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
313 {
314         const u8 *ucp;
315         const u8 *sense = SRpnt->sense;
316
317         s->have_sense = scsi_normalize_sense(SRpnt->sense,
318                                 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
319         s->flags = 0;
320
321         if (s->have_sense) {
322                 s->deferred = 0;
323                 s->remainder_valid =
324                         scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
325                 switch (sense[0] & 0x7f) {
326                 case 0x71:
327                         s->deferred = 1;
328                 case 0x70:
329                         s->fixed_format = 1;
330                         s->flags = sense[2] & 0xe0;
331                         break;
332                 case 0x73:
333                         s->deferred = 1;
334                 case 0x72:
335                         s->fixed_format = 0;
336                         ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
337                         s->flags = ucp ? (ucp[3] & 0xe0) : 0;
338                         break;
339                 }
340         }
341 }
342
343
344 /* Convert the result to success code */
345 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
346 {
347         int result = SRpnt->result;
348         u8 scode;
349         DEB(const char *stp;)
350         char *name = tape_name(STp);
351         struct st_cmdstatus *cmdstatp;
352
353         if (!result)
354                 return 0;
355
356         cmdstatp = &STp->buffer->cmdstat;
357         st_analyze_sense(SRpnt, cmdstatp);
358
359         if (cmdstatp->have_sense)
360                 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
361         else
362                 scode = 0;
363
364         DEB(
365         if (debugging) {
366                 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
367                        name, result,
368                        SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
369                        SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
370                 if (cmdstatp->have_sense)
371                          __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
372         } ) /* end DEB */
373         if (!debugging) { /* Abnormal conditions for tape */
374                 if (!cmdstatp->have_sense)
375                         printk(KERN_WARNING
376                                "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
377                                name, result, suggestion(result),
378                                driver_byte(result) & DRIVER_MASK, host_byte(result));
379                 else if (cmdstatp->have_sense &&
380                          scode != NO_SENSE &&
381                          scode != RECOVERED_ERROR &&
382                          /* scode != UNIT_ATTENTION && */
383                          scode != BLANK_CHECK &&
384                          scode != VOLUME_OVERFLOW &&
385                          SRpnt->cmd[0] != MODE_SENSE &&
386                          SRpnt->cmd[0] != TEST_UNIT_READY) {
387
388                         __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
389                 }
390         }
391
392         if (cmdstatp->fixed_format &&
393             STp->cln_mode >= EXTENDED_SENSE_START) {  /* Only fixed format sense */
394                 if (STp->cln_sense_value)
395                         STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
396                                                STp->cln_sense_mask) == STp->cln_sense_value);
397                 else
398                         STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
399                                                STp->cln_sense_mask) != 0);
400         }
401         if (cmdstatp->have_sense &&
402             cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
403                 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
404
405         STp->pos_unknown |= STp->device->was_reset;
406
407         if (cmdstatp->have_sense &&
408             scode == RECOVERED_ERROR
409 #if ST_RECOVERED_WRITE_FATAL
410             && SRpnt->cmd[0] != WRITE_6
411             && SRpnt->cmd[0] != WRITE_FILEMARKS
412 #endif
413             ) {
414                 STp->recover_count++;
415                 STp->recover_reg++;
416
417                 DEB(
418                 if (debugging) {
419                         if (SRpnt->cmd[0] == READ_6)
420                                 stp = "read";
421                         else if (SRpnt->cmd[0] == WRITE_6)
422                                 stp = "write";
423                         else
424                                 stp = "ioctl";
425                         printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
426                                STp->recover_count);
427                 } ) /* end DEB */
428
429                 if (cmdstatp->flags == 0)
430                         return 0;
431         }
432         return (-EIO);
433 }
434
435
436 /* Wakeup from interrupt */
437 static void st_sleep_done(void *data, char *sense, int result, int resid)
438 {
439         struct st_request *SRpnt = data;
440         struct scsi_tape *STp = SRpnt->stp;
441
442         memcpy(SRpnt->sense, sense, SCSI_SENSE_BUFFERSIZE);
443         (STp->buffer)->cmdstat.midlevel_result = SRpnt->result = result;
444         DEB( STp->write_pending = 0; )
445
446         if (SRpnt->waiting)
447                 complete(SRpnt->waiting);
448 }
449
450 static struct st_request *st_allocate_request(void)
451 {
452         return kzalloc(sizeof(struct st_request), GFP_KERNEL);
453 }
454
455 static void st_release_request(struct st_request *streq)
456 {
457         kfree(streq);
458 }
459
460 /* Do the scsi command. Waits until command performed if do_wait is true.
461    Otherwise write_behind_check() is used to check that the command
462    has finished. */
463 static struct st_request *
464 st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
465            int bytes, int direction, int timeout, int retries, int do_wait)
466 {
467         struct completion *waiting;
468
469         /* if async, make sure there's no command outstanding */
470         if (!do_wait && ((STp->buffer)->last_SRpnt)) {
471                 printk(KERN_ERR "%s: Async command already active.\n",
472                        tape_name(STp));
473                 if (signal_pending(current))
474                         (STp->buffer)->syscall_result = (-EINTR);
475                 else
476                         (STp->buffer)->syscall_result = (-EBUSY);
477                 return NULL;
478         }
479
480         if (SRpnt == NULL) {
481                 SRpnt = st_allocate_request();
482                 if (SRpnt == NULL) {
483                         DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n",
484                                      tape_name(STp)); );
485                         if (signal_pending(current))
486                                 (STp->buffer)->syscall_result = (-EINTR);
487                         else
488                                 (STp->buffer)->syscall_result = (-EBUSY);
489                         return NULL;
490                 }
491                 SRpnt->stp = STp;
492         }
493
494         /* If async IO, set last_SRpnt. This ptr tells write_behind_check
495            which IO is outstanding. It's nulled out when the IO completes. */
496         if (!do_wait)
497                 (STp->buffer)->last_SRpnt = SRpnt;
498
499         waiting = &STp->wait;
500         init_completion(waiting);
501         SRpnt->waiting = waiting;
502
503         if (!STp->buffer->do_dio)
504                 buf_to_sg(STp->buffer, bytes);
505
506         memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
507         STp->buffer->cmdstat.have_sense = 0;
508         STp->buffer->syscall_result = 0;
509
510         if (scsi_execute_async(STp->device, cmd, COMMAND_SIZE(cmd[0]), direction,
511                         &((STp->buffer)->sg[0]), bytes, (STp->buffer)->sg_segs,
512                                timeout, retries, SRpnt, st_sleep_done, GFP_KERNEL)) {
513                 /* could not allocate the buffer or request was too large */
514                 (STp->buffer)->syscall_result = (-EBUSY);
515                 (STp->buffer)->last_SRpnt = NULL;
516         }
517         else if (do_wait) {
518                 wait_for_completion(waiting);
519                 SRpnt->waiting = NULL;
520                 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
521         }
522
523         return SRpnt;
524 }
525
526
527 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
528    write has been correct but EOM early warning reached, -EIO if write ended in
529    error or zero if write successful. Asynchronous writes are used only in
530    variable block mode. */
531 static int write_behind_check(struct scsi_tape * STp)
532 {
533         int retval = 0;
534         struct st_buffer *STbuffer;
535         struct st_partstat *STps;
536         struct st_cmdstatus *cmdstatp;
537         struct st_request *SRpnt;
538
539         STbuffer = STp->buffer;
540         if (!STbuffer->writing)
541                 return 0;
542
543         DEB(
544         if (STp->write_pending)
545                 STp->nbr_waits++;
546         else
547                 STp->nbr_finished++;
548         ) /* end DEB */
549
550         wait_for_completion(&(STp->wait));
551         SRpnt = STbuffer->last_SRpnt;
552         STbuffer->last_SRpnt = NULL;
553         SRpnt->waiting = NULL;
554
555         (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
556         st_release_request(SRpnt);
557
558         STbuffer->buffer_bytes -= STbuffer->writing;
559         STps = &(STp->ps[STp->partition]);
560         if (STps->drv_block >= 0) {
561                 if (STp->block_size == 0)
562                         STps->drv_block++;
563                 else
564                         STps->drv_block += STbuffer->writing / STp->block_size;
565         }
566
567         cmdstatp = &STbuffer->cmdstat;
568         if (STbuffer->syscall_result) {
569                 retval = -EIO;
570                 if (cmdstatp->have_sense && !cmdstatp->deferred &&
571                     (cmdstatp->flags & SENSE_EOM) &&
572                     (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
573                      cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
574                         /* EOM at write-behind, has all data been written? */
575                         if (!cmdstatp->remainder_valid ||
576                             cmdstatp->uremainder64 == 0)
577                                 retval = -ENOSPC;
578                 }
579                 if (retval == -EIO)
580                         STps->drv_block = -1;
581         }
582         STbuffer->writing = 0;
583
584         DEB(if (debugging && retval)
585             printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n",
586                    tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
587
588         return retval;
589 }
590
591
592 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
593    it messes up the block number). */
594 static int cross_eof(struct scsi_tape * STp, int forward)
595 {
596         struct st_request *SRpnt;
597         unsigned char cmd[MAX_COMMAND_SIZE];
598
599         cmd[0] = SPACE;
600         cmd[1] = 0x01;          /* Space FileMarks */
601         if (forward) {
602                 cmd[2] = cmd[3] = 0;
603                 cmd[4] = 1;
604         } else
605                 cmd[2] = cmd[3] = cmd[4] = 0xff;        /* -1 filemarks */
606         cmd[5] = 0;
607
608         DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
609                    tape_name(STp), forward ? "forward" : "backward"));
610
611         SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
612                            STp->device->timeout, MAX_RETRIES, 1);
613         if (!SRpnt)
614                 return (STp->buffer)->syscall_result;
615
616         st_release_request(SRpnt);
617         SRpnt = NULL;
618
619         if ((STp->buffer)->cmdstat.midlevel_result != 0)
620                 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
621                    tape_name(STp), forward ? "forward" : "backward");
622
623         return (STp->buffer)->syscall_result;
624 }
625
626
627 /* Flush the write buffer (never need to write if variable blocksize). */
628 static int flush_write_buffer(struct scsi_tape * STp)
629 {
630         int offset, transfer, blks;
631         int result;
632         unsigned char cmd[MAX_COMMAND_SIZE];
633         struct st_request *SRpnt;
634         struct st_partstat *STps;
635
636         result = write_behind_check(STp);
637         if (result)
638                 return result;
639
640         result = 0;
641         if (STp->dirty == 1) {
642
643                 offset = (STp->buffer)->buffer_bytes;
644                 transfer = ((offset + STp->block_size - 1) /
645                             STp->block_size) * STp->block_size;
646                 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
647                                tape_name(STp), transfer));
648
649                 memset((STp->buffer)->b_data + offset, 0, transfer - offset);
650
651                 memset(cmd, 0, MAX_COMMAND_SIZE);
652                 cmd[0] = WRITE_6;
653                 cmd[1] = 1;
654                 blks = transfer / STp->block_size;
655                 cmd[2] = blks >> 16;
656                 cmd[3] = blks >> 8;
657                 cmd[4] = blks;
658
659                 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
660                                    STp->device->timeout, MAX_WRITE_RETRIES, 1);
661                 if (!SRpnt)
662                         return (STp->buffer)->syscall_result;
663
664                 STps = &(STp->ps[STp->partition]);
665                 if ((STp->buffer)->syscall_result != 0) {
666                         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
667
668                         if (cmdstatp->have_sense && !cmdstatp->deferred &&
669                             (cmdstatp->flags & SENSE_EOM) &&
670                             (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
671                              cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
672                             (!cmdstatp->remainder_valid ||
673                              cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
674                                 STp->dirty = 0;
675                                 (STp->buffer)->buffer_bytes = 0;
676                                 if (STps->drv_block >= 0)
677                                         STps->drv_block += blks;
678                                 result = (-ENOSPC);
679                         } else {
680                                 printk(KERN_ERR "%s: Error on flush.\n",
681                                        tape_name(STp));
682                                 STps->drv_block = (-1);
683                                 result = (-EIO);
684                         }
685                 } else {
686                         if (STps->drv_block >= 0)
687                                 STps->drv_block += blks;
688                         STp->dirty = 0;
689                         (STp->buffer)->buffer_bytes = 0;
690                 }
691                 st_release_request(SRpnt);
692                 SRpnt = NULL;
693         }
694         return result;
695 }
696
697
698 /* Flush the tape buffer. The tape will be positioned correctly unless
699    seek_next is true. */
700 static int flush_buffer(struct scsi_tape *STp, int seek_next)
701 {
702         int backspace, result;
703         struct st_buffer *STbuffer;
704         struct st_partstat *STps;
705
706         STbuffer = STp->buffer;
707
708         /*
709          * If there was a bus reset, block further access
710          * to this device.
711          */
712         if (STp->pos_unknown)
713                 return (-EIO);
714
715         if (STp->ready != ST_READY)
716                 return 0;
717         STps = &(STp->ps[STp->partition]);
718         if (STps->rw == ST_WRITING)     /* Writing */
719                 return flush_write_buffer(STp);
720
721         if (STp->block_size == 0)
722                 return 0;
723
724         backspace = ((STp->buffer)->buffer_bytes +
725                      (STp->buffer)->read_pointer) / STp->block_size -
726             ((STp->buffer)->read_pointer + STp->block_size - 1) /
727             STp->block_size;
728         (STp->buffer)->buffer_bytes = 0;
729         (STp->buffer)->read_pointer = 0;
730         result = 0;
731         if (!seek_next) {
732                 if (STps->eof == ST_FM_HIT) {
733                         result = cross_eof(STp, 0);     /* Back over the EOF hit */
734                         if (!result)
735                                 STps->eof = ST_NOEOF;
736                         else {
737                                 if (STps->drv_file >= 0)
738                                         STps->drv_file++;
739                                 STps->drv_block = 0;
740                         }
741                 }
742                 if (!result && backspace > 0)
743                         result = st_int_ioctl(STp, MTBSR, backspace);
744         } else if (STps->eof == ST_FM_HIT) {
745                 if (STps->drv_file >= 0)
746                         STps->drv_file++;
747                 STps->drv_block = 0;
748                 STps->eof = ST_NOEOF;
749         }
750         return result;
751
752 }
753 \f
754 /* Set the mode parameters */
755 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
756 {
757         int set_it = 0;
758         unsigned long arg;
759         char *name = tape_name(STp);
760
761         if (!STp->density_changed &&
762             STm->default_density >= 0 &&
763             STm->default_density != STp->density) {
764                 arg = STm->default_density;
765                 set_it = 1;
766         } else
767                 arg = STp->density;
768         arg <<= MT_ST_DENSITY_SHIFT;
769         if (!STp->blksize_changed &&
770             STm->default_blksize >= 0 &&
771             STm->default_blksize != STp->block_size) {
772                 arg |= STm->default_blksize;
773                 set_it = 1;
774         } else
775                 arg |= STp->block_size;
776         if (set_it &&
777             st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
778                 printk(KERN_WARNING
779                        "%s: Can't set default block size to %d bytes and density %x.\n",
780                        name, STm->default_blksize, STm->default_density);
781                 if (modes_defined)
782                         return (-EINVAL);
783         }
784         return 0;
785 }
786
787
788 /* Lock or unlock the drive door. Don't use when st_request allocated. */
789 static int do_door_lock(struct scsi_tape * STp, int do_lock)
790 {
791         int retval, cmd;
792         DEB(char *name = tape_name(STp);)
793
794
795         cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
796         DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
797                     do_lock ? "L" : "Unl"));
798         retval = scsi_ioctl(STp->device, cmd, NULL);
799         if (!retval) {
800                 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
801         }
802         else {
803                 STp->door_locked = ST_LOCK_FAILS;
804         }
805         return retval;
806 }
807
808
809 /* Set the internal state after reset */
810 static void reset_state(struct scsi_tape *STp)
811 {
812         int i;
813         struct st_partstat *STps;
814
815         STp->pos_unknown = 0;
816         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
817                 STps = &(STp->ps[i]);
818                 STps->rw = ST_IDLE;
819                 STps->eof = ST_NOEOF;
820                 STps->at_sm = 0;
821                 STps->last_block_valid = 0;
822                 STps->drv_block = -1;
823                 STps->drv_file = -1;
824         }
825         if (STp->can_partitions) {
826                 STp->partition = find_partition(STp);
827                 if (STp->partition < 0)
828                         STp->partition = 0;
829                 STp->new_partition = STp->partition;
830         }
831 }
832 \f
833 /* Test if the drive is ready. Returns either one of the codes below or a negative system
834    error code. */
835 #define CHKRES_READY       0
836 #define CHKRES_NEW_SESSION 1
837 #define CHKRES_NOT_READY   2
838 #define CHKRES_NO_TAPE     3
839
840 #define MAX_ATTENTIONS    10
841
842 static int test_ready(struct scsi_tape *STp, int do_wait)
843 {
844         int attentions, waits, max_wait, scode;
845         int retval = CHKRES_READY, new_session = 0;
846         unsigned char cmd[MAX_COMMAND_SIZE];
847         struct st_request *SRpnt = NULL;
848         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
849
850         max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
851
852         for (attentions=waits=0; ; ) {
853                 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
854                 cmd[0] = TEST_UNIT_READY;
855                 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
856                                    STp->long_timeout, MAX_READY_RETRIES, 1);
857
858                 if (!SRpnt) {
859                         retval = (STp->buffer)->syscall_result;
860                         break;
861                 }
862
863                 if (cmdstatp->have_sense) {
864
865                         scode = cmdstatp->sense_hdr.sense_key;
866
867                         if (scode == UNIT_ATTENTION) { /* New media? */
868                                 new_session = 1;
869                                 if (attentions < MAX_ATTENTIONS) {
870                                         attentions++;
871                                         continue;
872                                 }
873                                 else {
874                                         retval = (-EIO);
875                                         break;
876                                 }
877                         }
878
879                         if (scode == NOT_READY) {
880                                 if (waits < max_wait) {
881                                         if (msleep_interruptible(1000)) {
882                                                 retval = (-EINTR);
883                                                 break;
884                                         }
885                                         waits++;
886                                         continue;
887                                 }
888                                 else {
889                                         if ((STp->device)->scsi_level >= SCSI_2 &&
890                                             cmdstatp->sense_hdr.asc == 0x3a)    /* Check ASC */
891                                                 retval = CHKRES_NO_TAPE;
892                                         else
893                                                 retval = CHKRES_NOT_READY;
894                                         break;
895                                 }
896                         }
897                 }
898
899                 retval = (STp->buffer)->syscall_result;
900                 if (!retval)
901                         retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
902                 break;
903         }
904
905         if (SRpnt != NULL)
906                 st_release_request(SRpnt);
907         return retval;
908 }
909
910
911 /* See if the drive is ready and gather information about the tape. Return values:
912    < 0   negative error code from errno.h
913    0     drive ready
914    1     drive not ready (possibly no tape)
915 */
916 static int check_tape(struct scsi_tape *STp, struct file *filp)
917 {
918         int i, retval, new_session = 0, do_wait;
919         unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
920         unsigned short st_flags = filp->f_flags;
921         struct st_request *SRpnt = NULL;
922         struct st_modedef *STm;
923         struct st_partstat *STps;
924         char *name = tape_name(STp);
925         struct inode *inode = filp->f_path.dentry->d_inode;
926         int mode = TAPE_MODE(inode);
927
928         STp->ready = ST_READY;
929
930         if (mode != STp->current_mode) {
931                 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
932                                name, STp->current_mode, mode));
933                 new_session = 1;
934                 STp->current_mode = mode;
935         }
936         STm = &(STp->modes[STp->current_mode]);
937
938         saved_cleaning = STp->cleaning_req;
939         STp->cleaning_req = 0;
940
941         do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
942         retval = test_ready(STp, do_wait);
943
944         if (retval < 0)
945             goto err_out;
946
947         if (retval == CHKRES_NEW_SESSION) {
948                 STp->pos_unknown = 0;
949                 STp->partition = STp->new_partition = 0;
950                 if (STp->can_partitions)
951                         STp->nbr_partitions = 1; /* This guess will be updated later
952                                                     if necessary */
953                 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
954                         STps = &(STp->ps[i]);
955                         STps->rw = ST_IDLE;
956                         STps->eof = ST_NOEOF;
957                         STps->at_sm = 0;
958                         STps->last_block_valid = 0;
959                         STps->drv_block = 0;
960                         STps->drv_file = 0;
961                 }
962                 new_session = 1;
963         }
964         else {
965                 STp->cleaning_req |= saved_cleaning;
966
967                 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
968                         if (retval == CHKRES_NO_TAPE)
969                                 STp->ready = ST_NO_TAPE;
970                         else
971                                 STp->ready = ST_NOT_READY;
972
973                         STp->density = 0;       /* Clear the erroneous "residue" */
974                         STp->write_prot = 0;
975                         STp->block_size = 0;
976                         STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
977                         STp->partition = STp->new_partition = 0;
978                         STp->door_locked = ST_UNLOCKED;
979                         return CHKRES_NOT_READY;
980                 }
981         }
982
983         if (STp->omit_blklims)
984                 STp->min_block = STp->max_block = (-1);
985         else {
986                 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
987                 cmd[0] = READ_BLOCK_LIMITS;
988
989                 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
990                                    STp->device->timeout, MAX_READY_RETRIES, 1);
991                 if (!SRpnt) {
992                         retval = (STp->buffer)->syscall_result;
993                         goto err_out;
994                 }
995
996                 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
997                         STp->max_block = ((STp->buffer)->b_data[1] << 16) |
998                             ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
999                         STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1000                             (STp->buffer)->b_data[5];
1001                         if ( DEB( debugging || ) !STp->inited)
1002                                 printk(KERN_INFO
1003                                        "%s: Block limits %d - %d bytes.\n", name,
1004                                        STp->min_block, STp->max_block);
1005                 } else {
1006                         STp->min_block = STp->max_block = (-1);
1007                         DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1008                                        name));
1009                 }
1010         }
1011
1012         memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1013         cmd[0] = MODE_SENSE;
1014         cmd[4] = 12;
1015
1016         SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1017                         STp->device->timeout, MAX_READY_RETRIES, 1);
1018         if (!SRpnt) {
1019                 retval = (STp->buffer)->syscall_result;
1020                 goto err_out;
1021         }
1022
1023         if ((STp->buffer)->syscall_result != 0) {
1024                 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1025                 STp->block_size = ST_DEFAULT_BLOCK;     /* Educated guess (?) */
1026                 (STp->buffer)->syscall_result = 0;      /* Prevent error propagation */
1027                 STp->drv_write_prot = 0;
1028         } else {
1029                 DEBC(printk(ST_DEB_MSG
1030                             "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1031                             name,
1032                             (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1033                             (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1034
1035                 if ((STp->buffer)->b_data[3] >= 8) {
1036                         STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1037                         STp->density = (STp->buffer)->b_data[4];
1038                         STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1039                             (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1040                         DEBC(printk(ST_DEB_MSG
1041                                     "%s: Density %x, tape length: %x, drv buffer: %d\n",
1042                                     name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1043                                     (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1044                                     STp->drv_buffer));
1045                 }
1046                 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1047         }
1048         st_release_request(SRpnt);
1049         SRpnt = NULL;
1050         STp->inited = 1;
1051
1052         if (STp->block_size > 0)
1053                 (STp->buffer)->buffer_blocks =
1054                         (STp->buffer)->buffer_size / STp->block_size;
1055         else
1056                 (STp->buffer)->buffer_blocks = 1;
1057         (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1058
1059         DEBC(printk(ST_DEB_MSG
1060                        "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1061                        STp->block_size, (STp->buffer)->buffer_size,
1062                        (STp->buffer)->buffer_blocks));
1063
1064         if (STp->drv_write_prot) {
1065                 STp->write_prot = 1;
1066
1067                 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1068
1069                 if (do_wait &&
1070                     ((st_flags & O_ACCMODE) == O_WRONLY ||
1071                      (st_flags & O_ACCMODE) == O_RDWR)) {
1072                         retval = (-EROFS);
1073                         goto err_out;
1074                 }
1075         }
1076
1077         if (STp->can_partitions && STp->nbr_partitions < 1) {
1078                 /* This code is reached when the device is opened for the first time
1079                    after the driver has been initialized with tape in the drive and the
1080                    partition support has been enabled. */
1081                 DEBC(printk(ST_DEB_MSG
1082                             "%s: Updating partition number in status.\n", name));
1083                 if ((STp->partition = find_partition(STp)) < 0) {
1084                         retval = STp->partition;
1085                         goto err_out;
1086                 }
1087                 STp->new_partition = STp->partition;
1088                 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1089         }
1090
1091         if (new_session) {      /* Change the drive parameters for the new mode */
1092                 STp->density_changed = STp->blksize_changed = 0;
1093                 STp->compression_changed = 0;
1094                 if (!(STm->defaults_for_writes) &&
1095                     (retval = set_mode_densblk(STp, STm)) < 0)
1096                     goto err_out;
1097
1098                 if (STp->default_drvbuffer != 0xff) {
1099                         if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1100                                 printk(KERN_WARNING
1101                                        "%s: Can't set default drive buffering to %d.\n",
1102                                        name, STp->default_drvbuffer);
1103                 }
1104         }
1105
1106         return CHKRES_READY;
1107
1108  err_out:
1109         return retval;
1110 }
1111
1112
1113 \f/* Open the device. Needs to be called with BKL only because of incrementing the SCSI host
1114    module count. */
1115 static int st_open(struct inode *inode, struct file *filp)
1116 {
1117         int i, retval = (-EIO);
1118         struct scsi_tape *STp;
1119         struct st_partstat *STps;
1120         int dev = TAPE_NR(inode);
1121         char *name;
1122
1123         /*
1124          * We really want to do nonseekable_open(inode, filp); here, but some
1125          * versions of tar incorrectly call lseek on tapes and bail out if that
1126          * fails.  So we disallow pread() and pwrite(), but permit lseeks.
1127          */
1128         filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1129
1130         if (!(STp = scsi_tape_get(dev)))
1131                 return -ENXIO;
1132
1133         write_lock(&st_dev_arr_lock);
1134         filp->private_data = STp;
1135         name = tape_name(STp);
1136
1137         if (STp->in_use) {
1138                 write_unlock(&st_dev_arr_lock);
1139                 scsi_tape_put(STp);
1140                 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1141                 return (-EBUSY);
1142         }
1143
1144         STp->in_use = 1;
1145         write_unlock(&st_dev_arr_lock);
1146         STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1147
1148         if (!scsi_block_when_processing_errors(STp->device)) {
1149                 retval = (-ENXIO);
1150                 goto err_out;
1151         }
1152
1153         /* See that we have at least a one page buffer available */
1154         if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1155                 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1156                        name);
1157                 retval = (-EOVERFLOW);
1158                 goto err_out;
1159         }
1160
1161         (STp->buffer)->writing = 0;
1162         (STp->buffer)->syscall_result = 0;
1163
1164         STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1165
1166         STp->dirty = 0;
1167         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1168                 STps = &(STp->ps[i]);
1169                 STps->rw = ST_IDLE;
1170         }
1171         STp->try_dio_now = STp->try_dio;
1172         STp->recover_count = 0;
1173         DEB( STp->nbr_waits = STp->nbr_finished = 0;
1174              STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = STp->nbr_combinable = 0; )
1175
1176         retval = check_tape(STp, filp);
1177         if (retval < 0)
1178                 goto err_out;
1179         if ((filp->f_flags & O_NONBLOCK) == 0 &&
1180             retval != CHKRES_READY) {
1181                 if (STp->ready == NO_TAPE)
1182                         retval = (-ENOMEDIUM);
1183                 else
1184                         retval = (-EIO);
1185                 goto err_out;
1186         }
1187         return 0;
1188
1189  err_out:
1190         normalize_buffer(STp->buffer);
1191         STp->in_use = 0;
1192         scsi_tape_put(STp);
1193         return retval;
1194
1195 }
1196 \f
1197
1198 /* Flush the tape buffer before close */
1199 static int st_flush(struct file *filp, fl_owner_t id)
1200 {
1201         int result = 0, result2;
1202         unsigned char cmd[MAX_COMMAND_SIZE];
1203         struct st_request *SRpnt;
1204         struct scsi_tape *STp = filp->private_data;
1205         struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1206         struct st_partstat *STps = &(STp->ps[STp->partition]);
1207         char *name = tape_name(STp);
1208
1209         if (file_count(filp) > 1)
1210                 return 0;
1211
1212         if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1213                 result = flush_write_buffer(STp);
1214                 if (result != 0 && result != (-ENOSPC))
1215                         goto out;
1216         }
1217
1218         if (STp->can_partitions &&
1219             (result2 = switch_partition(STp)) < 0) {
1220                 DEBC(printk(ST_DEB_MSG
1221                                "%s: switch_partition at close failed.\n", name));
1222                 if (result == 0)
1223                         result = result2;
1224                 goto out;
1225         }
1226
1227         DEBC( if (STp->nbr_requests)
1228                 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d (%d).\n",
1229                        name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages, STp->nbr_combinable));
1230
1231         if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1232                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1233
1234                 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1235                             name, STp->nbr_waits, STp->nbr_finished);
1236                 )
1237
1238                 memset(cmd, 0, MAX_COMMAND_SIZE);
1239                 cmd[0] = WRITE_FILEMARKS;
1240                 cmd[4] = 1 + STp->two_fm;
1241
1242                 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1243                                    STp->device->timeout, MAX_WRITE_RETRIES, 1);
1244                 if (!SRpnt) {
1245                         result = (STp->buffer)->syscall_result;
1246                         goto out;
1247                 }
1248
1249                 if (STp->buffer->syscall_result == 0 ||
1250                     (cmdstatp->have_sense && !cmdstatp->deferred &&
1251                      (cmdstatp->flags & SENSE_EOM) &&
1252                      (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1253                       cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1254                      (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1255                         /* Write successful at EOM */
1256                         st_release_request(SRpnt);
1257                         SRpnt = NULL;
1258                         if (STps->drv_file >= 0)
1259                                 STps->drv_file++;
1260                         STps->drv_block = 0;
1261                         if (STp->two_fm)
1262                                 cross_eof(STp, 0);
1263                         STps->eof = ST_FM;
1264                 }
1265                 else { /* Write error */
1266                         st_release_request(SRpnt);
1267                         SRpnt = NULL;
1268                         printk(KERN_ERR "%s: Error on write filemark.\n", name);
1269                         if (result == 0)
1270                                 result = (-EIO);
1271                 }
1272
1273                 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1274                             name, cmd[4]));
1275         } else if (!STp->rew_at_close) {
1276                 STps = &(STp->ps[STp->partition]);
1277                 if (!STm->sysv || STps->rw != ST_READING) {
1278                         if (STp->can_bsr)
1279                                 result = flush_buffer(STp, 0);
1280                         else if (STps->eof == ST_FM_HIT) {
1281                                 result = cross_eof(STp, 0);
1282                                 if (result) {
1283                                         if (STps->drv_file >= 0)
1284                                                 STps->drv_file++;
1285                                         STps->drv_block = 0;
1286                                         STps->eof = ST_FM;
1287                                 } else
1288                                         STps->eof = ST_NOEOF;
1289                         }
1290                 } else if ((STps->eof == ST_NOEOF &&
1291                             !(result = cross_eof(STp, 1))) ||
1292                            STps->eof == ST_FM_HIT) {
1293                         if (STps->drv_file >= 0)
1294                                 STps->drv_file++;
1295                         STps->drv_block = 0;
1296                         STps->eof = ST_FM;
1297                 }
1298         }
1299
1300       out:
1301         if (STp->rew_at_close) {
1302                 result2 = st_int_ioctl(STp, MTREW, 1);
1303                 if (result == 0)
1304                         result = result2;
1305         }
1306         return result;
1307 }
1308
1309
1310 /* Close the device and release it. BKL is not needed: this is the only thread
1311    accessing this tape. */
1312 static int st_release(struct inode *inode, struct file *filp)
1313 {
1314         int result = 0;
1315         struct scsi_tape *STp = filp->private_data;
1316
1317         if (STp->door_locked == ST_LOCKED_AUTO)
1318                 do_door_lock(STp, 0);
1319
1320         normalize_buffer(STp->buffer);
1321         write_lock(&st_dev_arr_lock);
1322         STp->in_use = 0;
1323         write_unlock(&st_dev_arr_lock);
1324         scsi_tape_put(STp);
1325
1326         return result;
1327 }
1328 \f
1329 /* The checks common to both reading and writing */
1330 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1331 {
1332         ssize_t retval = 0;
1333
1334         /*
1335          * If we are in the middle of error recovery, don't let anyone
1336          * else try and use this device.  Also, if error recovery fails, it
1337          * may try and take the device offline, in which case all further
1338          * access to the device is prohibited.
1339          */
1340         if (!scsi_block_when_processing_errors(STp->device)) {
1341                 retval = (-ENXIO);
1342                 goto out;
1343         }
1344
1345         if (STp->ready != ST_READY) {
1346                 if (STp->ready == ST_NO_TAPE)
1347                         retval = (-ENOMEDIUM);
1348                 else
1349                         retval = (-EIO);
1350                 goto out;
1351         }
1352
1353         if (! STp->modes[STp->current_mode].defined) {
1354                 retval = (-ENXIO);
1355                 goto out;
1356         }
1357
1358
1359         /*
1360          * If there was a bus reset, block further access
1361          * to this device.
1362          */
1363         if (STp->pos_unknown) {
1364                 retval = (-EIO);
1365                 goto out;
1366         }
1367
1368         if (count == 0)
1369                 goto out;
1370
1371         DEB(
1372         if (!STp->in_use) {
1373                 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1374                 retval = (-EIO);
1375                 goto out;
1376         } ) /* end DEB */
1377
1378         if (STp->can_partitions &&
1379             (retval = switch_partition(STp)) < 0)
1380                 goto out;
1381
1382         if (STp->block_size == 0 && STp->max_block > 0 &&
1383             (count < STp->min_block || count > STp->max_block)) {
1384                 retval = (-EINVAL);
1385                 goto out;
1386         }
1387
1388         if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1389             !do_door_lock(STp, 1))
1390                 STp->door_locked = ST_LOCKED_AUTO;
1391
1392  out:
1393         return retval;
1394 }
1395
1396
1397 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1398                            size_t count, int is_read)
1399 {
1400         int i, bufsize, retval = 0;
1401         struct st_buffer *STbp = STp->buffer;
1402
1403         if (is_read)
1404                 i = STp->try_dio_now && try_rdio;
1405         else
1406                 i = STp->try_dio_now && try_wdio;
1407
1408         if (i && ((unsigned long)buf & queue_dma_alignment(
1409                                         STp->device->request_queue)) == 0) {
1410                 i = sgl_map_user_pages(&(STbp->sg[0]), STbp->use_sg,
1411                                       (unsigned long)buf, count, (is_read ? READ : WRITE));
1412                 if (i > 0) {
1413                         STbp->do_dio = i;
1414                         STbp->buffer_bytes = 0;   /* can be used as transfer counter */
1415                 }
1416                 else
1417                         STbp->do_dio = 0;  /* fall back to buffering with any error */
1418                 STbp->sg_segs = STbp->do_dio;
1419                 STbp->frp_sg_current = 0;
1420                 DEB(
1421                      if (STbp->do_dio) {
1422                         STp->nbr_dio++;
1423                         STp->nbr_pages += STbp->do_dio;
1424                         for (i=1; i < STbp->do_dio; i++)
1425                                 if (page_to_pfn(STbp->sg[i].page) == page_to_pfn(STbp->sg[i-1].page) + 1)
1426                                         STp->nbr_combinable++;
1427                      }
1428                 )
1429         } else
1430                 STbp->do_dio = 0;
1431         DEB( STp->nbr_requests++; )
1432
1433         if (!STbp->do_dio) {
1434                 if (STp->block_size)
1435                         bufsize = STp->block_size > st_fixed_buffer_size ?
1436                                 STp->block_size : st_fixed_buffer_size;
1437                 else
1438                         bufsize = count;
1439                 if (bufsize > STbp->buffer_size &&
1440                     !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1441                         printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1442                                tape_name(STp), bufsize);
1443                         retval = (-EOVERFLOW);
1444                         goto out;
1445                 }
1446                 if (STp->block_size)
1447                         STbp->buffer_blocks = bufsize / STp->block_size;
1448         }
1449
1450  out:
1451         return retval;
1452 }
1453
1454
1455 /* Can be called more than once after each setup_buffer() */
1456 static void release_buffering(struct scsi_tape *STp, int is_read)
1457 {
1458         struct st_buffer *STbp;
1459
1460         STbp = STp->buffer;
1461         if (STbp->do_dio) {
1462                 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, is_read);
1463                 STbp->do_dio = 0;
1464                 STbp->sg_segs = 0;
1465         }
1466 }
1467
1468
1469 /* Write command */
1470 static ssize_t
1471 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1472 {
1473         ssize_t total;
1474         ssize_t i, do_count, blks, transfer;
1475         ssize_t retval;
1476         int undone, retry_eot = 0, scode;
1477         int async_write;
1478         unsigned char cmd[MAX_COMMAND_SIZE];
1479         const char __user *b_point;
1480         struct st_request *SRpnt = NULL;
1481         struct scsi_tape *STp = filp->private_data;
1482         struct st_modedef *STm;
1483         struct st_partstat *STps;
1484         struct st_buffer *STbp;
1485         char *name = tape_name(STp);
1486
1487         if (down_interruptible(&STp->lock))
1488                 return -ERESTARTSYS;
1489
1490         retval = rw_checks(STp, filp, count);
1491         if (retval || count == 0)
1492                 goto out;
1493
1494         /* Write must be integral number of blocks */
1495         if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1496                 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1497                        name);
1498                 retval = (-EINVAL);
1499                 goto out;
1500         }
1501
1502         STm = &(STp->modes[STp->current_mode]);
1503         STps = &(STp->ps[STp->partition]);
1504
1505         if (STp->write_prot) {
1506                 retval = (-EACCES);
1507                 goto out;
1508         }
1509
1510
1511         if (STps->rw == ST_READING) {
1512                 retval = flush_buffer(STp, 0);
1513                 if (retval)
1514                         goto out;
1515                 STps->rw = ST_WRITING;
1516         } else if (STps->rw != ST_WRITING &&
1517                    STps->drv_file == 0 && STps->drv_block == 0) {
1518                 if ((retval = set_mode_densblk(STp, STm)) < 0)
1519                         goto out;
1520                 if (STm->default_compression != ST_DONT_TOUCH &&
1521                     !(STp->compression_changed)) {
1522                         if (st_compression(STp, (STm->default_compression == ST_YES))) {
1523                                 printk(KERN_WARNING "%s: Can't set default compression.\n",
1524                                        name);
1525                                 if (modes_defined) {
1526                                         retval = (-EINVAL);
1527                                         goto out;
1528                                 }
1529                         }
1530                 }
1531         }
1532
1533         STbp = STp->buffer;
1534         i = write_behind_check(STp);
1535         if (i) {
1536                 if (i == -ENOSPC)
1537                         STps->eof = ST_EOM_OK;
1538                 else
1539                         STps->eof = ST_EOM_ERROR;
1540         }
1541
1542         if (STps->eof == ST_EOM_OK) {
1543                 STps->eof = ST_EOD_1;  /* allow next write */
1544                 retval = (-ENOSPC);
1545                 goto out;
1546         }
1547         else if (STps->eof == ST_EOM_ERROR) {
1548                 retval = (-EIO);
1549                 goto out;
1550         }
1551
1552         /* Check the buffer readability in cases where copy_user might catch
1553            the problems after some tape movement. */
1554         if (STp->block_size != 0 &&
1555             !STbp->do_dio &&
1556             (copy_from_user(&i, buf, 1) != 0 ||
1557              copy_from_user(&i, buf + count - 1, 1) != 0)) {
1558                 retval = (-EFAULT);
1559                 goto out;
1560         }
1561
1562         retval = setup_buffering(STp, buf, count, 0);
1563         if (retval)
1564                 goto out;
1565
1566         total = count;
1567
1568         memset(cmd, 0, MAX_COMMAND_SIZE);
1569         cmd[0] = WRITE_6;
1570         cmd[1] = (STp->block_size != 0);
1571
1572         STps->rw = ST_WRITING;
1573
1574         b_point = buf;
1575         while (count > 0 && !retry_eot) {
1576
1577                 if (STbp->do_dio) {
1578                         do_count = count;
1579                 }
1580                 else {
1581                         if (STp->block_size == 0)
1582                                 do_count = count;
1583                         else {
1584                                 do_count = STbp->buffer_blocks * STp->block_size -
1585                                         STbp->buffer_bytes;
1586                                 if (do_count > count)
1587                                         do_count = count;
1588                         }
1589
1590                         i = append_to_buffer(b_point, STbp, do_count);
1591                         if (i) {
1592                                 retval = i;
1593                                 goto out;
1594                         }
1595                 }
1596                 count -= do_count;
1597                 b_point += do_count;
1598
1599                 async_write = STp->block_size == 0 && !STbp->do_dio &&
1600                         STm->do_async_writes && STps->eof < ST_EOM_OK;
1601
1602                 if (STp->block_size != 0 && STm->do_buffer_writes &&
1603                     !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1604                     STbp->buffer_bytes < STbp->buffer_size) {
1605                         STp->dirty = 1;
1606                         /* Don't write a buffer that is not full enough. */
1607                         if (!async_write && count == 0)
1608                                 break;
1609                 }
1610
1611         retry_write:
1612                 if (STp->block_size == 0)
1613                         blks = transfer = do_count;
1614                 else {
1615                         if (!STbp->do_dio)
1616                                 blks = STbp->buffer_bytes;
1617                         else
1618                                 blks = do_count;
1619                         blks /= STp->block_size;
1620                         transfer = blks * STp->block_size;
1621                 }
1622                 cmd[2] = blks >> 16;
1623                 cmd[3] = blks >> 8;
1624                 cmd[4] = blks;
1625
1626                 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1627                                    STp->device->timeout, MAX_WRITE_RETRIES, !async_write);
1628                 if (!SRpnt) {
1629                         retval = STbp->syscall_result;
1630                         goto out;
1631                 }
1632                 if (async_write && !STbp->syscall_result) {
1633                         STbp->writing = transfer;
1634                         STp->dirty = !(STbp->writing ==
1635                                        STbp->buffer_bytes);
1636                         SRpnt = NULL;  /* Prevent releasing this request! */
1637                         DEB( STp->write_pending = 1; )
1638                         break;
1639                 }
1640
1641                 if (STbp->syscall_result != 0) {
1642                         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1643
1644                         DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1645                         if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1646                                 scode = cmdstatp->sense_hdr.sense_key;
1647                                 if (cmdstatp->remainder_valid)
1648                                         undone = (int)cmdstatp->uremainder64;
1649                                 else if (STp->block_size == 0 &&
1650                                          scode == VOLUME_OVERFLOW)
1651                                         undone = transfer;
1652                                 else
1653                                         undone = 0;
1654                                 if (STp->block_size != 0)
1655                                         undone *= STp->block_size;
1656                                 if (undone <= do_count) {
1657                                         /* Only data from this write is not written */
1658                                         count += undone;
1659                                         do_count -= undone;
1660                                         if (STp->block_size)
1661                                                 blks = (transfer - undone) / STp->block_size;
1662                                         STps->eof = ST_EOM_OK;
1663                                         /* Continue in fixed block mode if all written
1664                                            in this request but still something left to write
1665                                            (retval left to zero)
1666                                         */
1667                                         if (STp->block_size == 0 ||
1668                                             undone > 0 || count == 0)
1669                                                 retval = (-ENOSPC); /* EOM within current request */
1670                                         DEBC(printk(ST_DEB_MSG
1671                                                        "%s: EOM with %d bytes unwritten.\n",
1672                                                        name, (int)count));
1673                                 } else {
1674                                         /* EOT within data buffered earlier (possible only
1675                                            in fixed block mode without direct i/o) */
1676                                         if (!retry_eot && !cmdstatp->deferred &&
1677                                             (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1678                                                 move_buffer_data(STp->buffer, transfer - undone);
1679                                                 retry_eot = 1;
1680                                                 if (STps->drv_block >= 0) {
1681                                                         STps->drv_block += (transfer - undone) /
1682                                                                 STp->block_size;
1683                                                 }
1684                                                 STps->eof = ST_EOM_OK;
1685                                                 DEBC(printk(ST_DEB_MSG
1686                                                             "%s: Retry write of %d bytes at EOM.\n",
1687                                                             name, STp->buffer->buffer_bytes));
1688                                                 goto retry_write;
1689                                         }
1690                                         else {
1691                                                 /* Either error within data buffered by driver or
1692                                                    failed retry */
1693                                                 count -= do_count;
1694                                                 blks = do_count = 0;
1695                                                 STps->eof = ST_EOM_ERROR;
1696                                                 STps->drv_block = (-1); /* Too cautious? */
1697                                                 retval = (-EIO);        /* EOM for old data */
1698                                                 DEBC(printk(ST_DEB_MSG
1699                                                             "%s: EOM with lost data.\n",
1700                                                             name));
1701                                         }
1702                                 }
1703                         } else {
1704                                 count += do_count;
1705                                 STps->drv_block = (-1);         /* Too cautious? */
1706                                 retval = STbp->syscall_result;
1707                         }
1708
1709                 }
1710
1711                 if (STps->drv_block >= 0) {
1712                         if (STp->block_size == 0)
1713                                 STps->drv_block += (do_count > 0);
1714                         else
1715                                 STps->drv_block += blks;
1716                 }
1717
1718                 STbp->buffer_bytes = 0;
1719                 STp->dirty = 0;
1720
1721                 if (retval || retry_eot) {
1722                         if (count < total)
1723                                 retval = total - count;
1724                         goto out;
1725                 }
1726         }
1727
1728         if (STps->eof == ST_EOD_1)
1729                 STps->eof = ST_EOM_OK;
1730         else if (STps->eof != ST_EOM_OK)
1731                 STps->eof = ST_NOEOF;
1732         retval = total - count;
1733
1734  out:
1735         if (SRpnt != NULL)
1736                 st_release_request(SRpnt);
1737         release_buffering(STp, 0);
1738         up(&STp->lock);
1739
1740         return retval;
1741 }
1742 \f
1743 /* Read data from the tape. Returns zero in the normal case, one if the
1744    eof status has changed, and the negative error code in case of a
1745    fatal error. Otherwise updates the buffer and the eof state.
1746
1747    Does release user buffer mapping if it is set.
1748 */
1749 static long read_tape(struct scsi_tape *STp, long count,
1750                       struct st_request ** aSRpnt)
1751 {
1752         int transfer, blks, bytes;
1753         unsigned char cmd[MAX_COMMAND_SIZE];
1754         struct st_request *SRpnt;
1755         struct st_modedef *STm;
1756         struct st_partstat *STps;
1757         struct st_buffer *STbp;
1758         int retval = 0;
1759         char *name = tape_name(STp);
1760
1761         if (count == 0)
1762                 return 0;
1763
1764         STm = &(STp->modes[STp->current_mode]);
1765         STps = &(STp->ps[STp->partition]);
1766         if (STps->eof == ST_FM_HIT)
1767                 return 1;
1768         STbp = STp->buffer;
1769
1770         if (STp->block_size == 0)
1771                 blks = bytes = count;
1772         else {
1773                 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1774                         blks = (STp->buffer)->buffer_blocks;
1775                         bytes = blks * STp->block_size;
1776                 } else {
1777                         bytes = count;
1778                         if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1779                                 bytes = (STp->buffer)->buffer_size;
1780                         blks = bytes / STp->block_size;
1781                         bytes = blks * STp->block_size;
1782                 }
1783         }
1784
1785         memset(cmd, 0, MAX_COMMAND_SIZE);
1786         cmd[0] = READ_6;
1787         cmd[1] = (STp->block_size != 0);
1788         cmd[2] = blks >> 16;
1789         cmd[3] = blks >> 8;
1790         cmd[4] = blks;
1791
1792         SRpnt = *aSRpnt;
1793         SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1794                            STp->device->timeout, MAX_RETRIES, 1);
1795         release_buffering(STp, 1);
1796         *aSRpnt = SRpnt;
1797         if (!SRpnt)
1798                 return STbp->syscall_result;
1799
1800         STbp->read_pointer = 0;
1801         STps->at_sm = 0;
1802
1803         /* Something to check */
1804         if (STbp->syscall_result) {
1805                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1806
1807                 retval = 1;
1808                 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1809                             name,
1810                             SRpnt->sense[0], SRpnt->sense[1],
1811                             SRpnt->sense[2], SRpnt->sense[3],
1812                             SRpnt->sense[4], SRpnt->sense[5],
1813                             SRpnt->sense[6], SRpnt->sense[7]));
1814                 if (cmdstatp->have_sense) {
1815
1816                         if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1817                                 cmdstatp->flags &= 0xcf;        /* No need for EOM in this case */
1818
1819                         if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1820                                 /* Compute the residual count */
1821                                 if (cmdstatp->remainder_valid)
1822                                         transfer = (int)cmdstatp->uremainder64;
1823                                 else
1824                                         transfer = 0;
1825                                 if (STp->block_size == 0 &&
1826                                     cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1827                                         transfer = bytes;
1828
1829                                 if (cmdstatp->flags & SENSE_ILI) {      /* ILI */
1830                                         if (STp->block_size == 0) {
1831                                                 if (transfer <= 0) {
1832                                                         if (transfer < 0)
1833                                                                 printk(KERN_NOTICE
1834                                                                        "%s: Failed to read %d byte block with %d byte transfer.\n",
1835                                                                        name, bytes - transfer, bytes);
1836                                                         if (STps->drv_block >= 0)
1837                                                                 STps->drv_block += 1;
1838                                                         STbp->buffer_bytes = 0;
1839                                                         return (-ENOMEM);
1840                                                 }
1841                                                 STbp->buffer_bytes = bytes - transfer;
1842                                         } else {
1843                                                 st_release_request(SRpnt);
1844                                                 SRpnt = *aSRpnt = NULL;
1845                                                 if (transfer == blks) { /* We did not get anything, error */
1846                                                         printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1847                                                         if (STps->drv_block >= 0)
1848                                                                 STps->drv_block += blks - transfer + 1;
1849                                                         st_int_ioctl(STp, MTBSR, 1);
1850                                                         return (-EIO);
1851                                                 }
1852                                                 /* We have some data, deliver it */
1853                                                 STbp->buffer_bytes = (blks - transfer) *
1854                                                     STp->block_size;
1855                                                 DEBC(printk(ST_DEB_MSG
1856                                                             "%s: ILI but enough data received %ld %d.\n",
1857                                                             name, count, STbp->buffer_bytes));
1858                                                 if (STps->drv_block >= 0)
1859                                                         STps->drv_block += 1;
1860                                                 if (st_int_ioctl(STp, MTBSR, 1))
1861                                                         return (-EIO);
1862                                         }
1863                                 } else if (cmdstatp->flags & SENSE_FMK) {       /* FM overrides EOM */
1864                                         if (STps->eof != ST_FM_HIT)
1865                                                 STps->eof = ST_FM_HIT;
1866                                         else
1867                                                 STps->eof = ST_EOD_2;
1868                                         if (STp->block_size == 0)
1869                                                 STbp->buffer_bytes = 0;
1870                                         else
1871                                                 STbp->buffer_bytes =
1872                                                     bytes - transfer * STp->block_size;
1873                                         DEBC(printk(ST_DEB_MSG
1874                                                     "%s: EOF detected (%d bytes read).\n",
1875                                                     name, STbp->buffer_bytes));
1876                                 } else if (cmdstatp->flags & SENSE_EOM) {
1877                                         if (STps->eof == ST_FM)
1878                                                 STps->eof = ST_EOD_1;
1879                                         else
1880                                                 STps->eof = ST_EOM_OK;
1881                                         if (STp->block_size == 0)
1882                                                 STbp->buffer_bytes = bytes - transfer;
1883                                         else
1884                                                 STbp->buffer_bytes =
1885                                                     bytes - transfer * STp->block_size;
1886
1887                                         DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1888                                                     name, STbp->buffer_bytes));
1889                                 }
1890                         }
1891                         /* end of EOF, EOM, ILI test */ 
1892                         else {  /* nonzero sense key */
1893                                 DEBC(printk(ST_DEB_MSG
1894                                             "%s: Tape error while reading.\n", name));
1895                                 STps->drv_block = (-1);
1896                                 if (STps->eof == ST_FM &&
1897                                     cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1898                                         DEBC(printk(ST_DEB_MSG
1899                                                     "%s: Zero returned for first BLANK CHECK after EOF.\n",
1900                                                     name));
1901                                         STps->eof = ST_EOD_2;   /* First BLANK_CHECK after FM */
1902                                 } else  /* Some other extended sense code */
1903                                         retval = (-EIO);
1904                         }
1905
1906                         if (STbp->buffer_bytes < 0)  /* Caused by bogus sense data */
1907                                 STbp->buffer_bytes = 0;
1908                 }
1909                 /* End of extended sense test */ 
1910                 else {          /* Non-extended sense */
1911                         retval = STbp->syscall_result;
1912                 }
1913
1914         }
1915         /* End of error handling */ 
1916         else                    /* Read successful */
1917                 STbp->buffer_bytes = bytes;
1918
1919         if (STps->drv_block >= 0) {
1920                 if (STp->block_size == 0)
1921                         STps->drv_block++;
1922                 else
1923                         STps->drv_block += STbp->buffer_bytes / STp->block_size;
1924         }
1925         return retval;
1926 }
1927 \f
1928
1929 /* Read command */
1930 static ssize_t
1931 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
1932 {
1933         ssize_t total;
1934         ssize_t retval = 0;
1935         ssize_t i, transfer;
1936         int special, do_dio = 0;
1937         struct st_request *SRpnt = NULL;
1938         struct scsi_tape *STp = filp->private_data;
1939         struct st_modedef *STm;
1940         struct st_partstat *STps;
1941         struct st_buffer *STbp = STp->buffer;
1942         DEB( char *name = tape_name(STp); )
1943
1944         if (down_interruptible(&STp->lock))
1945                 return -ERESTARTSYS;
1946
1947         retval = rw_checks(STp, filp, count);
1948         if (retval || count == 0)
1949                 goto out;
1950
1951         STm = &(STp->modes[STp->current_mode]);
1952         if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1953                 if (!STm->do_read_ahead) {
1954                         retval = (-EINVAL);     /* Read must be integral number of blocks */
1955                         goto out;
1956                 }
1957                 STp->try_dio_now = 0;  /* Direct i/o can't handle split blocks */
1958         }
1959
1960         STps = &(STp->ps[STp->partition]);
1961         if (STps->rw == ST_WRITING) {
1962                 retval = flush_buffer(STp, 0);
1963                 if (retval)
1964                         goto out;
1965                 STps->rw = ST_READING;
1966         }
1967         DEB(
1968         if (debugging && STps->eof != ST_NOEOF)
1969                 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
1970                        STps->eof, STbp->buffer_bytes);
1971         ) /* end DEB */
1972
1973         retval = setup_buffering(STp, buf, count, 1);
1974         if (retval)
1975                 goto out;
1976         do_dio = STbp->do_dio;
1977
1978         if (STbp->buffer_bytes == 0 &&
1979             STps->eof >= ST_EOD_1) {
1980                 if (STps->eof < ST_EOD) {
1981                         STps->eof += 1;
1982                         retval = 0;
1983                         goto out;
1984                 }
1985                 retval = (-EIO);        /* EOM or Blank Check */
1986                 goto out;
1987         }
1988
1989         if (do_dio) {
1990                 /* Check the buffer writability before any tape movement. Don't alter
1991                    buffer data. */
1992                 if (copy_from_user(&i, buf, 1) != 0 ||
1993                     copy_to_user(buf, &i, 1) != 0 ||
1994                     copy_from_user(&i, buf + count - 1, 1) != 0 ||
1995                     copy_to_user(buf + count - 1, &i, 1) != 0) {
1996                         retval = (-EFAULT);
1997                         goto out;
1998                 }
1999         }
2000
2001         STps->rw = ST_READING;
2002
2003
2004         /* Loop until enough data in buffer or a special condition found */
2005         for (total = 0, special = 0; total < count && !special;) {
2006
2007                 /* Get new data if the buffer is empty */
2008                 if (STbp->buffer_bytes == 0) {
2009                         special = read_tape(STp, count - total, &SRpnt);
2010                         if (special < 0) {      /* No need to continue read */
2011                                 retval = special;
2012                                 goto out;
2013                         }
2014                 }
2015
2016                 /* Move the data from driver buffer to user buffer */
2017                 if (STbp->buffer_bytes > 0) {
2018                         DEB(
2019                         if (debugging && STps->eof != ST_NOEOF)
2020                                 printk(ST_DEB_MSG
2021                                        "%s: EOF up (%d). Left %d, needed %d.\n", name,
2022                                        STps->eof, STbp->buffer_bytes,
2023                                        (int)(count - total));
2024                         ) /* end DEB */
2025                         transfer = STbp->buffer_bytes < count - total ?
2026                             STbp->buffer_bytes : count - total;
2027                         if (!do_dio) {
2028                                 i = from_buffer(STbp, buf, transfer);
2029                                 if (i) {
2030                                         retval = i;
2031                                         goto out;
2032                                 }
2033                         }
2034                         buf += transfer;
2035                         total += transfer;
2036                 }
2037
2038                 if (STp->block_size == 0)
2039                         break;  /* Read only one variable length block */
2040
2041         }                       /* for (total = 0, special = 0;
2042                                    total < count && !special; ) */
2043
2044         /* Change the eof state if no data from tape or buffer */
2045         if (total == 0) {
2046                 if (STps->eof == ST_FM_HIT) {
2047                         STps->eof = ST_FM;
2048                         STps->drv_block = 0;
2049                         if (STps->drv_file >= 0)
2050                                 STps->drv_file++;
2051                 } else if (STps->eof == ST_EOD_1) {
2052                         STps->eof = ST_EOD_2;
2053                         STps->drv_block = 0;
2054                         if (STps->drv_file >= 0)
2055                                 STps->drv_file++;
2056                 } else if (STps->eof == ST_EOD_2)
2057                         STps->eof = ST_EOD;
2058         } else if (STps->eof == ST_FM)
2059                 STps->eof = ST_NOEOF;
2060         retval = total;
2061
2062  out:
2063         if (SRpnt != NULL) {
2064                 st_release_request(SRpnt);
2065                 SRpnt = NULL;
2066         }
2067         if (do_dio) {
2068                 release_buffering(STp, 1);
2069                 STbp->buffer_bytes = 0;
2070         }
2071         up(&STp->lock);
2072
2073         return retval;
2074 }
2075 \f
2076
2077
2078 DEB(
2079 /* Set the driver options */
2080 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2081 {
2082         if (debugging) {
2083                 printk(KERN_INFO
2084                        "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2085                        name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2086                        STm->do_read_ahead);
2087                 printk(KERN_INFO
2088                        "%s:    can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2089                        name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2090                 printk(KERN_INFO
2091                        "%s:    defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2092                        name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2093                        STp->scsi2_logical);
2094                 printk(KERN_INFO
2095                        "%s:    sysv: %d nowait: %d\n", name, STm->sysv, STp->immediate);
2096                 printk(KERN_INFO "%s:    debugging: %d\n",
2097                        name, debugging);
2098         }
2099 }
2100         )
2101
2102
2103 static int st_set_options(struct scsi_tape *STp, long options)
2104 {
2105         int value;
2106         long code;
2107         struct st_modedef *STm;
2108         char *name = tape_name(STp);
2109         struct cdev *cd0, *cd1;
2110
2111         STm = &(STp->modes[STp->current_mode]);
2112         if (!STm->defined) {
2113                 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2114                 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2115                 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2116                 modes_defined = 1;
2117                 DEBC(printk(ST_DEB_MSG
2118                             "%s: Initialized mode %d definition from mode 0\n",
2119                             name, STp->current_mode));
2120         }
2121
2122         code = options & MT_ST_OPTIONS;
2123         if (code == MT_ST_BOOLEANS) {
2124                 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2125                 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2126                 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2127                 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2128                 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2129                 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2130                 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2131                 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2132                 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2133                 if ((STp->device)->scsi_level >= SCSI_2)
2134                         STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2135                 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2136                 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2137                 STm->sysv = (options & MT_ST_SYSV) != 0;
2138                 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2139                      st_log_options(STp, STm, name); )
2140         } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2141                 value = (code == MT_ST_SETBOOLEANS);
2142                 if ((options & MT_ST_BUFFER_WRITES) != 0)
2143                         STm->do_buffer_writes = value;
2144                 if ((options & MT_ST_ASYNC_WRITES) != 0)
2145                         STm->do_async_writes = value;
2146                 if ((options & MT_ST_DEF_WRITES) != 0)
2147                         STm->defaults_for_writes = value;
2148                 if ((options & MT_ST_READ_AHEAD) != 0)
2149                         STm->do_read_ahead = value;
2150                 if ((options & MT_ST_TWO_FM) != 0)
2151                         STp->two_fm = value;
2152                 if ((options & MT_ST_FAST_MTEOM) != 0)
2153                         STp->fast_mteom = value;
2154                 if ((options & MT_ST_AUTO_LOCK) != 0)
2155                         STp->do_auto_lock = value;
2156                 if ((options & MT_ST_CAN_BSR) != 0)
2157                         STp->can_bsr = value;
2158                 if ((options & MT_ST_NO_BLKLIMS) != 0)
2159                         STp->omit_blklims = value;
2160                 if ((STp->device)->scsi_level >= SCSI_2 &&
2161                     (options & MT_ST_CAN_PARTITIONS) != 0)
2162                         STp->can_partitions = value;
2163                 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2164                         STp->scsi2_logical = value;
2165                 if ((options & MT_ST_NOWAIT) != 0)
2166                         STp->immediate = value;
2167                 if ((options & MT_ST_SYSV) != 0)
2168                         STm->sysv = value;
2169                 DEB(
2170                 if ((options & MT_ST_DEBUGGING) != 0)
2171                         debugging = value;
2172                         st_log_options(STp, STm, name); )
2173         } else if (code == MT_ST_WRITE_THRESHOLD) {
2174                 /* Retained for compatibility */
2175         } else if (code == MT_ST_DEF_BLKSIZE) {
2176                 value = (options & ~MT_ST_OPTIONS);
2177                 if (value == ~MT_ST_OPTIONS) {
2178                         STm->default_blksize = (-1);
2179                         DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2180                 } else {
2181                         STm->default_blksize = value;
2182                         DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2183                                name, STm->default_blksize));
2184                         if (STp->ready == ST_READY) {
2185                                 STp->blksize_changed = 0;
2186                                 set_mode_densblk(STp, STm);
2187                         }
2188                 }
2189         } else if (code == MT_ST_TIMEOUTS) {
2190                 value = (options & ~MT_ST_OPTIONS);
2191                 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2192                         STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2193                         DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2194                                (value & ~MT_ST_SET_LONG_TIMEOUT)));
2195                 } else {
2196                         STp->device->timeout = value * HZ;
2197                         DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2198                                 name, value) );
2199                 }
2200         } else if (code == MT_ST_SET_CLN) {
2201                 value = (options & ~MT_ST_OPTIONS) & 0xff;
2202                 if (value != 0 &&
2203                     value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2204                         return (-EINVAL);
2205                 STp->cln_mode = value;
2206                 STp->cln_sense_mask = (options >> 8) & 0xff;
2207                 STp->cln_sense_value = (options >> 16) & 0xff;
2208                 printk(KERN_INFO
2209                        "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2210                        name, value, STp->cln_sense_mask, STp->cln_sense_value);
2211         } else if (code == MT_ST_DEF_OPTIONS) {
2212                 code = (options & ~MT_ST_CLEAR_DEFAULT);
2213                 value = (options & MT_ST_CLEAR_DEFAULT);
2214                 if (code == MT_ST_DEF_DENSITY) {
2215                         if (value == MT_ST_CLEAR_DEFAULT) {
2216                                 STm->default_density = (-1);
2217                                 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2218                                        name));
2219                         } else {
2220                                 STm->default_density = value & 0xff;
2221                                 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2222                                        name, STm->default_density));
2223                                 if (STp->ready == ST_READY) {
2224                                         STp->density_changed = 0;
2225                                         set_mode_densblk(STp, STm);
2226                                 }
2227                         }
2228                 } else if (code == MT_ST_DEF_DRVBUFFER) {
2229                         if (value == MT_ST_CLEAR_DEFAULT) {
2230                                 STp->default_drvbuffer = 0xff;
2231                                 DEBC( printk(KERN_INFO
2232                                        "%s: Drive buffer default disabled.\n", name));
2233                         } else {
2234                                 STp->default_drvbuffer = value & 7;
2235                                 DEBC( printk(KERN_INFO
2236                                        "%s: Drive buffer default set to %x\n",
2237                                        name, STp->default_drvbuffer));
2238                                 if (STp->ready == ST_READY)
2239                                         st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2240                         }
2241                 } else if (code == MT_ST_DEF_COMPRESSION) {
2242                         if (value == MT_ST_CLEAR_DEFAULT) {
2243                                 STm->default_compression = ST_DONT_TOUCH;
2244                                 DEBC( printk(KERN_INFO
2245                                        "%s: Compression default disabled.\n", name));
2246                         } else {
2247                                 if ((value & 0xff00) != 0) {
2248                                         STp->c_algo = (value & 0xff00) >> 8;
2249                                         DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2250                                                name, STp->c_algo));
2251                                 }
2252                                 if ((value & 0xff) != 0xff) {
2253                                         STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2254                                         DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2255                                                name, (value & 1)));
2256                                         if (STp->ready == ST_READY) {
2257                                                 STp->compression_changed = 0;
2258                                                 st_compression(STp, (STm->default_compression == ST_YES));
2259                                         }
2260                                 }
2261                         }
2262                 }
2263         } else
2264                 return (-EIO);
2265
2266         return 0;
2267 }
2268 \f
2269 #define MODE_HEADER_LENGTH  4
2270
2271 /* Mode header and page byte offsets */
2272 #define MH_OFF_DATA_LENGTH     0
2273 #define MH_OFF_MEDIUM_TYPE     1
2274 #define MH_OFF_DEV_SPECIFIC    2
2275 #define MH_OFF_BDESCS_LENGTH   3
2276 #define MP_OFF_PAGE_NBR        0
2277 #define MP_OFF_PAGE_LENGTH     1
2278
2279 /* Mode header and page bit masks */
2280 #define MH_BIT_WP              0x80
2281 #define MP_MSK_PAGE_NBR        0x3f
2282
2283 /* Don't return block descriptors */
2284 #define MODE_SENSE_OMIT_BDESCS 0x08
2285
2286 #define MODE_SELECT_PAGE_FORMAT 0x10
2287
2288 /* Read a mode page into the tape buffer. The block descriptors are included
2289    if incl_block_descs is true. The page control is ored to the page number
2290    parameter, if necessary. */
2291 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2292 {
2293         unsigned char cmd[MAX_COMMAND_SIZE];
2294         struct st_request *SRpnt = NULL;
2295
2296         memset(cmd, 0, MAX_COMMAND_SIZE);
2297         cmd[0] = MODE_SENSE;
2298         if (omit_block_descs)
2299                 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2300         cmd[2] = page;
2301         cmd[4] = 255;
2302
2303         SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2304                            STp->device->timeout, 0, 1);
2305         if (SRpnt == NULL)
2306                 return (STp->buffer)->syscall_result;
2307
2308         st_release_request(SRpnt);
2309
2310         return (STp->buffer)->syscall_result;
2311 }
2312
2313
2314 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2315    in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2316 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2317 {
2318         int pgo;
2319         unsigned char cmd[MAX_COMMAND_SIZE];
2320         struct st_request *SRpnt = NULL;
2321
2322         memset(cmd, 0, MAX_COMMAND_SIZE);
2323         cmd[0] = MODE_SELECT;
2324         cmd[1] = MODE_SELECT_PAGE_FORMAT;
2325         pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2326         cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2327
2328         /* Clear reserved fields */
2329         (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2330         (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2331         (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2332         (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2333
2334         SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE,
2335                            (slow ? STp->long_timeout : STp->device->timeout), 0, 1);
2336         if (SRpnt == NULL)
2337                 return (STp->buffer)->syscall_result;
2338
2339         st_release_request(SRpnt);
2340
2341         return (STp->buffer)->syscall_result;
2342 }
2343
2344
2345 #define COMPRESSION_PAGE        0x0f
2346 #define COMPRESSION_PAGE_LENGTH 16
2347
2348 #define CP_OFF_DCE_DCC          2
2349 #define CP_OFF_C_ALGO           7
2350
2351 #define DCE_MASK  0x80
2352 #define DCC_MASK  0x40
2353 #define RED_MASK  0x60
2354
2355
2356 /* Control the compression with mode page 15. Algorithm not changed if zero.
2357
2358    The block descriptors are read and written because Sony SDT-7000 does not
2359    work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2360    Including block descriptors should not cause any harm to other drives. */
2361
2362 static int st_compression(struct scsi_tape * STp, int state)
2363 {
2364         int retval;
2365         int mpoffs;  /* Offset to mode page start */
2366         unsigned char *b_data = (STp->buffer)->b_data;
2367         DEB( char *name = tape_name(STp); )
2368
2369         if (STp->ready != ST_READY)
2370                 return (-EIO);
2371
2372         /* Read the current page contents */
2373         retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2374         if (retval) {
2375                 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2376                             name));
2377                 return (-EIO);
2378         }
2379
2380         mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2381         DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2382                     (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2383
2384         /* Check if compression can be changed */
2385         if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2386                 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2387                 return (-EIO);
2388         }
2389
2390         /* Do the change */
2391         if (state) {
2392                 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2393                 if (STp->c_algo != 0)
2394                         b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2395         }
2396         else {
2397                 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2398                 if (STp->c_algo != 0)
2399                         b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2400         }
2401
2402         retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2403         if (retval) {
2404                 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2405                 return (-EIO);
2406         }
2407         DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2408                        name, state));
2409
2410         STp->compression_changed = 1;
2411         return 0;
2412 }
2413
2414
2415 /* Process the load and unload commands (does unload if the load code is zero) */
2416 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2417 {
2418         int retval = (-EIO), timeout;
2419         DEB( char *name = tape_name(STp); )
2420         unsigned char cmd[MAX_COMMAND_SIZE];
2421         struct st_partstat *STps;
2422         struct st_request *SRpnt;
2423
2424         if (STp->ready != ST_READY && !load_code) {
2425                 if (STp->ready == ST_NO_TAPE)
2426                         return (-ENOMEDIUM);
2427                 else
2428                         return (-EIO);
2429         }
2430
2431         memset(cmd, 0, MAX_COMMAND_SIZE);
2432         cmd[0] = START_STOP;
2433         if (load_code)
2434                 cmd[4] |= 1;
2435         /*
2436          * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2437          */
2438         if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2439             && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2440                 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2441                             name, (cmd[4]) ? "" : "un",
2442                             load_code - MT_ST_HPLOADER_OFFSET));
2443                 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2444         }
2445         if (STp->immediate) {
2446                 cmd[1] = 1;     /* Don't wait for completion */
2447                 timeout = STp->device->timeout;
2448         }
2449         else
2450                 timeout = STp->long_timeout;
2451
2452         DEBC(
2453                 if (!load_code)
2454                 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2455                 else
2456                 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2457                 );
2458
2459         SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2460                            timeout, MAX_RETRIES, 1);
2461         if (!SRpnt)
2462                 return (STp->buffer)->syscall_result;
2463
2464         retval = (STp->buffer)->syscall_result;
2465         st_release_request(SRpnt);
2466
2467         if (!retval) {  /* SCSI command successful */
2468
2469                 if (!load_code) {
2470                         STp->rew_at_close = 0;
2471                         STp->ready = ST_NO_TAPE;
2472                 }
2473                 else {
2474                         STp->rew_at_close = STp->autorew_dev;
2475                         retval = check_tape(STp, filp);
2476                         if (retval > 0)
2477                                 retval = 0;
2478                 }
2479         }
2480         else {
2481                 STps = &(STp->ps[STp->partition]);
2482                 STps->drv_file = STps->drv_block = (-1);
2483         }
2484
2485         return retval;
2486 }
2487 \f
2488 #if DEBUG
2489 #define ST_DEB_FORWARD  0
2490 #define ST_DEB_BACKWARD 1
2491 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2492 {
2493         s32 sc;
2494
2495         sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2496         sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2497         if (direction)
2498                 sc = -sc;
2499         printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2500                direction ? "backward" : "forward", sc, units);
2501 }
2502 #endif
2503
2504
2505 /* Internal ioctl function */
2506 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2507 {
2508         int timeout;
2509         long ltmp;
2510         int ioctl_result;
2511         int chg_eof = 1;
2512         unsigned char cmd[MAX_COMMAND_SIZE];
2513         struct st_request *SRpnt;
2514         struct st_partstat *STps;
2515         int fileno, blkno, at_sm, undone;
2516         int datalen = 0, direction = DMA_NONE;
2517         char *name = tape_name(STp);
2518
2519         WARN_ON(STp->buffer->do_dio != 0);
2520         if (STp->ready != ST_READY) {
2521                 if (STp->ready == ST_NO_TAPE)
2522                         return (-ENOMEDIUM);
2523                 else
2524                         return (-EIO);
2525         }
2526         timeout = STp->long_timeout;
2527         STps = &(STp->ps[STp->partition]);
2528         fileno = STps->drv_file;
2529         blkno = STps->drv_block;
2530         at_sm = STps->at_sm;
2531
2532         memset(cmd, 0, MAX_COMMAND_SIZE);
2533         switch (cmd_in) {
2534         case MTFSFM:
2535                 chg_eof = 0;    /* Changed from the FSF after this */
2536         case MTFSF:
2537                 cmd[0] = SPACE;
2538                 cmd[1] = 0x01;  /* Space FileMarks */
2539                 cmd[2] = (arg >> 16);
2540                 cmd[3] = (arg >> 8);
2541                 cmd[4] = arg;
2542                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2543                 if (fileno >= 0)
2544                         fileno += arg;
2545                 blkno = 0;
2546                 at_sm &= (arg == 0);
2547                 break;
2548         case MTBSFM:
2549                 chg_eof = 0;    /* Changed from the FSF after this */
2550         case MTBSF:
2551                 cmd[0] = SPACE;
2552                 cmd[1] = 0x01;  /* Space FileMarks */
2553                 ltmp = (-arg);
2554                 cmd[2] = (ltmp >> 16);
2555                 cmd[3] = (ltmp >> 8);
2556                 cmd[4] = ltmp;
2557                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2558                 if (fileno >= 0)
2559                         fileno -= arg;
2560                 blkno = (-1);   /* We can't know the block number */
2561                 at_sm &= (arg == 0);
2562                 break;
2563         case MTFSR:
2564                 cmd[0] = SPACE;
2565                 cmd[1] = 0x00;  /* Space Blocks */
2566                 cmd[2] = (arg >> 16);
2567                 cmd[3] = (arg >> 8);
2568                 cmd[4] = arg;
2569                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2570                 if (blkno >= 0)
2571                         blkno += arg;
2572                 at_sm &= (arg == 0);
2573                 break;
2574         case MTBSR:
2575                 cmd[0] = SPACE;
2576                 cmd[1] = 0x00;  /* Space Blocks */
2577                 ltmp = (-arg);
2578                 cmd[2] = (ltmp >> 16);
2579                 cmd[3] = (ltmp >> 8);
2580                 cmd[4] = ltmp;
2581                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2582                 if (blkno >= 0)
2583                         blkno -= arg;
2584                 at_sm &= (arg == 0);
2585                 break;
2586         case MTFSS:
2587                 cmd[0] = SPACE;
2588                 cmd[1] = 0x04;  /* Space Setmarks */
2589                 cmd[2] = (arg >> 16);
2590                 cmd[3] = (arg >> 8);
2591                 cmd[4] = arg;
2592                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2593                 if (arg != 0) {
2594                         blkno = fileno = (-1);
2595                         at_sm = 1;
2596                 }
2597                 break;
2598         case MTBSS:
2599                 cmd[0] = SPACE;
2600                 cmd[1] = 0x04;  /* Space Setmarks */
2601                 ltmp = (-arg);
2602                 cmd[2] = (ltmp >> 16);
2603                 cmd[3] = (ltmp >> 8);
2604                 cmd[4] = ltmp;
2605                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2606                 if (arg != 0) {
2607                         blkno = fileno = (-1);
2608                         at_sm = 1;
2609                 }
2610                 break;
2611         case MTWEOF:
2612         case MTWSM:
2613                 if (STp->write_prot)
2614                         return (-EACCES);
2615                 cmd[0] = WRITE_FILEMARKS;
2616                 if (cmd_in == MTWSM)
2617                         cmd[1] = 2;
2618                 cmd[2] = (arg >> 16);
2619                 cmd[3] = (arg >> 8);
2620                 cmd[4] = arg;
2621                 timeout = STp->device->timeout;
2622                 DEBC(
2623                      if (cmd_in == MTWEOF)
2624                                printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2625                                  cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2626                      else
2627                                 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2628                                  cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2629                 )
2630                 if (fileno >= 0)
2631                         fileno += arg;
2632                 blkno = 0;
2633                 at_sm = (cmd_in == MTWSM);
2634                 break;
2635         case MTREW:
2636                 cmd[0] = REZERO_UNIT;
2637                 if (STp->immediate) {
2638                         cmd[1] = 1;     /* Don't wait for completion */
2639                         timeout = STp->device->timeout;
2640                 }
2641                 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2642                 fileno = blkno = at_sm = 0;
2643                 break;
2644         case MTNOP:
2645                 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2646                 return 0;       /* Should do something ? */
2647                 break;
2648         case MTRETEN:
2649                 cmd[0] = START_STOP;
2650                 if (STp->immediate) {
2651                         cmd[1] = 1;     /* Don't wait for completion */
2652                         timeout = STp->device->timeout;
2653                 }
2654                 cmd[4] = 3;
2655                 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2656                 fileno = blkno = at_sm = 0;
2657                 break;
2658         case MTEOM:
2659                 if (!STp->fast_mteom) {
2660                         /* space to the end of tape */
2661                         ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2662                         fileno = STps->drv_file;
2663                         if (STps->eof >= ST_EOD_1)
2664                                 return 0;
2665                         /* The next lines would hide the number of spaced FileMarks
2666                            That's why I inserted the previous lines. I had no luck
2667                            with detecting EOM with FSF, so we go now to EOM.
2668                            Joerg Weule */
2669                 } else
2670                         fileno = (-1);
2671                 cmd[0] = SPACE;
2672                 cmd[1] = 3;
2673                 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2674                             name));
2675                 blkno = -1;
2676                 at_sm = 0;
2677                 break;
2678         case MTERASE:
2679                 if (STp->write_prot)
2680                         return (-EACCES);
2681                 cmd[0] = ERASE;
2682                 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2683                 if (STp->immediate) {
2684                         cmd[1] |= 2;    /* Don't wait for completion */
2685                         timeout = STp->device->timeout;
2686                 }
2687                 else
2688                         timeout = STp->long_timeout * 8;
2689
2690                 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2691                 fileno = blkno = at_sm = 0;
2692                 break;
2693         case MTSETBLK:          /* Set block length */
2694         case MTSETDENSITY:      /* Set tape density */
2695         case MTSETDRVBUFFER:    /* Set drive buffering */
2696         case SET_DENS_AND_BLK:  /* Set density and block size */
2697                 chg_eof = 0;
2698                 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2699                         return (-EIO);  /* Not allowed if data in buffer */
2700                 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2701                     (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2702                     STp->max_block > 0 &&
2703                     ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2704                      (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2705                         printk(KERN_WARNING "%s: Illegal block size.\n", name);
2706                         return (-EINVAL);
2707                 }
2708                 cmd[0] = MODE_SELECT;
2709                 if ((STp->use_pf & USE_PF))
2710                         cmd[1] = MODE_SELECT_PAGE_FORMAT;
2711                 cmd[4] = datalen = 12;
2712                 direction = DMA_TO_DEVICE;
2713
2714                 memset((STp->buffer)->b_data, 0, 12);
2715                 if (cmd_in == MTSETDRVBUFFER)
2716                         (STp->buffer)->b_data[2] = (arg & 7) << 4;
2717                 else
2718                         (STp->buffer)->b_data[2] =
2719                             STp->drv_buffer << 4;
2720                 (STp->buffer)->b_data[3] = 8;   /* block descriptor length */
2721                 if (cmd_in == MTSETDENSITY) {
2722                         (STp->buffer)->b_data[4] = arg;
2723                         STp->density_changed = 1;       /* At least we tried ;-) */
2724                 } else if (cmd_in == SET_DENS_AND_BLK)
2725                         (STp->buffer)->b_data[4] = arg >> 24;
2726                 else
2727                         (STp->buffer)->b_data[4] = STp->density;
2728                 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2729                         ltmp = arg & MT_ST_BLKSIZE_MASK;
2730                         if (cmd_in == MTSETBLK)
2731                                 STp->blksize_changed = 1; /* At least we tried ;-) */
2732                 } else
2733                         ltmp = STp->block_size;
2734                 (STp->buffer)->b_data[9] = (ltmp >> 16);
2735                 (STp->buffer)->b_data[10] = (ltmp >> 8);
2736                 (STp->buffer)->b_data[11] = ltmp;
2737                 timeout = STp->device->timeout;
2738                 DEBC(
2739                         if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2740                                 printk(ST_DEB_MSG
2741                                        "%s: Setting block size to %d bytes.\n", name,
2742                                        (STp->buffer)->b_data[9] * 65536 +
2743                                        (STp->buffer)->b_data[10] * 256 +
2744                                        (STp->buffer)->b_data[11]);
2745                         if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2746                                 printk(ST_DEB_MSG
2747                                        "%s: Setting density code to %x.\n", name,
2748                                        (STp->buffer)->b_data[4]);
2749                         if (cmd_in == MTSETDRVBUFFER)
2750                                 printk(ST_DEB_MSG
2751                                        "%s: Setting drive buffer code to %d.\n", name,
2752                                     ((STp->buffer)->b_data[2] >> 4) & 7);
2753                 )
2754                 break;
2755         default:
2756                 return (-ENOSYS);
2757         }
2758
2759         SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2760                            timeout, MAX_RETRIES, 1);
2761         if (!SRpnt)
2762                 return (STp->buffer)->syscall_result;
2763
2764         ioctl_result = (STp->buffer)->syscall_result;
2765
2766         if (!ioctl_result) {    /* SCSI command successful */
2767                 st_release_request(SRpnt);
2768                 SRpnt = NULL;
2769                 STps->drv_block = blkno;
2770                 STps->drv_file = fileno;
2771                 STps->at_sm = at_sm;
2772
2773                 if (cmd_in == MTBSFM)
2774                         ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2775                 else if (cmd_in == MTFSFM)
2776                         ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2777
2778                 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2779                         int old_block_size = STp->block_size;
2780                         STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2781                         if (STp->block_size != 0) {
2782                                 if (old_block_size == 0)
2783                                         normalize_buffer(STp->buffer);
2784                                 (STp->buffer)->buffer_blocks =
2785                                     (STp->buffer)->buffer_size / STp->block_size;
2786                         }
2787                         (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2788                         if (cmd_in == SET_DENS_AND_BLK)
2789                                 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2790                 } else if (cmd_in == MTSETDRVBUFFER)
2791                         STp->drv_buffer = (arg & 7);
2792                 else if (cmd_in == MTSETDENSITY)
2793                         STp->density = arg;
2794
2795                 if (cmd_in == MTEOM)
2796                         STps->eof = ST_EOD;
2797                 else if (cmd_in == MTFSF)
2798                         STps->eof = ST_FM;
2799                 else if (chg_eof)
2800                         STps->eof = ST_NOEOF;
2801
2802                 if (cmd_in == MTWEOF)
2803                         STps->rw = ST_IDLE;
2804         } else { /* SCSI command was not completely successful. Don't return
2805                     from this block without releasing the SCSI command block! */
2806                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2807
2808                 if (cmdstatp->flags & SENSE_EOM) {
2809                         if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2810                             cmd_in != MTBSR && cmd_in != MTBSS)
2811                                 STps->eof = ST_EOM_OK;
2812                         STps->drv_block = 0;
2813                 }
2814
2815                 if (cmdstatp->remainder_valid)
2816                         undone = (int)cmdstatp->uremainder64;
2817                 else
2818                         undone = 0;
2819
2820                 if (cmd_in == MTWEOF &&
2821                     cmdstatp->have_sense &&
2822                     (cmdstatp->flags & SENSE_EOM)) {
2823                         if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2824                             cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2825                                 ioctl_result = 0;       /* EOF(s) written successfully at EOM */
2826                                 STps->eof = ST_NOEOF;
2827                         } else {  /* Writing EOF(s) failed */
2828                                 if (fileno >= 0)
2829                                         fileno -= undone;
2830                                 if (undone < arg)
2831                                         STps->eof = ST_NOEOF;
2832                         }
2833                         STps->drv_file = fileno;
2834                 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2835                         if (fileno >= 0)
2836                                 STps->drv_file = fileno - undone;
2837                         else
2838                                 STps->drv_file = fileno;
2839                         STps->drv_block = -1;
2840                         STps->eof = ST_NOEOF;
2841                 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2842                         if (arg > 0 && undone < 0)  /* Some drives get this wrong */
2843                                 undone = (-undone);
2844                         if (STps->drv_file >= 0)
2845                                 STps->drv_file = fileno + undone;
2846                         STps->drv_block = 0;
2847                         STps->eof = ST_NOEOF;
2848                 } else if (cmd_in == MTFSR) {
2849                         if (cmdstatp->flags & SENSE_FMK) {      /* Hit filemark */
2850                                 if (STps->drv_file >= 0)
2851                                         STps->drv_file++;
2852                                 STps->drv_block = 0;
2853                                 STps->eof = ST_FM;
2854                         } else {
2855                                 if (blkno >= undone)
2856                                         STps->drv_block = blkno - undone;
2857                                 else
2858                                         STps->drv_block = (-1);
2859                                 STps->eof = ST_NOEOF;
2860                         }
2861                 } else if (cmd_in == MTBSR) {
2862                         if (cmdstatp->flags & SENSE_FMK) {      /* Hit filemark */
2863                                 STps->drv_file--;
2864                                 STps->drv_block = (-1);
2865                         } else {
2866                                 if (arg > 0 && undone < 0)  /* Some drives get this wrong */
2867                                         undone = (-undone);
2868                                 if (STps->drv_block >= 0)
2869                                         STps->drv_block = blkno + undone;
2870                         }
2871                         STps->eof = ST_NOEOF;
2872                 } else if (cmd_in == MTEOM) {
2873                         STps->drv_file = (-1);
2874                         STps->drv_block = (-1);
2875                         STps->eof = ST_EOD;
2876                 } else if (cmd_in == MTSETBLK ||
2877                            cmd_in == MTSETDENSITY ||
2878                            cmd_in == MTSETDRVBUFFER ||
2879                            cmd_in == SET_DENS_AND_BLK) {
2880                         if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2881                             !(STp->use_pf & PF_TESTED)) {
2882                                 /* Try the other possible state of Page Format if not
2883                                    already tried */
2884                                 STp->use_pf = !STp->use_pf | PF_TESTED;
2885                                 st_release_request(SRpnt);
2886                                 SRpnt = NULL;
2887                                 return st_int_ioctl(STp, cmd_in, arg);
2888                         }
2889                 } else if (chg_eof)
2890                         STps->eof = ST_NOEOF;
2891
2892                 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2893                         STps->eof = ST_EOD;
2894
2895                 st_release_request(SRpnt);
2896                 SRpnt = NULL;
2897         }
2898
2899         return ioctl_result;
2900 }
2901 \f
2902
2903 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2904    structure. */
2905
2906 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2907                         int logical)
2908 {
2909         int result;
2910         unsigned char scmd[MAX_COMMAND_SIZE];
2911         struct st_request *SRpnt;
2912         DEB( char *name = tape_name(STp); )
2913
2914         if (STp->ready != ST_READY)
2915                 return (-EIO);
2916
2917         memset(scmd, 0, MAX_COMMAND_SIZE);
2918         if ((STp->device)->scsi_level < SCSI_2) {
2919                 scmd[0] = QFA_REQUEST_BLOCK;
2920                 scmd[4] = 3;
2921         } else {
2922                 scmd[0] = READ_POSITION;
2923                 if (!logical && !STp->scsi2_logical)
2924                         scmd[1] = 1;
2925         }
2926         SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
2927                         STp->device->timeout, MAX_READY_RETRIES, 1);
2928         if (!SRpnt)
2929                 return (STp->buffer)->syscall_result;
2930
2931         if ((STp->buffer)->syscall_result != 0 ||
2932             (STp->device->scsi_level >= SCSI_2 &&
2933              ((STp->buffer)->b_data[0] & 4) != 0)) {
2934                 *block = *partition = 0;
2935                 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
2936                 result = (-EIO);
2937         } else {
2938                 result = 0;
2939                 if ((STp->device)->scsi_level < SCSI_2) {
2940                         *block = ((STp->buffer)->b_data[0] << 16)
2941                             + ((STp->buffer)->b_data[1] << 8)
2942                             + (STp->buffer)->b_data[2];
2943                         *partition = 0;
2944                 } else {
2945                         *block = ((STp->buffer)->b_data[4] << 24)
2946                             + ((STp->buffer)->b_data[5] << 16)
2947                             + ((STp->buffer)->b_data[6] << 8)
2948                             + (STp->buffer)->b_data[7];
2949                         *partition = (STp->buffer)->b_data[1];
2950                         if (((STp->buffer)->b_data[0] & 0x80) &&
2951                             (STp->buffer)->b_data[1] == 0)      /* BOP of partition 0 */
2952                                 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
2953                 }
2954                 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
2955                             *block, *partition));
2956         }
2957         st_release_request(SRpnt);
2958         SRpnt = NULL;
2959
2960         return result;
2961 }
2962
2963
2964 /* Set the tape block and partition. Negative partition means that only the
2965    block should be set in vendor specific way. */
2966 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
2967                         int logical)
2968 {
2969         struct st_partstat *STps;
2970         int result, p;
2971         unsigned int blk;
2972         int timeout;
2973         unsigned char scmd[MAX_COMMAND_SIZE];
2974         struct st_request *SRpnt;
2975         DEB( char *name = tape_name(STp); )
2976
2977         if (STp->ready != ST_READY)
2978                 return (-EIO);
2979         timeout = STp->long_timeout;
2980         STps = &(STp->ps[STp->partition]);
2981
2982         DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
2983                     name, block, partition));
2984         DEB(if (partition < 0)
2985                 return (-EIO); )
2986
2987         /* Update the location at the partition we are leaving */
2988         if ((!STp->can_partitions && partition != 0) ||
2989             partition >= ST_NBR_PARTITIONS)
2990                 return (-EINVAL);
2991         if (partition != STp->partition) {
2992                 if (get_location(STp, &blk, &p, 1))
2993                         STps->last_block_valid = 0;
2994                 else {
2995                         STps->last_block_valid = 1;
2996                         STps->last_block_visited = blk;
2997                         DEBC(printk(ST_DEB_MSG
2998                                     "%s: Visited block %d for partition %d saved.\n",
2999                                     name, blk, STp->partition));
3000                 }
3001         }
3002
3003         memset(scmd, 0, MAX_COMMAND_SIZE);
3004         if ((STp->device)->scsi_level < SCSI_2) {
3005                 scmd[0] = QFA_SEEK_BLOCK;
3006                 scmd[2] = (block >> 16);
3007                 scmd[3] = (block >> 8);
3008                 scmd[4] = block;
3009                 scmd[5] = 0;
3010         } else {
3011                 scmd[0] = SEEK_10;
3012                 scmd[3] = (block >> 24);
3013                 scmd[4] = (block >> 16);
3014                 scmd[5] = (block >> 8);
3015                 scmd[6] = block;
3016                 if (!logical && !STp->scsi2_logical)
3017                         scmd[1] = 4;
3018                 if (STp->partition != partition) {
3019                         scmd[1] |= 2;
3020                         scmd[8] = partition;
3021                         DEBC(printk(ST_DEB_MSG
3022                                     "%s: Trying to change partition from %d to %d\n",
3023                                     name, STp->partition, partition));
3024                 }
3025         }
3026         if (STp->immediate) {
3027                 scmd[1] |= 1;           /* Don't wait for completion */
3028                 timeout = STp->device->timeout;
3029         }
3030
3031         SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3032                            timeout, MAX_READY_RETRIES, 1);
3033         if (!SRpnt)
3034                 return (STp->buffer)->syscall_result;
3035
3036         STps->drv_block = STps->drv_file = (-1);
3037         STps->eof = ST_NOEOF;
3038         if ((STp->buffer)->syscall_result != 0) {
3039                 result = (-EIO);
3040                 if (STp->can_partitions &&
3041                     (STp->device)->scsi_level >= SCSI_2 &&
3042                     (p = find_partition(STp)) >= 0)
3043                         STp->partition = p;
3044         } else {
3045                 if (STp->can_partitions) {
3046                         STp->partition = partition;
3047                         STps = &(STp->ps[partition]);
3048                         if (!STps->last_block_valid ||
3049                             STps->last_block_visited != block) {
3050                                 STps->at_sm = 0;
3051                                 STps->rw = ST_IDLE;
3052                         }
3053                 } else
3054                         STps->at_sm = 0;
3055                 if (block == 0)
3056                         STps->drv_block = STps->drv_file = 0;
3057                 result = 0;
3058         }
3059
3060         st_release_request(SRpnt);
3061         SRpnt = NULL;
3062
3063         return result;
3064 }
3065
3066
3067 /* Find the current partition number for the drive status. Called from open and