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