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