9aadf2fcad6a271fb2fecfea1d2a28ed36bb3afc
[sfrench/cifs-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 - 2005 Kai Makisara
13    email Kai.Makisara@kolumbus.fi
14
15    Some small formal changes - aeb, 950809
16
17    Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
18  */
19
20 static char *verstr = "20050802";
21
22 #include <linux/module.h>
23
24 #include <linux/fs.h>
25 #include <linux/kernel.h>
26 #include <linux/sched.h>
27 #include <linux/mm.h>
28 #include <linux/init.h>
29 #include <linux/string.h>
30 #include <linux/errno.h>
31 #include <linux/mtio.h>
32 #include <linux/cdrom.h>
33 #include <linux/ioctl.h>
34 #include <linux/fcntl.h>
35 #include <linux/spinlock.h>
36 #include <linux/blkdev.h>
37 #include <linux/moduleparam.h>
38 #include <linux/devfs_fs_kernel.h>
39 #include <linux/cdev.h>
40 #include <linux/delay.h>
41
42 #include <asm/uaccess.h>
43 #include <asm/dma.h>
44 #include <asm/system.h>
45
46 #include <scsi/scsi.h>
47 #include <scsi/scsi_dbg.h>
48 #include <scsi/scsi_device.h>
49 #include <scsi/scsi_driver.h>
50 #include <scsi/scsi_eh.h>
51 #include <scsi/scsi_host.h>
52 #include <scsi/scsi_ioctl.h>
53 #include <scsi/scsi_request.h>
54 #include <scsi/sg.h>
55
56
57 /* The driver prints some debugging information on the console if DEBUG
58    is defined and non-zero. */
59 #define DEBUG 0
60
61 #if DEBUG
62 /* The message level for the debug messages is currently set to KERN_NOTICE
63    so that people can easily see the messages. Later when the debugging messages
64    in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
65 #define ST_DEB_MSG  KERN_NOTICE
66 #define DEB(a) a
67 #define DEBC(a) if (debugging) { a ; }
68 #else
69 #define DEB(a)
70 #define DEBC(a)
71 #endif
72
73 #define ST_KILOBYTE 1024
74
75 #include "st_options.h"
76 #include "st.h"
77
78 static int buffer_kbs;
79 static int max_sg_segs;
80 static int try_direct_io = TRY_DIRECT_IO;
81 static int try_rdio = 1;
82 static int try_wdio = 1;
83
84 static int st_dev_max;
85 static int st_nr_dev;
86
87 static struct class *st_sysfs_class;
88
89 MODULE_AUTHOR("Kai Makisara");
90 MODULE_DESCRIPTION("SCSI Tape Driver");
91 MODULE_LICENSE("GPL");
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 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 st_map_user_pages(struct scatterlist *, const unsigned int, 
192                              unsigned long, size_t, int, unsigned long);
193 static int sgl_map_user_pages(struct scatterlist *, const unsigned int, 
194                               unsigned long, size_t, int);
195 static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int);
196
197 static int st_probe(struct device *);
198 static int st_remove(struct device *);
199 static int st_init_command(struct scsi_cmnd *);
200
201 static void do_create_driverfs_files(void);
202 static void do_remove_driverfs_files(void);
203 static void do_create_class_files(struct scsi_tape *, int, int);
204
205 static struct scsi_driver st_template = {
206         .owner                  = THIS_MODULE,
207         .gendrv = {
208                 .name           = "st",
209                 .probe          = st_probe,
210                 .remove         = st_remove,
211         },
212         .init_command           = st_init_command,
213 };
214
215 static int st_compression(struct scsi_tape *, int);
216
217 static int find_partition(struct scsi_tape *);
218 static int switch_partition(struct scsi_tape *);
219
220 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
221
222 static void scsi_tape_release(struct kref *);
223
224 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
225
226 static DECLARE_MUTEX(st_ref_sem);
227
228 \f
229 #include "osst_detect.h"
230 #ifndef SIGS_FROM_OSST
231 #define SIGS_FROM_OSST \
232         {"OnStream", "SC-", "", "osst"}, \
233         {"OnStream", "DI-", "", "osst"}, \
234         {"OnStream", "DP-", "", "osst"}, \
235         {"OnStream", "USB", "", "osst"}, \
236         {"OnStream", "FW-", "", "osst"}
237 #endif
238
239 static struct scsi_tape *scsi_tape_get(int dev)
240 {
241         struct scsi_tape *STp = NULL;
242
243         down(&st_ref_sem);
244         write_lock(&st_dev_arr_lock);
245
246         if (dev < st_dev_max && scsi_tapes != NULL)
247                 STp = scsi_tapes[dev];
248         if (!STp) goto out;
249
250         kref_get(&STp->kref);
251
252         if (!STp->device)
253                 goto out_put;
254
255         if (scsi_device_get(STp->device))
256                 goto out_put;
257
258         goto out;
259
260 out_put:
261         kref_put(&STp->kref, scsi_tape_release);
262         STp = NULL;
263 out:
264         write_unlock(&st_dev_arr_lock);
265         up(&st_ref_sem);
266         return STp;
267 }
268
269 static void scsi_tape_put(struct scsi_tape *STp)
270 {
271         struct scsi_device *sdev = STp->device;
272
273         down(&st_ref_sem);
274         kref_put(&STp->kref, scsi_tape_release);
275         scsi_device_put(sdev);
276         up(&st_ref_sem);
277 }
278
279 struct st_reject_data {
280         char *vendor;
281         char *model;
282         char *rev;
283         char *driver_hint; /* Name of the correct driver, NULL if unknown */
284 };
285
286 static struct st_reject_data reject_list[] = {
287         /* {"XXX", "Yy-", "", NULL},  example */
288         SIGS_FROM_OSST,
289         {NULL, }};
290
291 /* If the device signature is on the list of incompatible drives, the
292    function returns a pointer to the name of the correct driver (if known) */
293 static char * st_incompatible(struct scsi_device* SDp)
294 {
295         struct st_reject_data *rp;
296
297         for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
298                 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
299                     !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
300                     !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
301                         if (rp->driver_hint)
302                                 return rp->driver_hint;
303                         else
304                                 return "unknown";
305                 }
306         return NULL;
307 }
308 \f
309
310 static inline char *tape_name(struct scsi_tape *tape)
311 {
312         return tape->disk->disk_name;
313 }
314
315
316 static void st_analyze_sense(struct scsi_request *SRpnt, struct st_cmdstatus *s)
317 {
318         const u8 *ucp;
319         const u8 *sense = SRpnt->sr_sense_buffer;
320
321         s->have_sense = scsi_request_normalize_sense(SRpnt, &s->sense_hdr);
322         s->flags = 0;
323
324         if (s->have_sense) {
325                 s->deferred = 0;
326                 s->remainder_valid =
327                         scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
328                 switch (sense[0] & 0x7f) {
329                 case 0x71:
330                         s->deferred = 1;
331                 case 0x70:
332                         s->fixed_format = 1;
333                         s->flags = sense[2] & 0xe0;
334                         break;
335                 case 0x73:
336                         s->deferred = 1;
337                 case 0x72:
338                         s->fixed_format = 0;
339                         ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
340                         s->flags = ucp ? (ucp[3] & 0xe0) : 0;
341                         break;
342                 }
343         }
344 }
345
346
347 /* Convert the result to success code */
348 static int st_chk_result(struct scsi_tape *STp, struct scsi_request * SRpnt)
349 {
350         int result = SRpnt->sr_result;
351         u8 scode;
352         DEB(const char *stp;)
353         char *name = tape_name(STp);
354         struct st_cmdstatus *cmdstatp;
355
356         if (!result)
357                 return 0;
358
359         cmdstatp = &STp->buffer->cmdstat;
360         st_analyze_sense(SRpnt, cmdstatp);
361
362         if (cmdstatp->have_sense)
363                 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
364         else
365                 scode = 0;
366
367         DEB(
368         if (debugging) {
369                 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x Len: %d\n",
370                        name, result,
371                        SRpnt->sr_cmnd[0], SRpnt->sr_cmnd[1], SRpnt->sr_cmnd[2],
372                        SRpnt->sr_cmnd[3], SRpnt->sr_cmnd[4], SRpnt->sr_cmnd[5],
373                        SRpnt->sr_bufflen);
374                 if (cmdstatp->have_sense)
375                         scsi_print_req_sense("st", SRpnt);
376         } ) /* end DEB */
377         if (!debugging) { /* Abnormal conditions for tape */
378                 if (!cmdstatp->have_sense)
379                         printk(KERN_WARNING
380                                "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
381                                name, result, suggestion(result),
382                                driver_byte(result) & DRIVER_MASK, host_byte(result));
383                 else if (cmdstatp->have_sense &&
384                          scode != NO_SENSE &&
385                          scode != RECOVERED_ERROR &&
386                          /* scode != UNIT_ATTENTION && */
387                          scode != BLANK_CHECK &&
388                          scode != VOLUME_OVERFLOW &&
389                          SRpnt->sr_cmnd[0] != MODE_SENSE &&
390                          SRpnt->sr_cmnd[0] != TEST_UNIT_READY) {
391                                 printk(KERN_WARNING "%s: Error with sense data: ", name);
392                                 scsi_print_req_sense("st", SRpnt);
393                 }
394         }
395
396         if (cmdstatp->fixed_format &&
397             STp->cln_mode >= EXTENDED_SENSE_START) {  /* Only fixed format sense */
398                 if (STp->cln_sense_value)
399                         STp->cleaning_req |= ((SRpnt->sr_sense_buffer[STp->cln_mode] &
400                                                STp->cln_sense_mask) == STp->cln_sense_value);
401                 else
402                         STp->cleaning_req |= ((SRpnt->sr_sense_buffer[STp->cln_mode] &
403                                                STp->cln_sense_mask) != 0);
404         }
405         if (cmdstatp->have_sense &&
406             cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
407                 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
408
409         STp->pos_unknown |= STp->device->was_reset;
410
411         if (cmdstatp->have_sense &&
412             scode == RECOVERED_ERROR
413 #if ST_RECOVERED_WRITE_FATAL
414             && SRpnt->sr_cmnd[0] != WRITE_6
415             && SRpnt->sr_cmnd[0] != WRITE_FILEMARKS
416 #endif
417             ) {
418                 STp->recover_count++;
419                 STp->recover_reg++;
420
421                 DEB(
422                 if (debugging) {
423                         if (SRpnt->sr_cmnd[0] == READ_6)
424                                 stp = "read";
425                         else if (SRpnt->sr_cmnd[0] == WRITE_6)
426                                 stp = "write";
427                         else
428                                 stp = "ioctl";
429                         printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
430                                STp->recover_count);
431                 } ) /* end DEB */
432
433                 if (cmdstatp->flags == 0)
434                         return 0;
435         }
436         return (-EIO);
437 }
438
439
440 /* Wakeup from interrupt */
441 static void st_sleep_done(struct scsi_cmnd * SCpnt)
442 {
443         struct scsi_tape *STp = container_of(SCpnt->request->rq_disk->private_data,
444                                              struct scsi_tape, driver);
445
446         (STp->buffer)->cmdstat.midlevel_result = SCpnt->result;
447         SCpnt->request->rq_status = RQ_SCSI_DONE;
448         DEB( STp->write_pending = 0; )
449
450         if (SCpnt->request->waiting)
451                 complete(SCpnt->request->waiting);
452 }
453
454 /* Do the scsi command. Waits until command performed if do_wait is true.
455    Otherwise write_behind_check() is used to check that the command
456    has finished. */
457 static struct scsi_request *
458 st_do_scsi(struct scsi_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
459            int bytes, int direction, int timeout, int retries, int do_wait)
460 {
461         struct completion *waiting;
462         unsigned char *bp;
463
464         /* if async, make sure there's no command outstanding */
465         if (!do_wait && ((STp->buffer)->last_SRpnt)) {
466                 printk(KERN_ERR "%s: Async command already active.\n",
467                        tape_name(STp));
468                 if (signal_pending(current))
469                         (STp->buffer)->syscall_result = (-EINTR);
470                 else
471                         (STp->buffer)->syscall_result = (-EBUSY);
472                 return NULL;
473         }
474
475         if (SRpnt == NULL) {
476                 SRpnt = scsi_allocate_request(STp->device, GFP_ATOMIC);
477                 if (SRpnt == NULL) {
478                         DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n",
479                                      tape_name(STp)); );
480                         if (signal_pending(current))
481                                 (STp->buffer)->syscall_result = (-EINTR);
482                         else
483                                 (STp->buffer)->syscall_result = (-EBUSY);
484                         return NULL;
485                 }
486         }
487
488         /* If async IO, set last_SRpnt. This ptr tells write_behind_check
489            which IO is outstanding. It's nulled out when the IO completes. */
490         if (!do_wait)
491                 (STp->buffer)->last_SRpnt = SRpnt;
492
493         waiting = &STp->wait;
494         init_completion(waiting);
495         SRpnt->sr_use_sg = STp->buffer->do_dio || (bytes > (STp->buffer)->frp[0].length);
496         if (SRpnt->sr_use_sg) {
497                 if (!STp->buffer->do_dio)
498                         buf_to_sg(STp->buffer, bytes);
499                 SRpnt->sr_use_sg = (STp->buffer)->sg_segs;
500                 bp = (char *) &((STp->buffer)->sg[0]);
501         } else
502                 bp = (STp->buffer)->b_data;
503         SRpnt->sr_data_direction = direction;
504         SRpnt->sr_cmd_len = 0;
505         SRpnt->sr_request->waiting = waiting;
506         SRpnt->sr_request->rq_status = RQ_SCSI_BUSY;
507         SRpnt->sr_request->rq_disk = STp->disk;
508         SRpnt->sr_request->end_io = blk_end_sync_rq;
509         STp->buffer->cmdstat.have_sense = 0;
510
511         scsi_do_req(SRpnt, (void *) cmd, bp, bytes,
512                     st_sleep_done, timeout, retries);
513
514         if (do_wait) {
515                 wait_for_completion(waiting);
516                 SRpnt->sr_request->waiting = NULL;
517                 if (SRpnt->sr_request->rq_status != RQ_SCSI_DONE)
518                         SRpnt->sr_result |= (DRIVER_ERROR << 24);
519                 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
520         }
521         return SRpnt;
522 }
523
524
525 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
526    write has been correct but EOM early warning reached, -EIO if write ended in
527    error or zero if write successful. Asynchronous writes are used only in
528    variable block mode. */
529 static int write_behind_check(struct scsi_tape * STp)
530 {
531         int retval = 0;
532         struct st_buffer *STbuffer;
533         struct st_partstat *STps;
534         struct st_cmdstatus *cmdstatp;
535         struct scsi_request *SRpnt;
536
537         STbuffer = STp->buffer;
538         if (!STbuffer->writing)
539                 return 0;
540
541         DEB(
542         if (STp->write_pending)
543                 STp->nbr_waits++;
544         else
545                 STp->nbr_finished++;
546         ) /* end DEB */
547
548         wait_for_completion(&(STp->wait));
549         SRpnt = STbuffer->last_SRpnt;
550         STbuffer->last_SRpnt = NULL;
551         SRpnt->sr_request->waiting = NULL;
552         if (SRpnt->sr_request->rq_status != RQ_SCSI_DONE)
553                 SRpnt->sr_result |= (DRIVER_ERROR << 24);
554
555         (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
556         scsi_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 scsi_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         scsi_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 scsi_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                 scsi_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 scsi_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 scsi_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                 scsi_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 scsi_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_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->sr_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_WARNING
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         scsi_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->recover_count = 0;
1172         DEB( STp->nbr_waits = STp->nbr_finished = 0;
1173              STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = STp->nbr_combinable = 0; )
1174
1175         retval = check_tape(STp, filp);
1176         if (retval < 0)
1177                 goto err_out;
1178         if ((filp->f_flags & O_NONBLOCK) == 0 &&
1179             retval != CHKRES_READY) {
1180                 retval = (-EIO);
1181                 goto err_out;
1182         }
1183         return 0;
1184
1185  err_out:
1186         normalize_buffer(STp->buffer);
1187         STp->in_use = 0;
1188         scsi_tape_put(STp);
1189         return retval;
1190
1191 }
1192 \f
1193
1194 /* Flush the tape buffer before close */
1195 static int st_flush(struct file *filp)
1196 {
1197         int result = 0, result2;
1198         unsigned char cmd[MAX_COMMAND_SIZE];
1199         struct scsi_request *SRpnt;
1200         struct scsi_tape *STp = filp->private_data;
1201         struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1202         struct st_partstat *STps = &(STp->ps[STp->partition]);
1203         char *name = tape_name(STp);
1204
1205         if (file_count(filp) > 1)
1206                 return 0;
1207
1208         if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1209                 result = flush_write_buffer(STp);
1210                 if (result != 0 && result != (-ENOSPC))
1211                         goto out;
1212         }
1213
1214         if (STp->can_partitions &&
1215             (result2 = switch_partition(STp)) < 0) {
1216                 DEBC(printk(ST_DEB_MSG
1217                                "%s: switch_partition at close failed.\n", name));
1218                 if (result == 0)
1219                         result = result2;
1220                 goto out;
1221         }
1222
1223         DEBC( if (STp->nbr_requests)
1224                 printk(KERN_WARNING "%s: Number of r/w requests %d, dio used in %d, pages %d (%d).\n",
1225                        name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages, STp->nbr_combinable));
1226
1227         if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1228                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1229
1230                 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1231                             name, STp->nbr_waits, STp->nbr_finished);
1232                 )
1233
1234                 memset(cmd, 0, MAX_COMMAND_SIZE);
1235                 cmd[0] = WRITE_FILEMARKS;
1236                 cmd[4] = 1 + STp->two_fm;
1237
1238                 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1239                                    STp->device->timeout, MAX_WRITE_RETRIES, 1);
1240                 if (!SRpnt) {
1241                         result = (STp->buffer)->syscall_result;
1242                         goto out;
1243                 }
1244
1245                 if (STp->buffer->syscall_result == 0 ||
1246                     (cmdstatp->have_sense && !cmdstatp->deferred &&
1247                      (cmdstatp->flags & SENSE_EOM) &&
1248                      (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1249                       cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1250                      (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1251                         /* Write successful at EOM */
1252                         scsi_release_request(SRpnt);
1253                         SRpnt = NULL;
1254                         if (STps->drv_file >= 0)
1255                                 STps->drv_file++;
1256                         STps->drv_block = 0;
1257                         if (STp->two_fm)
1258                                 cross_eof(STp, 0);
1259                         STps->eof = ST_FM;
1260                 }
1261                 else { /* Write error */
1262                         scsi_release_request(SRpnt);
1263                         SRpnt = NULL;
1264                         printk(KERN_ERR "%s: Error on write filemark.\n", name);
1265                         if (result == 0)
1266                                 result = (-EIO);
1267                 }
1268
1269                 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1270                             name, cmd[4]));
1271         } else if (!STp->rew_at_close) {
1272                 STps = &(STp->ps[STp->partition]);
1273                 if (!STm->sysv || STps->rw != ST_READING) {
1274                         if (STp->can_bsr)
1275                                 result = flush_buffer(STp, 0);
1276                         else if (STps->eof == ST_FM_HIT) {
1277                                 result = cross_eof(STp, 0);
1278                                 if (result) {
1279                                         if (STps->drv_file >= 0)
1280                                                 STps->drv_file++;
1281                                         STps->drv_block = 0;
1282                                         STps->eof = ST_FM;
1283                                 } else
1284                                         STps->eof = ST_NOEOF;
1285                         }
1286                 } else if ((STps->eof == ST_NOEOF &&
1287                             !(result = cross_eof(STp, 1))) ||
1288                            STps->eof == ST_FM_HIT) {
1289                         if (STps->drv_file >= 0)
1290                                 STps->drv_file++;
1291                         STps->drv_block = 0;
1292                         STps->eof = ST_FM;
1293                 }
1294         }
1295
1296       out:
1297         if (STp->rew_at_close) {
1298                 result2 = st_int_ioctl(STp, MTREW, 1);
1299                 if (result == 0)
1300                         result = result2;
1301         }
1302         return result;
1303 }
1304
1305
1306 /* Close the device and release it. BKL is not needed: this is the only thread
1307    accessing this tape. */
1308 static int st_release(struct inode *inode, struct file *filp)
1309 {
1310         int result = 0;
1311         struct scsi_tape *STp = filp->private_data;
1312
1313         if (STp->door_locked == ST_LOCKED_AUTO)
1314                 do_door_lock(STp, 0);
1315
1316         normalize_buffer(STp->buffer);
1317         write_lock(&st_dev_arr_lock);
1318         STp->in_use = 0;
1319         write_unlock(&st_dev_arr_lock);
1320         scsi_tape_put(STp);
1321
1322         return result;
1323 }
1324 \f
1325 /* The checks common to both reading and writing */
1326 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1327 {
1328         ssize_t retval = 0;
1329
1330         /*
1331          * If we are in the middle of error recovery, don't let anyone
1332          * else try and use this device.  Also, if error recovery fails, it
1333          * may try and take the device offline, in which case all further
1334          * access to the device is prohibited.
1335          */
1336         if (!scsi_block_when_processing_errors(STp->device)) {
1337                 retval = (-ENXIO);
1338                 goto out;
1339         }
1340
1341         if (STp->ready != ST_READY) {
1342                 if (STp->ready == ST_NO_TAPE)
1343                         retval = (-ENOMEDIUM);
1344                 else
1345                         retval = (-EIO);
1346                 goto out;
1347         }
1348
1349         if (! STp->modes[STp->current_mode].defined) {
1350                 retval = (-ENXIO);
1351                 goto out;
1352         }
1353
1354
1355         /*
1356          * If there was a bus reset, block further access
1357          * to this device.
1358          */
1359         if (STp->pos_unknown) {
1360                 retval = (-EIO);
1361                 goto out;
1362         }
1363
1364         if (count == 0)
1365                 goto out;
1366
1367         DEB(
1368         if (!STp->in_use) {
1369                 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1370                 retval = (-EIO);
1371                 goto out;
1372         } ) /* end DEB */
1373
1374         if (STp->can_partitions &&
1375             (retval = switch_partition(STp)) < 0)
1376                 goto out;
1377
1378         if (STp->block_size == 0 && STp->max_block > 0 &&
1379             (count < STp->min_block || count > STp->max_block)) {
1380                 retval = (-EINVAL);
1381                 goto out;
1382         }
1383
1384         if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1385             !do_door_lock(STp, 1))
1386                 STp->door_locked = ST_LOCKED_AUTO;
1387
1388  out:
1389         return retval;
1390 }
1391
1392
1393 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1394                            size_t count, int is_read)
1395 {
1396         int i, bufsize, retval = 0;
1397         struct st_buffer *STbp = STp->buffer;
1398
1399         if (is_read)
1400                 i = STp->try_dio && try_rdio;
1401         else
1402                 i = STp->try_dio && try_wdio;
1403         if (i && ((unsigned long)buf & queue_dma_alignment(
1404                                         STp->device->request_queue)) == 0) {
1405                 i = st_map_user_pages(&(STbp->sg[0]), STbp->use_sg,
1406                                       (unsigned long)buf, count, (is_read ? READ : WRITE),
1407                                       STp->max_pfn);
1408                 if (i > 0) {
1409                         STbp->do_dio = i;
1410                         STbp->buffer_bytes = 0;   /* can be used as transfer counter */
1411                 }
1412                 else
1413                         STbp->do_dio = 0;  /* fall back to buffering with any error */
1414                 STbp->sg_segs = STbp->do_dio;
1415                 STbp->frp_sg_current = 0;
1416                 DEB(
1417                      if (STbp->do_dio) {
1418                         STp->nbr_dio++;
1419                         STp->nbr_pages += STbp->do_dio;
1420                         for (i=1; i < STbp->do_dio; i++)
1421                                 if (page_to_pfn(STbp->sg[i].page) == page_to_pfn(STbp->sg[i-1].page) + 1)
1422                                         STp->nbr_combinable++;
1423                      }
1424                 )
1425         } else
1426                 STbp->do_dio = 0;
1427         DEB( STp->nbr_requests++; )
1428
1429         if (!STbp->do_dio) {
1430                 if (STp->block_size)
1431                         bufsize = STp->block_size > st_fixed_buffer_size ?
1432                                 STp->block_size : st_fixed_buffer_size;
1433                 else
1434                         bufsize = count;
1435                 if (bufsize > STbp->buffer_size &&
1436                     !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1437                         printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1438                                tape_name(STp), bufsize);
1439                         retval = (-EOVERFLOW);
1440                         goto out;
1441                 }
1442                 if (STp->block_size)
1443                         STbp->buffer_blocks = bufsize / STp->block_size;
1444         }
1445
1446  out:
1447         return retval;
1448 }
1449
1450
1451 /* Can be called more than once after each setup_buffer() */
1452 static void release_buffering(struct scsi_tape *STp)
1453 {
1454         struct st_buffer *STbp;
1455
1456         STbp = STp->buffer;
1457         if (STbp->do_dio) {
1458                 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, 0);
1459                 STbp->do_dio = 0;
1460         }
1461 }
1462
1463
1464 /* Write command */
1465 static ssize_t
1466 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1467 {
1468         ssize_t total;
1469         ssize_t i, do_count, blks, transfer;
1470         ssize_t retval;
1471         int undone, retry_eot = 0, scode;
1472         int async_write;
1473         unsigned char cmd[MAX_COMMAND_SIZE];
1474         const char __user *b_point;
1475         struct scsi_request *SRpnt = NULL;
1476         struct scsi_tape *STp = filp->private_data;
1477         struct st_modedef *STm;
1478         struct st_partstat *STps;
1479         struct st_buffer *STbp;
1480         char *name = tape_name(STp);
1481
1482         if (down_interruptible(&STp->lock))
1483                 return -ERESTARTSYS;
1484
1485         retval = rw_checks(STp, filp, count);
1486         if (retval || count == 0)
1487                 goto out;
1488
1489         /* Write must be integral number of blocks */
1490         if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1491                 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1492                        name);
1493                 retval = (-EINVAL);
1494                 goto out;
1495         }
1496
1497         STm = &(STp->modes[STp->current_mode]);
1498         STps = &(STp->ps[STp->partition]);
1499
1500         if (STp->write_prot) {
1501                 retval = (-EACCES);
1502                 goto out;
1503         }
1504
1505
1506         if (STps->rw == ST_READING) {
1507                 retval = flush_buffer(STp, 0);
1508                 if (retval)
1509                         goto out;
1510                 STps->rw = ST_WRITING;
1511         } else if (STps->rw != ST_WRITING &&
1512                    STps->drv_file == 0 && STps->drv_block == 0) {
1513                 if ((retval = set_mode_densblk(STp, STm)) < 0)
1514                         goto out;
1515                 if (STm->default_compression != ST_DONT_TOUCH &&
1516                     !(STp->compression_changed)) {
1517                         if (st_compression(STp, (STm->default_compression == ST_YES))) {
1518                                 printk(KERN_WARNING "%s: Can't set default compression.\n",
1519                                        name);
1520                                 if (modes_defined) {
1521                                         retval = (-EINVAL);
1522                                         goto out;
1523                                 }
1524                         }
1525                 }
1526         }
1527
1528         STbp = STp->buffer;
1529         i = write_behind_check(STp);
1530         if (i) {
1531                 if (i == -ENOSPC)
1532                         STps->eof = ST_EOM_OK;
1533                 else
1534                         STps->eof = ST_EOM_ERROR;
1535         }
1536
1537         if (STps->eof == ST_EOM_OK) {
1538                 STps->eof = ST_EOD_1;  /* allow next write */
1539                 retval = (-ENOSPC);
1540                 goto out;
1541         }
1542         else if (STps->eof == ST_EOM_ERROR) {
1543                 retval = (-EIO);
1544                 goto out;
1545         }
1546
1547         /* Check the buffer readability in cases where copy_user might catch
1548            the problems after some tape movement. */
1549         if (STp->block_size != 0 &&
1550             !STbp->do_dio &&
1551             (copy_from_user(&i, buf, 1) != 0 ||
1552              copy_from_user(&i, buf + count - 1, 1) != 0)) {
1553                 retval = (-EFAULT);
1554                 goto out;
1555         }
1556
1557         retval = setup_buffering(STp, buf, count, 0);
1558         if (retval)
1559                 goto out;
1560
1561         total = count;
1562
1563         memset(cmd, 0, MAX_COMMAND_SIZE);
1564         cmd[0] = WRITE_6;
1565         cmd[1] = (STp->block_size != 0);
1566
1567         STps->rw = ST_WRITING;
1568
1569         b_point = buf;
1570         while (count > 0 && !retry_eot) {
1571
1572                 if (STbp->do_dio) {
1573                         do_count = count;
1574                 }
1575                 else {
1576                         if (STp->block_size == 0)
1577                                 do_count = count;
1578                         else {
1579                                 do_count = STbp->buffer_blocks * STp->block_size -
1580                                         STbp->buffer_bytes;
1581                                 if (do_count > count)
1582                                         do_count = count;
1583                         }
1584
1585                         i = append_to_buffer(b_point, STbp, do_count);
1586                         if (i) {
1587                                 retval = i;
1588                                 goto out;
1589                         }
1590                 }
1591                 count -= do_count;
1592                 b_point += do_count;
1593
1594                 async_write = STp->block_size == 0 && !STbp->do_dio &&
1595                         STm->do_async_writes && STps->eof < ST_EOM_OK;
1596
1597                 if (STp->block_size != 0 && STm->do_buffer_writes &&
1598                     !(STp->try_dio && try_wdio) && STps->eof < ST_EOM_OK &&
1599                     STbp->buffer_bytes < STbp->buffer_size) {
1600                         STp->dirty = 1;
1601                         /* Don't write a buffer that is not full enough. */
1602                         if (!async_write && count == 0)
1603                                 break;
1604                 }
1605
1606         retry_write:
1607                 if (STp->block_size == 0)
1608                         blks = transfer = do_count;
1609                 else {
1610                         if (!STbp->do_dio)
1611                                 blks = STbp->buffer_bytes;
1612                         else
1613                                 blks = do_count;
1614                         blks /= STp->block_size;
1615                         transfer = blks * STp->block_size;
1616                 }
1617                 cmd[2] = blks >> 16;
1618                 cmd[3] = blks >> 8;
1619                 cmd[4] = blks;
1620
1621                 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1622                                    STp->device->timeout, MAX_WRITE_RETRIES, !async_write);
1623                 if (!SRpnt) {
1624                         retval = STbp->syscall_result;
1625                         goto out;
1626                 }
1627                 if (async_write) {
1628                         STbp->writing = transfer;
1629                         STp->dirty = !(STbp->writing ==
1630                                        STbp->buffer_bytes);
1631                         SRpnt = NULL;  /* Prevent releasing this request! */
1632                         DEB( STp->write_pending = 1; )
1633                         break;
1634                 }
1635
1636                 if (STbp->syscall_result != 0) {
1637                         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1638
1639                         DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1640                         if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1641                                 scode = cmdstatp->sense_hdr.sense_key;
1642                                 if (cmdstatp->remainder_valid)
1643                                         undone = (int)cmdstatp->uremainder64;
1644                                 else if (STp->block_size == 0 &&
1645                                          scode == VOLUME_OVERFLOW)
1646                                         undone = transfer;
1647                                 else
1648                                         undone = 0;
1649                                 if (STp->block_size != 0)
1650                                         undone *= STp->block_size;
1651                                 if (undone <= do_count) {
1652                                         /* Only data from this write is not written */
1653                                         count += undone;
1654                                         do_count -= undone;
1655                                         if (STp->block_size)
1656                                                 blks = (transfer - undone) / STp->block_size;
1657                                         STps->eof = ST_EOM_OK;
1658                                         /* Continue in fixed block mode if all written
1659                                            in this request but still something left to write
1660                                            (retval left to zero)
1661                                         */
1662                                         if (STp->block_size == 0 ||
1663                                             undone > 0 || count == 0)
1664                                                 retval = (-ENOSPC); /* EOM within current request */
1665                                         DEBC(printk(ST_DEB_MSG
1666                                                        "%s: EOM with %d bytes unwritten.\n",
1667                                                        name, (int)count));
1668                                 } else {
1669                                         /* EOT within data buffered earlier (possible only
1670                                            in fixed block mode without direct i/o) */
1671                                         if (!retry_eot && !cmdstatp->deferred &&
1672                                             (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1673                                                 move_buffer_data(STp->buffer, transfer - undone);
1674                                                 retry_eot = 1;
1675                                                 if (STps->drv_block >= 0) {
1676                                                         STps->drv_block += (transfer - undone) /
1677                                                                 STp->block_size;
1678                                                 }
1679                                                 STps->eof = ST_EOM_OK;
1680                                                 DEBC(printk(ST_DEB_MSG
1681                                                             "%s: Retry write of %d bytes at EOM.\n",
1682                                                             name, STp->buffer->buffer_bytes));
1683                                                 goto retry_write;
1684                                         }
1685                                         else {
1686                                                 /* Either error within data buffered by driver or
1687                                                    failed retry */
1688                                                 count -= do_count;
1689                                                 blks = do_count = 0;
1690                                                 STps->eof = ST_EOM_ERROR;
1691                                                 STps->drv_block = (-1); /* Too cautious? */
1692                                                 retval = (-EIO);        /* EOM for old data */
1693                                                 DEBC(printk(ST_DEB_MSG
1694                                                             "%s: EOM with lost data.\n",
1695                                                             name));
1696                                         }
1697                                 }
1698                         } else {
1699                                 count += do_count;
1700                                 STps->drv_block = (-1);         /* Too cautious? */
1701                                 retval = (-EIO);
1702                         }
1703
1704                 }
1705
1706                 if (STps->drv_block >= 0) {
1707                         if (STp->block_size == 0)
1708                                 STps->drv_block += (do_count > 0);
1709                         else
1710                                 STps->drv_block += blks;
1711                 }
1712
1713                 STbp->buffer_bytes = 0;
1714                 STp->dirty = 0;
1715
1716                 if (retval || retry_eot) {
1717                         if (count < total)
1718                                 retval = total - count;
1719                         goto out;
1720                 }
1721         }
1722
1723         if (STps->eof == ST_EOD_1)
1724                 STps->eof = ST_EOM_OK;
1725         else if (STps->eof != ST_EOM_OK)
1726                 STps->eof = ST_NOEOF;
1727         retval = total - count;
1728
1729  out:
1730         if (SRpnt != NULL)
1731                 scsi_release_request(SRpnt);
1732         release_buffering(STp);
1733         up(&STp->lock);
1734
1735         return retval;
1736 }
1737 \f
1738 /* Read data from the tape. Returns zero in the normal case, one if the
1739    eof status has changed, and the negative error code in case of a
1740    fatal error. Otherwise updates the buffer and the eof state.
1741
1742    Does release user buffer mapping if it is set.
1743 */
1744 static long read_tape(struct scsi_tape *STp, long count,
1745                       struct scsi_request ** aSRpnt)
1746 {
1747         int transfer, blks, bytes;
1748         unsigned char cmd[MAX_COMMAND_SIZE];
1749         struct scsi_request *SRpnt;
1750         struct st_modedef *STm;
1751         struct st_partstat *STps;
1752         struct st_buffer *STbp;
1753         int retval = 0;
1754         char *name = tape_name(STp);
1755
1756         if (count == 0)
1757                 return 0;
1758
1759         STm = &(STp->modes[STp->current_mode]);
1760         STps = &(STp->ps[STp->partition]);
1761         if (STps->eof == ST_FM_HIT)
1762                 return 1;
1763         STbp = STp->buffer;
1764
1765         if (STp->block_size == 0)
1766                 blks = bytes = count;
1767         else {
1768                 if (!(STp->try_dio && try_rdio) && STm->do_read_ahead) {
1769                         blks = (STp->buffer)->buffer_blocks;
1770                         bytes = blks * STp->block_size;
1771                 } else {
1772                         bytes = count;
1773                         if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1774                                 bytes = (STp->buffer)->buffer_size;
1775                         blks = bytes / STp->block_size;
1776                         bytes = blks * STp->block_size;
1777                 }
1778         }
1779
1780         memset(cmd, 0, MAX_COMMAND_SIZE);
1781         cmd[0] = READ_6;
1782         cmd[1] = (STp->block_size != 0);
1783         cmd[2] = blks >> 16;
1784         cmd[3] = blks >> 8;
1785         cmd[4] = blks;
1786
1787         SRpnt = *aSRpnt;
1788         SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1789                            STp->device->timeout, MAX_RETRIES, 1);
1790         release_buffering(STp);
1791         *aSRpnt = SRpnt;
1792         if (!SRpnt)
1793                 return STbp->syscall_result;
1794
1795         STbp->read_pointer = 0;
1796         STps->at_sm = 0;
1797
1798         /* Something to check */
1799         if (STbp->syscall_result) {
1800                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1801
1802                 retval = 1;
1803                 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1804                             name,
1805                             SRpnt->sr_sense_buffer[0], SRpnt->sr_sense_buffer[1],
1806                             SRpnt->sr_sense_buffer[2], SRpnt->sr_sense_buffer[3],
1807                             SRpnt->sr_sense_buffer[4], SRpnt->sr_sense_buffer[5],
1808                             SRpnt->sr_sense_buffer[6], SRpnt->sr_sense_buffer[7]));
1809                 if (cmdstatp->have_sense) {
1810
1811                         if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1812                                 cmdstatp->flags &= 0xcf;        /* No need for EOM in this case */
1813
1814                         if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1815                                 /* Compute the residual count */
1816                                 if (cmdstatp->remainder_valid)
1817                                         transfer = (int)cmdstatp->uremainder64;
1818                                 else
1819                                         transfer = 0;
1820                                 if (STp->block_size == 0 &&
1821                                     cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1822                                         transfer = bytes;
1823
1824                                 if (cmdstatp->flags & SENSE_ILI) {      /* ILI */
1825                                         if (STp->block_size == 0) {
1826                                                 if (transfer <= 0) {
1827                                                         if (transfer < 0)
1828                                                                 printk(KERN_NOTICE
1829                                                                        "%s: Failed to read %d byte block with %d byte transfer.\n",
1830                                                                        name, bytes - transfer, bytes);
1831                                                         if (STps->drv_block >= 0)
1832                                                                 STps->drv_block += 1;
1833                                                         STbp->buffer_bytes = 0;
1834                                                         return (-ENOMEM);
1835                                                 }
1836                                                 STbp->buffer_bytes = bytes - transfer;
1837                                         } else {
1838                                                 scsi_release_request(SRpnt);
1839                                                 SRpnt = *aSRpnt = NULL;
1840                                                 if (transfer == blks) { /* We did not get anything, error */
1841                                                         printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1842                                                         if (STps->drv_block >= 0)
1843                                                                 STps->drv_block += blks - transfer + 1;
1844                                                         st_int_ioctl(STp, MTBSR, 1);
1845                                                         return (-EIO);
1846                                                 }
1847                                                 /* We have some data, deliver it */
1848                                                 STbp->buffer_bytes = (blks - transfer) *
1849                                                     STp->block_size;
1850                                                 DEBC(printk(ST_DEB_MSG
1851                                                             "%s: ILI but enough data received %ld %d.\n",
1852                                                             name, count, STbp->buffer_bytes));
1853                                                 if (STps->drv_block >= 0)
1854                                                         STps->drv_block += 1;
1855                                                 if (st_int_ioctl(STp, MTBSR, 1))
1856                                                         return (-EIO);
1857                                         }
1858                                 } else if (cmdstatp->flags & SENSE_FMK) {       /* FM overrides EOM */
1859                                         if (STps->eof != ST_FM_HIT)
1860                                                 STps->eof = ST_FM_HIT;
1861                                         else
1862                                                 STps->eof = ST_EOD_2;
1863                                         if (STp->block_size == 0)
1864                                                 STbp->buffer_bytes = 0;
1865                                         else
1866                                                 STbp->buffer_bytes =
1867                                                     bytes - transfer * STp->block_size;
1868                                         DEBC(printk(ST_DEB_MSG
1869                                                     "%s: EOF detected (%d bytes read).\n",
1870                                                     name, STbp->buffer_bytes));
1871                                 } else if (cmdstatp->flags & SENSE_EOM) {
1872                                         if (STps->eof == ST_FM)
1873                                                 STps->eof = ST_EOD_1;
1874                                         else
1875                                                 STps->eof = ST_EOM_OK;
1876                                         if (STp->block_size == 0)
1877                                                 STbp->buffer_bytes = bytes - transfer;
1878                                         else
1879                                                 STbp->buffer_bytes =
1880                                                     bytes - transfer * STp->block_size;
1881
1882                                         DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1883                                                     name, STbp->buffer_bytes));
1884                                 }
1885                         }
1886                         /* end of EOF, EOM, ILI test */ 
1887                         else {  /* nonzero sense key */
1888                                 DEBC(printk(ST_DEB_MSG
1889                                             "%s: Tape error while reading.\n", name));
1890                                 STps->drv_block = (-1);
1891                                 if (STps->eof == ST_FM &&
1892                                     cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1893                                         DEBC(printk(ST_DEB_MSG
1894                                                     "%s: Zero returned for first BLANK CHECK after EOF.\n",
1895                                                     name));
1896                                         STps->eof = ST_EOD_2;   /* First BLANK_CHECK after FM */
1897                                 } else  /* Some other extended sense code */
1898                                         retval = (-EIO);
1899                         }
1900
1901                         if (STbp->buffer_bytes < 0)  /* Caused by bogus sense data */
1902                                 STbp->buffer_bytes = 0;
1903                 }
1904                 /* End of extended sense test */ 
1905                 else {          /* Non-extended sense */
1906                         retval = STbp->syscall_result;
1907                 }
1908
1909         }
1910         /* End of error handling */ 
1911         else                    /* Read successful */
1912                 STbp->buffer_bytes = bytes;
1913
1914         if (STps->drv_block >= 0) {
1915                 if (STp->block_size == 0)
1916                         STps->drv_block++;
1917                 else
1918                         STps->drv_block += STbp->buffer_bytes / STp->block_size;
1919         }
1920         return retval;
1921 }
1922 \f
1923
1924 /* Read command */
1925 static ssize_t
1926 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
1927 {
1928         ssize_t total;
1929         ssize_t retval = 0;
1930         ssize_t i, transfer;
1931         int special, do_dio = 0;
1932         struct scsi_request *SRpnt = NULL;
1933         struct scsi_tape *STp = filp->private_data;
1934         struct st_modedef *STm;
1935         struct st_partstat *STps;
1936         struct st_buffer *STbp = STp->buffer;
1937         DEB( char *name = tape_name(STp); )
1938
1939         if (down_interruptible(&STp->lock))
1940                 return -ERESTARTSYS;
1941
1942         retval = rw_checks(STp, filp, count);
1943         if (retval || count == 0)
1944                 goto out;
1945
1946         STm = &(STp->modes[STp->current_mode]);
1947         if (!(STm->do_read_ahead) && STp->block_size != 0 &&
1948             (count % STp->block_size) != 0) {
1949                 retval = (-EINVAL);     /* Read must be integral number of blocks */
1950                 goto out;
1951         }
1952
1953         STps = &(STp->ps[STp->partition]);
1954         if (STps->rw == ST_WRITING) {
1955                 retval = flush_buffer(STp, 0);
1956                 if (retval)
1957                         goto out;
1958                 STps->rw = ST_READING;
1959         }
1960         DEB(
1961         if (debugging && STps->eof != ST_NOEOF)
1962                 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
1963                        STps->eof, STbp->buffer_bytes);
1964         ) /* end DEB */
1965
1966         retval = setup_buffering(STp, buf, count, 1);
1967         if (retval)
1968                 goto out;
1969         do_dio = STbp->do_dio;
1970
1971         if (STbp->buffer_bytes == 0 &&
1972             STps->eof >= ST_EOD_1) {
1973                 if (STps->eof < ST_EOD) {
1974                         STps->eof += 1;
1975                         retval = 0;
1976                         goto out;
1977                 }
1978                 retval = (-EIO);        /* EOM or Blank Check */
1979                 goto out;
1980         }
1981
1982         if (do_dio) {
1983                 /* Check the buffer writability before any tape movement. Don't alter
1984                    buffer data. */
1985                 if (copy_from_user(&i, buf, 1) != 0 ||
1986                     copy_to_user(buf, &i, 1) != 0 ||
1987                     copy_from_user(&i, buf + count - 1, 1) != 0 ||
1988                     copy_to_user(buf + count - 1, &i, 1) != 0) {
1989                         retval = (-EFAULT);
1990                         goto out;
1991                 }
1992         }
1993
1994         STps->rw = ST_READING;
1995
1996
1997         /* Loop until enough data in buffer or a special condition found */
1998         for (total = 0, special = 0; total < count && !special;) {
1999
2000                 /* Get new data if the buffer is empty */
2001                 if (STbp->buffer_bytes == 0) {
2002                         special = read_tape(STp, count - total, &SRpnt);
2003                         if (special < 0) {      /* No need to continue read */
2004                                 retval = special;
2005                                 goto out;
2006                         }
2007                 }
2008
2009                 /* Move the data from driver buffer to user buffer */
2010                 if (STbp->buffer_bytes > 0) {
2011                         DEB(
2012                         if (debugging && STps->eof != ST_NOEOF)
2013                                 printk(ST_DEB_MSG
2014                                        "%s: EOF up (%d). Left %d, needed %d.\n", name,
2015                                        STps->eof, STbp->buffer_bytes,
2016                                        (int)(count - total));
2017                         ) /* end DEB */
2018                         transfer = STbp->buffer_bytes < count - total ?
2019                             STbp->buffer_bytes : count - total;
2020                         if (!do_dio) {
2021                                 i = from_buffer(STbp, buf, transfer);
2022                                 if (i) {
2023                                         retval = i;
2024                                         goto out;
2025                                 }
2026                         }
2027                         buf += transfer;
2028                         total += transfer;
2029                 }
2030
2031                 if (STp->block_size == 0)
2032                         break;  /* Read only one variable length block */
2033
2034         }                       /* for (total = 0, special = 0;
2035                                    total < count && !special; ) */
2036
2037         /* Change the eof state if no data from tape or buffer */
2038         if (total == 0) {
2039                 if (STps->eof == ST_FM_HIT) {
2040                         STps->eof = ST_FM;
2041                         STps->drv_block = 0;
2042                         if (STps->drv_file >= 0)
2043                                 STps->drv_file++;
2044                 } else if (STps->eof == ST_EOD_1) {
2045                         STps->eof = ST_EOD_2;
2046                         STps->drv_block = 0;
2047                         if (STps->drv_file >= 0)
2048                                 STps->drv_file++;
2049                 } else if (STps->eof == ST_EOD_2)
2050                         STps->eof = ST_EOD;
2051         } else if (STps->eof == ST_FM)
2052                 STps->eof = ST_NOEOF;
2053         retval = total;
2054
2055  out:
2056         if (SRpnt != NULL) {
2057                 scsi_release_request(SRpnt);
2058                 SRpnt = NULL;
2059         }
2060         if (do_dio) {
2061                 release_buffering(STp);
2062                 STbp->buffer_bytes = 0;
2063         }
2064         up(&STp->lock);
2065
2066         return retval;
2067 }
2068 \f
2069
2070
2071 DEB(
2072 /* Set the driver options */
2073 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2074 {
2075         if (debugging) {
2076                 printk(KERN_INFO
2077                        "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2078                        name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2079                        STm->do_read_ahead);
2080                 printk(KERN_INFO
2081                        "%s:    can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2082                        name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2083                 printk(KERN_INFO
2084                        "%s:    defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2085                        name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2086                        STp->scsi2_logical);
2087                 printk(KERN_INFO
2088                        "%s:    sysv: %d nowait: %d\n", name, STm->sysv, STp->immediate);
2089                 printk(KERN_INFO "%s:    debugging: %d\n",
2090                        name, debugging);
2091         }
2092 }
2093         )
2094
2095
2096 static int st_set_options(struct scsi_tape *STp, long options)
2097 {
2098         int value;
2099         long code;
2100         struct st_modedef *STm;
2101         char *name = tape_name(STp);
2102         struct cdev *cd0, *cd1;
2103
2104         STm = &(STp->modes[STp->current_mode]);
2105         if (!STm->defined) {
2106                 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2107                 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2108                 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2109                 modes_defined = 1;
2110                 DEBC(printk(ST_DEB_MSG
2111                             "%s: Initialized mode %d definition from mode 0\n",
2112                             name, STp->current_mode));
2113         }
2114
2115         code = options & MT_ST_OPTIONS;
2116         if (code == MT_ST_BOOLEANS) {
2117                 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2118                 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2119                 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2120                 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2121                 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2122                 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2123                 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2124                 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2125                 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2126                 if ((STp->device)->scsi_level >= SCSI_2)
2127                         STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2128                 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2129                 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2130                 STm->sysv = (options & MT_ST_SYSV) != 0;
2131                 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2132                      st_log_options(STp, STm, name); )
2133         } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2134                 value = (code == MT_ST_SETBOOLEANS);
2135                 if ((options & MT_ST_BUFFER_WRITES) != 0)
2136                         STm->do_buffer_writes = value;
2137                 if ((options & MT_ST_ASYNC_WRITES) != 0)
2138                         STm->do_async_writes = value;
2139                 if ((options & MT_ST_DEF_WRITES) != 0)
2140                         STm->defaults_for_writes = value;
2141                 if ((options & MT_ST_READ_AHEAD) != 0)
2142                         STm->do_read_ahead = value;
2143                 if ((options & MT_ST_TWO_FM) != 0)
2144                         STp->two_fm = value;
2145                 if ((options & MT_ST_FAST_MTEOM) != 0)
2146                         STp->fast_mteom = value;
2147                 if ((options & MT_ST_AUTO_LOCK) != 0)
2148                         STp->do_auto_lock = value;
2149                 if ((options & MT_ST_CAN_BSR) != 0)
2150                         STp->can_bsr = value;
2151                 if ((options & MT_ST_NO_BLKLIMS) != 0)
2152                         STp->omit_blklims = value;
2153                 if ((STp->device)->scsi_level >= SCSI_2 &&
2154                     (options & MT_ST_CAN_PARTITIONS) != 0)
2155                         STp->can_partitions = value;
2156                 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2157                         STp->scsi2_logical = value;
2158                 if ((options & MT_ST_NOWAIT) != 0)
2159                         STp->immediate = value;
2160                 if ((options & MT_ST_SYSV) != 0)
2161                         STm->sysv = value;
2162                 DEB(
2163                 if ((options & MT_ST_DEBUGGING) != 0)
2164                         debugging = value;
2165                         st_log_options(STp, STm, name); )
2166         } else if (code == MT_ST_WRITE_THRESHOLD) {
2167                 /* Retained for compatibility */
2168         } else if (code == MT_ST_DEF_BLKSIZE) {
2169                 value = (options & ~MT_ST_OPTIONS);
2170                 if (value == ~MT_ST_OPTIONS) {
2171                         STm->default_blksize = (-1);
2172                         DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2173                 } else {
2174                         STm->default_blksize = value;
2175                         DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2176                                name, STm->default_blksize));
2177                         if (STp->ready == ST_READY) {
2178                                 STp->blksize_changed = 0;
2179                                 set_mode_densblk(STp, STm);
2180                         }
2181                 }
2182         } else if (code == MT_ST_TIMEOUTS) {
2183                 value = (options & ~MT_ST_OPTIONS);
2184                 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2185                         STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2186                         DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2187                                (value & ~MT_ST_SET_LONG_TIMEOUT)));
2188                 } else {
2189                         STp->device->timeout = value * HZ;
2190                         DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2191                                 name, value) );
2192                 }
2193         } else if (code == MT_ST_SET_CLN) {
2194                 value = (options & ~MT_ST_OPTIONS) & 0xff;
2195                 if (value != 0 &&
2196                     value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2197                         return (-EINVAL);
2198                 STp->cln_mode = value;
2199                 STp->cln_sense_mask = (options >> 8) & 0xff;
2200                 STp->cln_sense_value = (options >> 16) & 0xff;
2201                 printk(KERN_INFO
2202                        "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2203                        name, value, STp->cln_sense_mask, STp->cln_sense_value);
2204         } else if (code == MT_ST_DEF_OPTIONS) {
2205                 code = (options & ~MT_ST_CLEAR_DEFAULT);
2206                 value = (options & MT_ST_CLEAR_DEFAULT);
2207                 if (code == MT_ST_DEF_DENSITY) {
2208                         if (value == MT_ST_CLEAR_DEFAULT) {
2209                                 STm->default_density = (-1);
2210                                 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2211                                        name));
2212                         } else {
2213                                 STm->default_density = value & 0xff;
2214                                 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2215                                        name, STm->default_density));
2216                                 if (STp->ready == ST_READY) {
2217                                         STp->density_changed = 0;
2218                                         set_mode_densblk(STp, STm);
2219                                 }
2220                         }
2221                 } else if (code == MT_ST_DEF_DRVBUFFER) {
2222                         if (value == MT_ST_CLEAR_DEFAULT) {
2223                                 STp->default_drvbuffer = 0xff;
2224                                 DEBC( printk(KERN_INFO
2225                                        "%s: Drive buffer default disabled.\n", name));
2226                         } else {
2227                                 STp->default_drvbuffer = value & 7;
2228                                 DEBC( printk(KERN_INFO
2229                                        "%s: Drive buffer default set to %x\n",
2230                                        name, STp->default_drvbuffer));
2231                                 if (STp->ready == ST_READY)
2232                                         st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2233                         }
2234                 } else if (code == MT_ST_DEF_COMPRESSION) {
2235                         if (value == MT_ST_CLEAR_DEFAULT) {
2236                                 STm->default_compression = ST_DONT_TOUCH;
2237                                 DEBC( printk(KERN_INFO
2238                                        "%s: Compression default disabled.\n", name));
2239                         } else {
2240                                 if ((value & 0xff00) != 0) {
2241                                         STp->c_algo = (value & 0xff00) >> 8;
2242                                         DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2243                                                name, STp->c_algo));
2244                                 }
2245                                 if ((value & 0xff) != 0xff) {
2246                                         STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2247                                         DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2248                                                name, (value & 1)));
2249                                         if (STp->ready == ST_READY) {
2250                                                 STp->compression_changed = 0;
2251                                                 st_compression(STp, (STm->default_compression == ST_YES));
2252                                         }
2253                                 }
2254                         }
2255                 }
2256         } else
2257                 return (-EIO);
2258
2259         return 0;
2260 }
2261 \f
2262 #define MODE_HEADER_LENGTH  4
2263
2264 /* Mode header and page byte offsets */
2265 #define MH_OFF_DATA_LENGTH     0
2266 #define MH_OFF_MEDIUM_TYPE     1
2267 #define MH_OFF_DEV_SPECIFIC    2
2268 #define MH_OFF_BDESCS_LENGTH   3
2269 #define MP_OFF_PAGE_NBR        0
2270 #define MP_OFF_PAGE_LENGTH     1
2271
2272 /* Mode header and page bit masks */
2273 #define MH_BIT_WP              0x80
2274 #define MP_MSK_PAGE_NBR        0x3f
2275
2276 /* Don't return block descriptors */
2277 #define MODE_SENSE_OMIT_BDESCS 0x08
2278
2279 #define MODE_SELECT_PAGE_FORMAT 0x10
2280
2281 /* Read a mode page into the tape buffer. The block descriptors are included
2282    if incl_block_descs is true. The page control is ored to the page number
2283    parameter, if necessary. */
2284 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2285 {
2286         unsigned char cmd[MAX_COMMAND_SIZE];
2287         struct scsi_request *SRpnt = NULL;
2288
2289         memset(cmd, 0, MAX_COMMAND_SIZE);
2290         cmd[0] = MODE_SENSE;
2291         if (omit_block_descs)
2292                 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2293         cmd[2] = page;
2294         cmd[4] = 255;
2295
2296         SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2297                            STp->device->timeout, 0, 1);
2298         if (SRpnt == NULL)
2299                 return (STp->buffer)->syscall_result;
2300
2301         scsi_release_request(SRpnt);
2302
2303         return (STp->buffer)->syscall_result;
2304 }
2305
2306
2307 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2308    in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2309 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2310 {
2311         int pgo;
2312         unsigned char cmd[MAX_COMMAND_SIZE];
2313         struct scsi_request *SRpnt = NULL;
2314
2315         memset(cmd, 0, MAX_COMMAND_SIZE);
2316         cmd[0] = MODE_SELECT;
2317         cmd[1] = MODE_SELECT_PAGE_FORMAT;
2318         pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2319         cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2320
2321         /* Clear reserved fields */
2322         (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2323         (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2324         (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2325         (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2326
2327         SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE,
2328                            (slow ? STp->long_timeout : STp->device->timeout), 0, 1);
2329         if (SRpnt == NULL)
2330                 return (STp->buffer)->syscall_result;
2331
2332         scsi_release_request(SRpnt);
2333
2334         return (STp->buffer)->syscall_result;
2335 }
2336
2337
2338 #define COMPRESSION_PAGE        0x0f
2339 #define COMPRESSION_PAGE_LENGTH 16
2340
2341 #define CP_OFF_DCE_DCC          2
2342 #define CP_OFF_C_ALGO           7
2343
2344 #define DCE_MASK  0x80
2345 #define DCC_MASK  0x40
2346 #define RED_MASK  0x60
2347
2348
2349 /* Control the compression with mode page 15. Algorithm not changed if zero.
2350
2351    The block descriptors are read and written because Sony SDT-7000 does not
2352    work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2353    Including block descriptors should not cause any harm to other drives. */
2354
2355 static int st_compression(struct scsi_tape * STp, int state)
2356 {
2357         int retval;
2358         int mpoffs;  /* Offset to mode page start */
2359         unsigned char *b_data = (STp->buffer)->b_data;
2360         DEB( char *name = tape_name(STp); )
2361
2362         if (STp->ready != ST_READY)
2363                 return (-EIO);
2364
2365         /* Read the current page contents */
2366         retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2367         if (retval) {
2368                 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2369                             name));
2370                 return (-EIO);
2371         }
2372
2373         mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2374         DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2375                     (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2376
2377         /* Check if compression can be changed */
2378         if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2379                 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2380                 return (-EIO);
2381         }
2382
2383         /* Do the change */
2384         if (state) {
2385                 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2386                 if (STp->c_algo != 0)
2387                         b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2388         }
2389         else {
2390                 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2391                 if (STp->c_algo != 0)
2392                         b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2393         }
2394
2395         retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2396         if (retval) {
2397                 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2398                 return (-EIO);
2399         }
2400         DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2401                        name, state));
2402
2403         STp->compression_changed = 1;
2404         return 0;
2405 }
2406
2407
2408 /* Process the load and unload commands (does unload if the load code is zero) */
2409 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2410 {
2411         int retval = (-EIO), timeout;
2412         DEB( char *name = tape_name(STp); )
2413         unsigned char cmd[MAX_COMMAND_SIZE];
2414         struct st_partstat *STps;
2415         struct scsi_request *SRpnt;
2416
2417         if (STp->ready != ST_READY && !load_code) {
2418                 if (STp->ready == ST_NO_TAPE)
2419                         return (-ENOMEDIUM);
2420                 else
2421                         return (-EIO);
2422         }
2423
2424         memset(cmd, 0, MAX_COMMAND_SIZE);
2425         cmd[0] = START_STOP;
2426         if (load_code)
2427                 cmd[4] |= 1;
2428         /*
2429          * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2430          */
2431         if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2432             && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2433                 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2434                             name, (cmd[4]) ? "" : "un",
2435                             load_code - MT_ST_HPLOADER_OFFSET));
2436                 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2437         }
2438         if (STp->immediate) {
2439                 cmd[1] = 1;     /* Don't wait for completion */
2440                 timeout = STp->device->timeout;
2441         }
2442         else
2443                 timeout = STp->long_timeout;
2444
2445         DEBC(
2446                 if (!load_code)
2447                 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2448                 else
2449                 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2450                 );
2451
2452         SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2453                            timeout, MAX_RETRIES, 1);
2454         if (!SRpnt)
2455                 return (STp->buffer)->syscall_result;
2456
2457         retval = (STp->buffer)->syscall_result;
2458         scsi_release_request(SRpnt);
2459
2460         if (!retval) {  /* SCSI command successful */
2461
2462                 if (!load_code) {
2463                         STp->rew_at_close = 0;
2464                         STp->ready = ST_NO_TAPE;
2465                 }
2466                 else {
2467                         STp->rew_at_close = STp->autorew_dev;
2468                         retval = check_tape(STp, filp);
2469                         if (retval > 0)
2470                                 retval = 0;
2471                 }
2472         }
2473         else {
2474                 STps = &(STp->ps[STp->partition]);
2475                 STps->drv_file = STps->drv_block = (-1);
2476         }
2477
2478         return retval;
2479 }
2480 \f
2481 #if DEBUG
2482 #define ST_DEB_FORWARD  0
2483 #define ST_DEB_BACKWARD 1
2484 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2485 {
2486         s32 sc;
2487
2488         sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2489         sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2490         if (direction)
2491                 sc = -sc;
2492         printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2493                direction ? "backward" : "forward", sc, units);
2494 }
2495 #endif
2496
2497
2498 /* Internal ioctl function */
2499 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2500 {
2501         int timeout;
2502         long ltmp;
2503         int ioctl_result;
2504         int chg_eof = 1;
2505         unsigned char cmd[MAX_COMMAND_SIZE];
2506         struct scsi_request *SRpnt;
2507         struct st_partstat *STps;
2508         int fileno, blkno, at_sm, undone;
2509         int datalen = 0, direction = DMA_NONE;
2510         char *name = tape_name(STp);
2511
2512         WARN_ON(STp->buffer->do_dio != 0);
2513         if (STp->ready != ST_READY) {
2514                 if (STp->ready == ST_NO_TAPE)
2515                         return (-ENOMEDIUM);
2516                 else
2517                         return (-EIO);
2518         }
2519         timeout = STp->long_timeout;
2520         STps = &(STp->ps[STp->partition]);
2521         fileno = STps->drv_file;
2522         blkno = STps->drv_block;
2523         at_sm = STps->at_sm;
2524
2525         memset(cmd, 0, MAX_COMMAND_SIZE);
2526         switch (cmd_in) {
2527         case MTFSFM:
2528                 chg_eof = 0;    /* Changed from the FSF after this */
2529         case MTFSF:
2530                 cmd[0] = SPACE;
2531                 cmd[1] = 0x01;  /* Space FileMarks */
2532                 cmd[2] = (arg >> 16);
2533                 cmd[3] = (arg >> 8);
2534                 cmd[4] = arg;
2535                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2536                 if (fileno >= 0)
2537                         fileno += arg;
2538                 blkno = 0;
2539                 at_sm &= (arg == 0);
2540                 break;
2541         case MTBSFM:
2542                 chg_eof = 0;    /* Changed from the FSF after this */
2543         case MTBSF:
2544                 cmd[0] = SPACE;
2545                 cmd[1] = 0x01;  /* Space FileMarks */
2546                 ltmp = (-arg);
2547                 cmd[2] = (ltmp >> 16);
2548                 cmd[3] = (ltmp >> 8);
2549                 cmd[4] = ltmp;
2550                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2551                 if (fileno >= 0)
2552                         fileno -= arg;
2553                 blkno = (-1);   /* We can't know the block number */
2554                 at_sm &= (arg == 0);
2555                 break;
2556         case MTFSR:
2557                 cmd[0] = SPACE;
2558                 cmd[1] = 0x00;  /* Space Blocks */
2559                 cmd[2] = (arg >> 16);
2560                 cmd[3] = (arg >> 8);
2561                 cmd[4] = arg;
2562                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2563                 if (blkno >= 0)
2564                         blkno += arg;
2565                 at_sm &= (arg == 0);
2566                 break;
2567         case MTBSR:
2568                 cmd[0] = SPACE;
2569                 cmd[1] = 0x00;  /* Space Blocks */
2570                 ltmp = (-arg);
2571                 cmd[2] = (ltmp >> 16);
2572                 cmd[3] = (ltmp >> 8);
2573                 cmd[4] = ltmp;
2574                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2575                 if (blkno >= 0)
2576                         blkno -= arg;
2577                 at_sm &= (arg == 0);
2578                 break;
2579         case MTFSS:
2580                 cmd[0] = SPACE;
2581                 cmd[1] = 0x04;  /* Space Setmarks */
2582                 cmd[2] = (arg >> 16);
2583                 cmd[3] = (arg >> 8);
2584                 cmd[4] = arg;
2585                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2586                 if (arg != 0) {
2587                         blkno = fileno = (-1);
2588                         at_sm = 1;
2589                 }
2590                 break;
2591         case MTBSS:
2592                 cmd[0] = SPACE;
2593                 cmd[1] = 0x04;  /* Space Setmarks */
2594                 ltmp = (-arg);
2595                 cmd[2] = (ltmp >> 16);
2596                 cmd[3] = (ltmp >> 8);
2597                 cmd[4] = ltmp;
2598                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2599                 if (arg != 0) {
2600                         blkno = fileno = (-1);
2601                         at_sm = 1;
2602                 }
2603                 break;
2604         case MTWEOF:
2605         case MTWSM:
2606                 if (STp->write_prot)
2607                         return (-EACCES);
2608                 cmd[0] = WRITE_FILEMARKS;
2609                 if (cmd_in == MTWSM)
2610                         cmd[1] = 2;
2611                 cmd[2] = (arg >> 16);
2612                 cmd[3] = (arg >> 8);
2613                 cmd[4] = arg;
2614                 timeout = STp->device->timeout;
2615                 DEBC(
2616                      if (cmd_in == MTWEOF)
2617                                printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2618                                  cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2619                      else
2620                                 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2621                                  cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2622                 )
2623                 if (fileno >= 0)
2624                         fileno += arg;
2625                 blkno = 0;
2626                 at_sm = (cmd_in == MTWSM);
2627                 break;
2628         case MTREW:
2629                 cmd[0] = REZERO_UNIT;
2630                 if (STp->immediate) {
2631                         cmd[1] = 1;     /* Don't wait for completion */
2632                         timeout = STp->device->timeout;
2633                 }
2634                 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2635                 fileno = blkno = at_sm = 0;
2636                 break;
2637         case MTNOP:
2638                 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2639                 return 0;       /* Should do something ? */
2640                 break;
2641         case MTRETEN:
2642                 cmd[0] = START_STOP;
2643                 if (STp->immediate) {
2644                         cmd[1] = 1;     /* Don't wait for completion */
2645                         timeout = STp->device->timeout;
2646                 }
2647                 cmd[4] = 3;
2648                 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2649                 fileno = blkno = at_sm = 0;
2650                 break;
2651         case MTEOM:
2652                 if (!STp->fast_mteom) {
2653                         /* space to the end of tape */
2654                         ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2655                         fileno = STps->drv_file;
2656                         if (STps->eof >= ST_EOD_1)
2657                                 return 0;
2658                         /* The next lines would hide the number of spaced FileMarks
2659                            That's why I inserted the previous lines. I had no luck
2660                            with detecting EOM with FSF, so we go now to EOM.
2661                            Joerg Weule */
2662                 } else
2663                         fileno = (-1);
2664                 cmd[0] = SPACE;
2665                 cmd[1] = 3;
2666                 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2667                             name));
2668                 blkno = -1;
2669                 at_sm = 0;
2670                 break;
2671         case MTERASE:
2672                 if (STp->write_prot)
2673                         return (-EACCES);
2674                 cmd[0] = ERASE;
2675                 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2676                 if (STp->immediate) {
2677                         cmd[1] |= 2;    /* Don't wait for completion */
2678                         timeout = STp->device->timeout;
2679                 }
2680                 else
2681                         timeout = STp->long_timeout * 8;
2682
2683                 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2684                 fileno = blkno = at_sm = 0;
2685                 break;
2686         case MTSETBLK:          /* Set block length */
2687         case MTSETDENSITY:      /* Set tape density */
2688         case MTSETDRVBUFFER:    /* Set drive buffering */
2689         case SET_DENS_AND_BLK:  /* Set density and block size */
2690                 chg_eof = 0;
2691                 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2692                         return (-EIO);  /* Not allowed if data in buffer */
2693                 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2694                     (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2695                     STp->max_block > 0 &&
2696                     ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2697                      (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2698                         printk(KERN_WARNING "%s: Illegal block size.\n", name);
2699                         return (-EINVAL);
2700                 }
2701                 cmd[0] = MODE_SELECT;
2702                 if ((STp->use_pf & USE_PF))
2703                         cmd[1] = MODE_SELECT_PAGE_FORMAT;
2704                 cmd[4] = datalen = 12;
2705                 direction = DMA_TO_DEVICE;
2706
2707                 memset((STp->buffer)->b_data, 0, 12);
2708                 if (cmd_in == MTSETDRVBUFFER)
2709                         (STp->buffer)->b_data[2] = (arg & 7) << 4;
2710                 else
2711                         (STp->buffer)->b_data[2] =
2712                             STp->drv_buffer << 4;
2713                 (STp->buffer)->b_data[3] = 8;   /* block descriptor length */
2714                 if (cmd_in == MTSETDENSITY) {
2715                         (STp->buffer)->b_data[4] = arg;
2716                         STp->density_changed = 1;       /* At least we tried ;-) */
2717                 } else if (cmd_in == SET_DENS_AND_BLK)
2718                         (STp->buffer)->b_data[4] = arg >> 24;
2719                 else
2720                         (STp->buffer)->b_data[4] = STp->density;
2721                 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2722                         ltmp = arg & MT_ST_BLKSIZE_MASK;
2723                         if (cmd_in == MTSETBLK)
2724                                 STp->blksize_changed = 1; /* At least we tried ;-) */
2725                 } else
2726                         ltmp = STp->block_size;
2727                 (STp->buffer)->b_data[9] = (ltmp >> 16);
2728                 (STp->buffer)->b_data[10] = (ltmp >> 8);
2729                 (STp->buffer)->b_data[11] = ltmp;
2730                 timeout = STp->device->timeout;
2731                 DEBC(
2732                         if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2733                                 printk(ST_DEB_MSG
2734                                        "%s: Setting block size to %d bytes.\n", name,
2735                                        (STp->buffer)->b_data[9] * 65536 +
2736                                        (STp->buffer)->b_data[10] * 256 +
2737                                        (STp->buffer)->b_data[11]);
2738                         if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2739                                 printk(ST_DEB_MSG
2740                                        "%s: Setting density code to %x.\n", name,
2741                                        (STp->buffer)->b_data[4]);
2742                         if (cmd_in == MTSETDRVBUFFER)
2743                                 printk(ST_DEB_MSG
2744                                        "%s: Setting drive buffer code to %d.\n", name,
2745                                     ((STp->buffer)->b_data[2] >> 4) & 7);
2746                 )
2747                 break;
2748         default:
2749                 return (-ENOSYS);
2750         }
2751
2752         SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2753                            timeout, MAX_RETRIES, 1);
2754         if (!SRpnt)
2755                 return (STp->buffer)->syscall_result;
2756
2757         ioctl_result = (STp->buffer)->syscall_result;
2758
2759         if (!ioctl_result) {    /* SCSI command successful */
2760                 scsi_release_request(SRpnt);
2761                 SRpnt = NULL;
2762                 STps->drv_block = blkno;
2763                 STps->drv_file = fileno;
2764                 STps->at_sm = at_sm;
2765
2766                 if (cmd_in == MTBSFM)
2767                         ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2768                 else if (cmd_in == MTFSFM)
2769                         ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2770
2771                 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2772                         int old_block_size = STp->block_size;
2773                         STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2774                         if (STp->block_size != 0) {
2775                                 if (old_block_size == 0)
2776                                         normalize_buffer(STp->buffer);
2777                                 (STp->buffer)->buffer_blocks =
2778                                     (STp->buffer)->buffer_size / STp->block_size;
2779                         }
2780                         (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2781                         if (cmd_in == SET_DENS_AND_BLK)
2782                                 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2783                 } else if (cmd_in == MTSETDRVBUFFER)
2784                         STp->drv_buffer = (arg & 7);
2785                 else if (cmd_in == MTSETDENSITY)
2786                         STp->density = arg;
2787
2788                 if (cmd_in == MTEOM)
2789                         STps->eof = ST_EOD;
2790                 else if (cmd_in == MTFSF)
2791                         STps->eof = ST_FM;
2792                 else if (chg_eof)
2793                         STps->eof = ST_NOEOF;
2794
2795                 if (cmd_in == MTWEOF)
2796                         STps->rw = ST_IDLE;
2797         } else { /* SCSI command was not completely successful. Don't return
2798                     from this block without releasing the SCSI command block! */
2799                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2800
2801                 if (cmdstatp->flags & SENSE_EOM) {
2802                         if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2803                             cmd_in != MTBSR && cmd_in != MTBSS)
2804                                 STps->eof = ST_EOM_OK;
2805                         STps->drv_block = 0;
2806                 }
2807
2808                 if (cmdstatp->remainder_valid)
2809                         undone = (int)cmdstatp->uremainder64;
2810                 else
2811                         undone = 0;
2812
2813                 if (cmd_in == MTWEOF &&
2814                     cmdstatp->have_sense &&
2815                     (cmdstatp->flags & SENSE_EOM) &&
2816                     (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2817                      cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
2818                     undone == 0) {
2819                         ioctl_result = 0;       /* EOF written succesfully at EOM */
2820                         if (fileno >= 0)
2821                                 fileno++;
2822                         STps->drv_file = fileno;
2823                         STps->eof = ST_NOEOF;
2824                 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2825                         if (fileno >= 0)
2826                                 STps->drv_file = fileno - undone;
2827                         else
2828                                 STps->drv_file = fileno;
2829                         STps->drv_block = -1;
2830                         STps->eof = ST_NOEOF;
2831                 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2832                         if (arg > 0 && undone < 0)  /* Some drives get this wrong */
2833                                 undone = (-undone);
2834                         if (STps->drv_file >= 0)
2835                                 STps->drv_file = fileno + undone;
2836                         STps->drv_block = 0;
2837                         STps->eof = ST_NOEOF;
2838                 } else if (cmd_in == MTFSR) {
2839                         if (cmdstatp->flags & SENSE_FMK) {      /* Hit filemark */
2840                                 if (STps->drv_file >= 0)
2841                                         STps->drv_file++;
2842                                 STps->drv_block = 0;
2843                                 STps->eof = ST_FM;
2844                         } else {
2845                                 if (blkno >= undone)
2846                                         STps->drv_block = blkno - undone;
2847                                 else
2848                                         STps->drv_block = (-1);
2849                                 STps->eof = ST_NOEOF;
2850                         }
2851                 } else if (cmd_in == MTBSR) {
2852                         if (cmdstatp->flags & SENSE_FMK) {      /* Hit filemark */
2853                                 STps->drv_file--;
2854                                 STps->drv_block = (-1);
2855                         } else {
2856                                 if (arg > 0 && undone < 0)  /* Some drives get this wrong */
2857                                         undone = (-undone);
2858                                 if (STps->drv_block >= 0)
2859                                         STps->drv_block = blkno + undone;
2860                         }
2861                         STps->eof = ST_NOEOF;
2862                 } else if (cmd_in == MTEOM) {
2863                         STps->drv_file = (-1);
2864                         STps->drv_block = (-1);
2865                         STps->eof = ST_EOD;
2866                 } else if (cmd_in == MTSETBLK ||
2867                            cmd_in == MTSETDENSITY ||
2868                            cmd_in == MTSETDRVBUFFER ||
2869                            cmd_in == SET_DENS_AND_BLK) {
2870                         if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2871                             !(STp->use_pf & PF_TESTED)) {
2872                                 /* Try the other possible state of Page Format if not
2873                                    already tried */
2874                                 STp->use_pf = !STp->use_pf | PF_TESTED;
2875                                 scsi_release_request(SRpnt);
2876                                 SRpnt = NULL;
2877                                 return st_int_ioctl(STp, cmd_in, arg);
2878                         }
2879                 } else if (chg_eof)
2880                         STps->eof = ST_NOEOF;
2881
2882                 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2883                         STps->eof = ST_EOD;
2884
2885                 scsi_release_request(SRpnt);
2886                 SRpnt = NULL;
2887         }
2888
2889         return ioctl_result;
2890 }
2891 \f
2892
2893 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2894    structure. */
2895
2896 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2897                         int logical)
2898 {
2899         int result;
2900         unsigned char scmd[MAX_COMMAND_SIZE];
2901         struct scsi_request *SRpnt;
2902         DEB( char *name = tape_name(STp); )
2903
2904         if (STp->ready != ST_READY)
2905                 return (-EIO);
2906
2907         memset(scmd, 0, MAX_COMMAND_SIZE);
2908         if ((STp->device)->scsi_level < SCSI_2) {
2909                 scmd[0] = QFA_REQUEST_BLOCK;
2910                 scmd[4] = 3;
2911         } else {
2912                 scmd[0] = READ_POSITION;
2913                 if (!logical && !STp->scsi2_logical)
2914                         scmd[1] = 1;
2915         }
2916         SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
2917                         STp->device->timeout, MAX_READY_RETRIES, 1);
2918         if (!SRpnt)
2919                 return (STp->buffer)->syscall_result;
2920
2921         if ((STp->buffer)->syscall_result != 0 ||
2922             (STp->device->scsi_level >= SCSI_2 &&
2923              ((STp->buffer)->b_data[0] & 4) != 0)) {
2924                 *block = *partition = 0;
2925                 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
2926                 result = (-EIO);
2927         } else {
2928                 result = 0;
2929                 if ((STp->device)->scsi_level < SCSI_2) {
2930                         *block = ((STp->buffer)->b_data[0] << 16)
2931                             + ((STp->buffer)->b_data[1] << 8)
2932                             + (STp->buffer)->b_data[2];
2933                         *partition = 0;
2934                 } else {
2935                         *block = ((STp->buffer)->b_data[4] << 24)
2936                             + ((STp->buffer)->b_data[5] << 16)
2937                             + ((STp->buffer)->b_data[6] << 8)
2938                             + (STp->buffer)->b_data[7];
2939                         *partition = (STp->buffer)->b_data[1];
2940                         if (((STp->buffer)->b_data[0] & 0x80) &&
2941                             (STp->buffer)->b_data[1] == 0)      /* BOP of partition 0 */
2942                                 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
2943                 }
2944                 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
2945                             *block, *partition));
2946         }
2947         scsi_release_request(SRpnt);
2948         SRpnt = NULL;
2949
2950         return result;
2951 }
2952
2953
2954 /* Set the tape block and partition. Negative partition means that only the
2955    block should be set in vendor specific way. */
2956 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
2957                         int logical)
2958 {
2959         struct st_partstat *STps;
2960         int result, p;
2961         unsigned int blk;
2962         int timeout;
2963         unsigned char scmd[MAX_COMMAND_SIZE];
2964         struct scsi_request *SRpnt;
2965         DEB( char *name = tape_name(STp); )
2966
2967         if (STp->ready != ST_READY)
2968                 return (-EIO);
2969         timeout = STp->long_timeout;
2970         STps = &(STp->ps[STp->partition]);
2971
2972         DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
2973                     name, block, partition));
2974         DEB(if (partition < 0)
2975                 return (-EIO); )
2976
2977         /* Update the location at the partition we are leaving */
2978         if ((!STp->can_partitions && partition != 0) ||
2979             partition >= ST_NBR_PARTITIONS)
2980                 return (-EINVAL);
2981         if (partition != STp->partition) {
2982                 if (get_location(STp, &blk, &p, 1))
2983                         STps->last_block_valid = 0;
2984                 else {
2985                         STps->last_block_valid = 1;
2986                         STps->last_block_visited = blk;
2987                         DEBC(printk(ST_DEB_MSG
2988               &n