2 SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
3 file Documentation/scsi/st.txt for more information.
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.
12 Copyright 1992 - 2008 Kai Makisara
13 email Kai.Makisara@kolumbus.fi
15 Some small formal changes - aeb, 950809
17 Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
20 static const char *verstr = "20080504";
22 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/sched.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>
43 #include <asm/uaccess.h>
45 #include <asm/system.h>
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>
57 /* The driver prints some debugging information on the console if DEBUG
58 is defined and non-zero. */
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
67 #define DEBC(a) if (debugging) { a ; }
73 #define ST_KILOBYTE 1024
75 #include "st_options.h"
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;
84 static int st_dev_max;
87 static struct class *st_sysfs_class;
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);
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.
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)");
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");
113 static int write_threshold_kbs; /* retained for compatibility */
114 static struct st_dev_parm {
117 } parms[] __initdata = {
119 "buffer_kbs", &buffer_kbs
121 { /* Retained for compatibility with 2.4 */
122 "write_threshold_kbs", &write_threshold_kbs
128 "try_direct_io", &try_direct_io
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"
137 /* Bit reversed order to get same names for same minors with all
139 static const char *st_formats[] = {
140 "", "r", "k", "s", "l", "t", "o", "u",
141 "m", "v", "p", "x", "a", "y", "q", "z"};
143 /* The default definitions have been moved to st_options.h */
145 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
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!"
153 static int debugging = DEBUG;
155 #define MAX_RETRIES 0
156 #define MAX_WRITE_RETRIES 0
157 #define MAX_READY_RETRIES 0
158 #define NO_TAPE NOT_READY
160 #define ST_TIMEOUT (900 * HZ)
161 #define ST_LONG_TIMEOUT (14000 * HZ)
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)
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) )
172 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
174 #define SET_DENS_AND_BLK 0x10001
176 static DEFINE_RWLOCK(st_dev_arr_lock);
178 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
179 static int st_max_sg_segs = ST_MAX_SG;
181 static struct scsi_tape **scsi_tapes = NULL;
183 static int modes_defined;
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);
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);
198 static int st_probe(struct device *);
199 static int st_remove(struct device *);
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);
205 static struct scsi_driver st_template = {
206 .owner = THIS_MODULE,
214 static int st_compression(struct scsi_tape *, int);
216 static int find_partition(struct scsi_tape *);
217 static int switch_partition(struct scsi_tape *);
219 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
221 static void scsi_tape_release(struct kref *);
223 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
225 static DEFINE_MUTEX(st_ref_mutex);
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"}
238 static struct scsi_tape *scsi_tape_get(int dev)
240 struct scsi_tape *STp = NULL;
242 mutex_lock(&st_ref_mutex);
243 write_lock(&st_dev_arr_lock);
245 if (dev < st_dev_max && scsi_tapes != NULL)
246 STp = scsi_tapes[dev];
249 kref_get(&STp->kref);
254 if (scsi_device_get(STp->device))
260 kref_put(&STp->kref, scsi_tape_release);
263 write_unlock(&st_dev_arr_lock);
264 mutex_unlock(&st_ref_mutex);
268 static void scsi_tape_put(struct scsi_tape *STp)
270 struct scsi_device *sdev = STp->device;
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);
278 struct st_reject_data {
282 char *driver_hint; /* Name of the correct driver, NULL if unknown */
285 static struct st_reject_data reject_list[] = {
286 /* {"XXX", "Yy-", "", NULL}, example */
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)
294 struct st_reject_data *rp;
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))) {
301 return rp->driver_hint;
309 static inline char *tape_name(struct scsi_tape *tape)
311 return tape->disk->disk_name;
315 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
318 const u8 *sense = SRpnt->sense;
320 s->have_sense = scsi_normalize_sense(SRpnt->sense,
321 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
327 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
328 switch (sense[0] & 0x7f) {
333 s->flags = sense[2] & 0xe0;
339 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
340 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
347 /* Convert the result to success code */
348 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
350 int result = SRpnt->result;
352 DEB(const char *stp;)
353 char *name = tape_name(STp);
354 struct st_cmdstatus *cmdstatp;
359 cmdstatp = &STp->buffer->cmdstat;
360 st_analyze_sense(SRpnt, cmdstatp);
362 if (cmdstatp->have_sense)
363 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
369 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
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);
376 if (!debugging) { /* Abnormal conditions for tape */
377 if (!cmdstatp->have_sense)
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 &&
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) {
391 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
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);
401 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
402 STp->cln_sense_mask) != 0);
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 */
408 STp->pos_unknown |= STp->device->was_reset;
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
417 STp->recover_count++;
422 if (SRpnt->cmd[0] == READ_6)
424 else if (SRpnt->cmd[0] == WRITE_6)
428 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
432 if (cmdstatp->flags == 0)
439 /* Wakeup from interrupt */
440 static void st_sleep_done(void *data, char *sense, int result, int resid)
442 struct st_request *SRpnt = data;
443 struct scsi_tape *STp = SRpnt->stp;
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; )
451 complete(SRpnt->waiting);
454 static struct st_request *st_allocate_request(void)
456 return kzalloc(sizeof(struct st_request), GFP_KERNEL);
459 static void st_release_request(struct st_request *streq)
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
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)
471 struct completion *waiting;
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",
477 if (signal_pending(current))
478 (STp->buffer)->syscall_result = (-EINTR);
480 (STp->buffer)->syscall_result = (-EBUSY);
485 SRpnt = st_allocate_request();
487 DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n",
489 if (signal_pending(current))
490 (STp->buffer)->syscall_result = (-EINTR);
492 (STp->buffer)->syscall_result = (-EBUSY);
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. */
501 (STp->buffer)->last_SRpnt = SRpnt;
503 waiting = &STp->wait;
504 init_completion(waiting);
505 SRpnt->waiting = waiting;
507 if (!STp->buffer->do_dio)
508 buf_to_sg(STp->buffer, bytes);
510 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
511 STp->buffer->cmdstat.have_sense = 0;
512 STp->buffer->syscall_result = 0;
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;
522 wait_for_completion(waiting);
523 SRpnt->waiting = NULL;
524 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
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)
538 struct st_buffer *STbuffer;
539 struct st_partstat *STps;
540 struct st_cmdstatus *cmdstatp;
541 struct st_request *SRpnt;
543 STbuffer = STp->buffer;
544 if (!STbuffer->writing)
548 if (STp->write_pending)
554 wait_for_completion(&(STp->wait));
555 SRpnt = STbuffer->last_SRpnt;
556 STbuffer->last_SRpnt = NULL;
557 SRpnt->waiting = NULL;
559 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
560 st_release_request(SRpnt);
562 STbuffer->buffer_bytes -= STbuffer->writing;
563 STps = &(STp->ps[STp->partition]);
564 if (STps->drv_block >= 0) {
565 if (STp->block_size == 0)
568 STps->drv_block += STbuffer->writing / STp->block_size;
571 cmdstatp = &STbuffer->cmdstat;
572 if (STbuffer->syscall_result) {
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)
584 STps->drv_block = -1;
586 STbuffer->writing = 0;
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 */
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)
600 struct st_request *SRpnt;
601 unsigned char cmd[MAX_COMMAND_SIZE];
604 cmd[1] = 0x01; /* Space FileMarks */
609 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
612 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
613 tape_name(STp), forward ? "forward" : "backward"));
615 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
616 STp->device->timeout, MAX_RETRIES, 1);
618 return (STp->buffer)->syscall_result;
620 st_release_request(SRpnt);
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");
627 return (STp->buffer)->syscall_result;
631 /* Flush the write buffer (never need to write if variable blocksize). */
632 static int st_flush_write_buffer(struct scsi_tape * STp)
634 int offset, transfer, blks;
636 unsigned char cmd[MAX_COMMAND_SIZE];
637 struct st_request *SRpnt;
638 struct st_partstat *STps;
640 result = write_behind_check(STp);
645 if (STp->dirty == 1) {
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));
653 memset((STp->buffer)->b_data + offset, 0, transfer - offset);
655 memset(cmd, 0, MAX_COMMAND_SIZE);
658 blks = transfer / STp->block_size;
663 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
664 STp->device->timeout, MAX_WRITE_RETRIES, 1);
666 return (STp->buffer)->syscall_result;
668 STps = &(STp->ps[STp->partition]);
669 if ((STp->buffer)->syscall_result != 0) {
670 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
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 */
679 (STp->buffer)->buffer_bytes = 0;
680 if (STps->drv_block >= 0)
681 STps->drv_block += blks;
684 printk(KERN_ERR "%s: Error on flush.\n",
686 STps->drv_block = (-1);
690 if (STps->drv_block >= 0)
691 STps->drv_block += blks;
693 (STp->buffer)->buffer_bytes = 0;
695 st_release_request(SRpnt);
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)
706 int backspace, result;
707 struct st_buffer *STbuffer;
708 struct st_partstat *STps;
710 STbuffer = STp->buffer;
713 * If there was a bus reset, block further access
716 if (STp->pos_unknown)
719 if (STp->ready != ST_READY)
721 STps = &(STp->ps[STp->partition]);
722 if (STps->rw == ST_WRITING) /* Writing */
723 return st_flush_write_buffer(STp);
725 if (STp->block_size == 0)
728 backspace = ((STp->buffer)->buffer_bytes +
729 (STp->buffer)->read_pointer) / STp->block_size -
730 ((STp->buffer)->read_pointer + STp->block_size - 1) /
732 (STp->buffer)->buffer_bytes = 0;
733 (STp->buffer)->read_pointer = 0;
736 if (STps->eof == ST_FM_HIT) {
737 result = cross_eof(STp, 0); /* Back over the EOF hit */
739 STps->eof = ST_NOEOF;
741 if (STps->drv_file >= 0)
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)
752 STps->eof = ST_NOEOF;
758 /* Set the mode parameters */
759 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
763 char *name = tape_name(STp);
765 if (!STp->density_changed &&
766 STm->default_density >= 0 &&
767 STm->default_density != STp->density) {
768 arg = STm->default_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;
779 arg |= STp->block_size;
781 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
783 "%s: Can't set default block size to %d bytes and density %x.\n",
784 name, STm->default_blksize, STm->default_density);
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)
796 DEB(char *name = tape_name(STp);)
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);
804 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
807 STp->door_locked = ST_LOCK_FAILS;
813 /* Set the internal state after reset */
814 static void reset_state(struct scsi_tape *STp)
817 struct st_partstat *STps;
819 STp->pos_unknown = 0;
820 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
821 STps = &(STp->ps[i]);
823 STps->eof = ST_NOEOF;
825 STps->last_block_valid = 0;
826 STps->drv_block = -1;
829 if (STp->can_partitions) {
830 STp->partition = find_partition(STp);
831 if (STp->partition < 0)
833 STp->new_partition = STp->partition;
837 /* Test if the drive is ready. Returns either one of the codes below or a negative system
839 #define CHKRES_READY 0
840 #define CHKRES_NEW_SESSION 1
841 #define CHKRES_NOT_READY 2
842 #define CHKRES_NO_TAPE 3
844 #define MAX_ATTENTIONS 10
846 static int test_ready(struct scsi_tape *STp, int do_wait)
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;
854 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
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);
863 retval = (STp->buffer)->syscall_result;
867 if (cmdstatp->have_sense) {
869 scode = cmdstatp->sense_hdr.sense_key;
871 if (scode == UNIT_ATTENTION) { /* New media? */
873 if (attentions < MAX_ATTENTIONS) {
883 if (scode == NOT_READY) {
884 if (waits < max_wait) {
885 if (msleep_interruptible(1000)) {
893 if ((STp->device)->scsi_level >= SCSI_2 &&
894 cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
895 retval = CHKRES_NO_TAPE;
897 retval = CHKRES_NOT_READY;
903 retval = (STp->buffer)->syscall_result;
905 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
910 st_release_request(SRpnt);
915 /* See if the drive is ready and gather information about the tape. Return values:
916 < 0 negative error code from errno.h
918 1 drive not ready (possibly no tape)
920 static int check_tape(struct scsi_tape *STp, struct file *filp)
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);
932 STp->ready = ST_READY;
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));
938 STp->current_mode = mode;
940 STm = &(STp->modes[STp->current_mode]);
942 saved_cleaning = STp->cleaning_req;
943 STp->cleaning_req = 0;
945 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
946 retval = test_ready(STp, do_wait);
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
957 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
958 STps = &(STp->ps[i]);
960 STps->eof = ST_NOEOF;
962 STps->last_block_valid = 0;
969 STp->cleaning_req |= saved_cleaning;
971 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
972 if (retval == CHKRES_NO_TAPE)
973 STp->ready = ST_NO_TAPE;
975 STp->ready = ST_NOT_READY;
977 STp->density = 0; /* Clear the erroneous "residue" */
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;
987 if (STp->omit_blklims)
988 STp->min_block = STp->max_block = (-1);
990 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
991 cmd[0] = READ_BLOCK_LIMITS;
993 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
994 STp->device->timeout, MAX_READY_RETRIES, 1);
996 retval = (STp->buffer)->syscall_result;
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)
1007 "%s: Block limits %d - %d bytes.\n", name,
1008 STp->min_block, STp->max_block);
1010 STp->min_block = STp->max_block = (-1);
1011 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1016 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1017 cmd[0] = MODE_SENSE;
1020 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1021 STp->device->timeout, MAX_READY_RETRIES, 1);
1023 retval = (STp->buffer)->syscall_result;
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;
1033 DEBC(printk(ST_DEB_MSG
1034 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1036 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1037 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
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],
1050 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1052 st_release_request(SRpnt);
1056 if (STp->block_size > 0)
1057 (STp->buffer)->buffer_blocks =
1058 (STp->buffer)->buffer_size / STp->block_size;
1060 (STp->buffer)->buffer_blocks = 1;
1061 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
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));
1068 if (STp->drv_write_prot) {
1069 STp->write_prot = 1;
1071 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1074 ((st_flags & O_ACCMODE) == O_WRONLY ||
1075 (st_flags & O_ACCMODE) == O_RDWR)) {
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;
1091 STp->new_partition = STp->partition;
1092 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
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)
1102 if (STp->default_drvbuffer != 0xff) {
1103 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1105 "%s: Can't set default drive buffering to %d.\n",
1106 name, STp->default_drvbuffer);
1110 return CHKRES_READY;
1117 \f/* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1119 static int st_open(struct inode *inode, struct file *filp)
1121 int i, retval = (-EIO);
1122 struct scsi_tape *STp;
1123 struct st_partstat *STps;
1124 int dev = TAPE_NR(inode);
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.
1133 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1135 if (!(STp = scsi_tape_get(dev))) {
1140 write_lock(&st_dev_arr_lock);
1141 filp->private_data = STp;
1142 name = tape_name(STp);
1145 write_unlock(&st_dev_arr_lock);
1148 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1153 write_unlock(&st_dev_arr_lock);
1154 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1156 if (!scsi_block_when_processing_errors(STp->device)) {
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",
1165 retval = (-EOVERFLOW);
1169 (STp->buffer)->cleared = 0;
1170 (STp->buffer)->writing = 0;
1171 (STp->buffer)->syscall_result = 0;
1173 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1176 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1177 STps = &(STp->ps[i]);
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; )
1185 retval = check_tape(STp, filp);
1188 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1189 retval != CHKRES_READY) {
1190 if (STp->ready == NO_TAPE)
1191 retval = (-ENOMEDIUM);
1200 normalize_buffer(STp->buffer);
1209 /* Flush the tape buffer before close */
1210 static int st_flush(struct file *filp, fl_owner_t id)
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);
1220 if (file_count(filp) > 1)
1223 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1224 result = st_flush_write_buffer(STp);
1225 if (result != 0 && result != (-ENOSPC))
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));
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));
1242 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1243 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1245 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1246 name, STp->nbr_waits, STp->nbr_finished);
1249 memset(cmd, 0, MAX_COMMAND_SIZE);
1250 cmd[0] = WRITE_FILEMARKS;
1251 cmd[4] = 1 + STp->two_fm;
1253 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1254 STp->device->timeout, MAX_WRITE_RETRIES, 1);
1256 result = (STp->buffer)->syscall_result;
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);
1269 if (STps->drv_file >= 0)
1271 STps->drv_block = 0;
1276 else { /* Write error */
1277 st_release_request(SRpnt);
1279 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1284 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1286 } else if (!STp->rew_at_close) {
1287 STps = &(STp->ps[STp->partition]);
1288 if (!STm->sysv || STps->rw != ST_READING) {
1290 result = flush_buffer(STp, 0);
1291 else if (STps->eof == ST_FM_HIT) {
1292 result = cross_eof(STp, 0);
1294 if (STps->drv_file >= 0)
1296 STps->drv_block = 0;
1299 STps->eof = ST_NOEOF;
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)
1306 STps->drv_block = 0;
1312 if (STp->rew_at_close) {
1313 result2 = st_int_ioctl(STp, MTREW, 1);
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)
1326 struct scsi_tape *STp = filp->private_data;
1328 if (STp->door_locked == ST_LOCKED_AUTO)
1329 do_door_lock(STp, 0);
1331 normalize_buffer(STp->buffer);
1332 write_lock(&st_dev_arr_lock);
1334 write_unlock(&st_dev_arr_lock);
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)
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.
1351 if (!scsi_block_when_processing_errors(STp->device)) {
1356 if (STp->ready != ST_READY) {
1357 if (STp->ready == ST_NO_TAPE)
1358 retval = (-ENOMEDIUM);
1364 if (! STp->modes[STp->current_mode].defined) {
1371 * If there was a bus reset, block further access
1374 if (STp->pos_unknown) {
1384 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1389 if (STp->can_partitions &&
1390 (retval = switch_partition(STp)) < 0)
1393 if (STp->block_size == 0 && STp->max_block > 0 &&
1394 (count < STp->min_block || count > STp->max_block)) {
1399 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1400 !do_door_lock(STp, 1))
1401 STp->door_locked = ST_LOCKED_AUTO;
1408 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1409 size_t count, int is_read)
1411 int i, bufsize, retval = 0;
1412 struct st_buffer *STbp = STp->buffer;
1415 i = STp->try_dio_now && try_rdio;
1417 i = STp->try_dio_now && try_wdio;
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));
1425 STbp->buffer_bytes = 0; /* can be used as transfer counter */
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;
1434 STp->nbr_pages += STbp->do_dio;
1439 DEB( STp->nbr_requests++; )
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;
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)
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);
1460 if (STp->block_size)
1461 STbp->buffer_blocks = bufsize / STp->block_size;
1469 /* Can be called more than once after each setup_buffer() */
1470 static void release_buffering(struct scsi_tape *STp, int is_read)
1472 struct st_buffer *STbp;
1476 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, is_read);
1485 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1488 ssize_t i, do_count, blks, transfer;
1490 int undone, retry_eot = 0, scode;
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);
1501 if (mutex_lock_interruptible(&STp->lock))
1502 return -ERESTARTSYS;
1504 retval = rw_checks(STp, filp, count);
1505 if (retval || count == 0)
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",
1516 STm = &(STp->modes[STp->current_mode]);
1517 STps = &(STp->ps[STp->partition]);
1519 if (STp->write_prot) {
1525 if (STps->rw == ST_READING) {
1526 retval = flush_buffer(STp, 0);
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)
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",
1539 if (modes_defined) {
1548 i = write_behind_check(STp);
1551 STps->eof = ST_EOM_OK;
1553 STps->eof = ST_EOM_ERROR;
1556 if (STps->eof == ST_EOM_OK) {
1557 STps->eof = ST_EOD_1; /* allow next write */
1561 else if (STps->eof == ST_EOM_ERROR) {
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 &&
1570 (copy_from_user(&i, buf, 1) != 0 ||
1571 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1576 retval = setup_buffering(STp, buf, count, 0);
1582 memset(cmd, 0, MAX_COMMAND_SIZE);
1584 cmd[1] = (STp->block_size != 0);
1586 STps->rw = ST_WRITING;
1589 while (count > 0 && !retry_eot) {
1595 if (STp->block_size == 0)
1598 do_count = STbp->buffer_blocks * STp->block_size -
1600 if (do_count > count)
1604 i = append_to_buffer(b_point, STbp, do_count);
1611 b_point += do_count;
1613 async_write = STp->block_size == 0 && !STbp->do_dio &&
1614 STm->do_async_writes && STps->eof < ST_EOM_OK;
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) {
1620 /* Don't write a buffer that is not full enough. */
1621 if (!async_write && count == 0)
1626 if (STp->block_size == 0)
1627 blks = transfer = do_count;
1630 blks = STbp->buffer_bytes;
1633 blks /= STp->block_size;
1634 transfer = blks * STp->block_size;
1636 cmd[2] = blks >> 16;
1640 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1641 STp->device->timeout, MAX_WRITE_RETRIES, !async_write);
1643 retval = STbp->syscall_result;
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; )
1655 if (STbp->syscall_result != 0) {
1656 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
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)
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 */
1675 if (STp->block_size)
1676 blks = (transfer - undone) / STp->block_size;
1677 STps->eof = ST_EOM_OK;
1678 /* Continue in fixed block mode if all written
1679 in this request but still something left to write
1680 (retval left to zero)
1682 if (STp->block_size == 0 ||
1683 undone > 0 || count == 0)
1684 retval = (-ENOSPC); /* EOM within current request */
1685 DEBC(printk(ST_DEB_MSG
1686 "%s: EOM with %d bytes unwritten.\n",
1689 /* EOT within data buffered earlier (possible only
1690 in fixed block mode without direct i/o) */
1691 if (!retry_eot && !cmdstatp->deferred &&
1692 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1693 move_buffer_data(STp->buffer, transfer - undone);
1695 if (STps->drv_block >= 0) {
1696 STps->drv_block += (transfer - undone) /
1699 STps->eof = ST_EOM_OK;
1700 DEBC(printk(ST_DEB_MSG
1701 "%s: Retry write of %d bytes at EOM.\n",
1702 name, STp->buffer->buffer_bytes));
1706 /* Either error within data buffered by driver or
1709 blks = do_count = 0;
1710 STps->eof = ST_EOM_ERROR;
1711 STps->drv_block = (-1); /* Too cautious? */
1712 retval = (-EIO); /* EOM for old data */
1713 DEBC(printk(ST_DEB_MSG
1714 "%s: EOM with lost data.\n",
1720 STps->drv_block = (-1); /* Too cautious? */
1721 retval = STbp->syscall_result;
1726 if (STps->drv_block >= 0) {
1727 if (STp->block_size == 0)
1728 STps->drv_block += (do_count > 0);
1730 STps->drv_block += blks;
1733 STbp->buffer_bytes = 0;
1736 if (retval || retry_eot) {
1738 retval = total - count;
1743 if (STps->eof == ST_EOD_1)
1744 STps->eof = ST_EOM_OK;
1745 else if (STps->eof != ST_EOM_OK)
1746 STps->eof = ST_NOEOF;
1747 retval = total - count;
1751 st_release_request(SRpnt);
1752 release_buffering(STp, 0);
1753 mutex_unlock(&STp->lock);
1758 /* Read data from the tape. Returns zero in the normal case, one if the
1759 eof status has changed, and the negative error code in case of a
1760 fatal error. Otherwise updates the buffer and the eof state.
1762 Does release user buffer mapping if it is set.
1764 static long read_tape(struct scsi_tape *STp, long count,
1765 struct st_request ** aSRpnt)
1767 int transfer, blks, bytes;
1768 unsigned char cmd[MAX_COMMAND_SIZE];
1769 struct st_request *SRpnt;
1770 struct st_modedef *STm;
1771 struct st_partstat *STps;
1772 struct st_buffer *STbp;
1774 char *name = tape_name(STp);
1779 STm = &(STp->modes[STp->current_mode]);
1780 STps = &(STp->ps[STp->partition]);
1781 if (STps->eof == ST_FM_HIT)
1785 if (STp->block_size == 0)
1786 blks = bytes = count;
1788 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1789 blks = (STp->buffer)->buffer_blocks;
1790 bytes = blks * STp->block_size;
1793 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1794 bytes = (STp->buffer)->buffer_size;
1795 blks = bytes / STp->block_size;
1796 bytes = blks * STp->block_size;
1800 memset(cmd, 0, MAX_COMMAND_SIZE);
1802 cmd[1] = (STp->block_size != 0);
1803 if (!cmd[1] && STp->sili)
1805 cmd[2] = blks >> 16;
1810 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1811 STp->device->timeout, MAX_RETRIES, 1);
1812 release_buffering(STp, 1);
1815 return STbp->syscall_result;
1817 STbp->read_pointer = 0;
1820 /* Something to check */
1821 if (STbp->syscall_result) {
1822 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1825 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1827 SRpnt->sense[0], SRpnt->sense[1],
1828 SRpnt->sense[2], SRpnt->sense[3],
1829 SRpnt->sense[4], SRpnt->sense[5],
1830 SRpnt->sense[6], SRpnt->sense[7]));
1831 if (cmdstatp->have_sense) {
1833 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1834 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1836 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1837 /* Compute the residual count */
1838 if (cmdstatp->remainder_valid)
1839 transfer = (int)cmdstatp->uremainder64;
1842 if (STp->block_size == 0 &&
1843 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1846 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
1847 if (STp->block_size == 0) {
1848 if (transfer <= 0) {
1851 "%s: Failed to read %d byte block with %d byte transfer.\n",
1852 name, bytes - transfer, bytes);
1853 if (STps->drv_block >= 0)
1854 STps->drv_block += 1;
1855 STbp->buffer_bytes = 0;
1858 STbp->buffer_bytes = bytes - transfer;
1860 st_release_request(SRpnt);
1861 SRpnt = *aSRpnt = NULL;
1862 if (transfer == blks) { /* We did not get anything, error */
1863 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1864 if (STps->drv_block >= 0)
1865 STps->drv_block += blks - transfer + 1;
1866 st_int_ioctl(STp, MTBSR, 1);
1869 /* We have some data, deliver it */
1870 STbp->buffer_bytes = (blks - transfer) *
1872 DEBC(printk(ST_DEB_MSG
1873 "%s: ILI but enough data received %ld %d.\n",
1874 name, count, STbp->buffer_bytes));
1875 if (STps->drv_block >= 0)
1876 STps->drv_block += 1;
1877 if (st_int_ioctl(STp, MTBSR, 1))
1880 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
1881 if (STps->eof != ST_FM_HIT)
1882 STps->eof = ST_FM_HIT;
1884 STps->eof = ST_EOD_2;
1885 if (STp->block_size == 0)
1886 STbp->buffer_bytes = 0;
1888 STbp->buffer_bytes =
1889 bytes - transfer * STp->block_size;
1890 DEBC(printk(ST_DEB_MSG
1891 "%s: EOF detected (%d bytes read).\n",
1892 name, STbp->buffer_bytes));
1893 } else if (cmdstatp->flags & SENSE_EOM) {
1894 if (STps->eof == ST_FM)
1895 STps->eof = ST_EOD_1;
1897 STps->eof = ST_EOM_OK;
1898 if (STp->block_size == 0)
1899 STbp->buffer_bytes = bytes - transfer;
1901 STbp->buffer_bytes =
1902 bytes - transfer * STp->block_size;
1904 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1905 name, STbp->buffer_bytes));
1908 /* end of EOF, EOM, ILI test */
1909 else { /* nonzero sense key */
1910 DEBC(printk(ST_DEB_MSG
1911 "%s: Tape error while reading.\n", name));
1912 STps->drv_block = (-1);
1913 if (STps->eof == ST_FM &&
1914 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1915 DEBC(printk(ST_DEB_MSG
1916 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1918 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1919 } else /* Some other extended sense code */
1923 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
1924 STbp->buffer_bytes = 0;
1926 /* End of extended sense test */
1927 else { /* Non-extended sense */
1928 retval = STbp->syscall_result;
1932 /* End of error handling */
1933 else { /* Read successful */
1934 STbp->buffer_bytes = bytes;
1935 if (STp->sili) /* In fixed block mode residual is always zero here */
1936 STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
1939 if (STps->drv_block >= 0) {
1940 if (STp->block_size == 0)
1943 STps->drv_block += STbp->buffer_bytes / STp->block_size;
1951 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
1955 ssize_t i, transfer;
1956 int special, do_dio = 0;
1957 struct st_request *SRpnt = NULL;
1958 struct scsi_tape *STp = filp->private_data;
1959 struct st_modedef *STm;
1960 struct st_partstat *STps;
1961 struct st_buffer *STbp = STp->buffer;
1962 DEB( char *name = tape_name(STp); )
1964 if (mutex_lock_interruptible(&STp->lock))
1965 return -ERESTARTSYS;
1967 retval = rw_checks(STp, filp, count);
1968 if (retval || count == 0)
1971 STm = &(STp->modes[STp->current_mode]);
1972 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1973 if (!STm->do_read_ahead) {
1974 retval = (-EINVAL); /* Read must be integral number of blocks */
1977 STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */
1980 STps = &(STp->ps[STp->partition]);
1981 if (STps->rw == ST_WRITING) {
1982 retval = flush_buffer(STp, 0);
1985 STps->rw = ST_READING;
1988 if (debugging && STps->eof != ST_NOEOF)
1989 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
1990 STps->eof, STbp->buffer_bytes);
1993 retval = setup_buffering(STp, buf, count, 1);
1996 do_dio = STbp->do_dio;
1998 if (STbp->buffer_bytes == 0 &&
1999 STps->eof >= ST_EOD_1) {
2000 if (STps->eof < ST_EOD) {
2005 retval = (-EIO); /* EOM or Blank Check */
2010 /* Check the buffer writability before any tape movement. Don't alter
2012 if (copy_from_user(&i, buf, 1) != 0 ||
2013 copy_to_user(buf, &i, 1) != 0 ||
2014 copy_from_user(&i, buf + count - 1, 1) != 0 ||
2015 copy_to_user(buf + count - 1, &i, 1) != 0) {
2021 STps->rw = ST_READING;
2024 /* Loop until enough data in buffer or a special condition found */
2025 for (total = 0, special = 0; total < count && !special;) {
2027 /* Get new data if the buffer is empty */
2028 if (STbp->buffer_bytes == 0) {
2029 special = read_tape(STp, count - total, &SRpnt);
2030 if (special < 0) { /* No need to continue read */
2036 /* Move the data from driver buffer to user buffer */
2037 if (STbp->buffer_bytes > 0) {
2039 if (debugging && STps->eof != ST_NOEOF)
2041 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2042 STps->eof, STbp->buffer_bytes,
2043 (int)(count - total));
2045 transfer = STbp->buffer_bytes < count - total ?
2046 STbp->buffer_bytes : count - total;
2048 i = from_buffer(STbp, buf, transfer);
2058 if (STp->block_size == 0)
2059 break; /* Read only one variable length block */
2061 } /* for (total = 0, special = 0;
2062 total < count && !special; ) */
2064 /* Change the eof state if no data from tape or buffer */
2066 if (STps->eof == ST_FM_HIT) {
2068 STps->drv_block = 0;
2069 if (STps->drv_file >= 0)
2071 } else if (STps->eof == ST_EOD_1) {
2072 STps->eof = ST_EOD_2;
2073 STps->drv_block = 0;
2074 if (STps->drv_file >= 0)
2076 } else if (STps->eof == ST_EOD_2)
2078 } else if (STps->eof == ST_FM)
2079 STps->eof = ST_NOEOF;
2083 if (SRpnt != NULL) {
2084 st_release_request(SRpnt);
2088 release_buffering(STp, 1);
2089 STbp->buffer_bytes = 0;
2091 mutex_unlock(&STp->lock);
2099 /* Set the driver options */
2100 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2104 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2105 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2106 STm->do_read_ahead);
2108 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2109 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2111 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2112 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2113 STp->scsi2_logical);
2115 "%s: sysv: %d nowait: %d sili: %d\n", name, STm->sysv, STp->immediate,
2117 printk(KERN_INFO "%s: debugging: %d\n",
2124 static int st_set_options(struct scsi_tape *STp, long options)
2128 struct st_modedef *STm;
2129 char *name = tape_name(STp);
2130 struct cdev *cd0, *cd1;
2132 STm = &(STp->modes[STp->current_mode]);
2133 if (!STm->defined) {
2134 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2135 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2136 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2138 DEBC(printk(ST_DEB_MSG
2139 "%s: Initialized mode %d definition from mode 0\n",
2140 name, STp->current_mode));
2143 code = options & MT_ST_OPTIONS;
2144 if (code == MT_ST_BOOLEANS) {
2145 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2146 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2147 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2148 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2149 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2150 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2151 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2152 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2153 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2154 if ((STp->device)->scsi_level >= SCSI_2)
2155 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2156 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2157 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2158 STm->sysv = (options & MT_ST_SYSV) != 0;
2159 STp->sili = (options & MT_ST_SILI) != 0;
2160 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2161 st_log_options(STp, STm, name); )
2162 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2163 value = (code == MT_ST_SETBOOLEANS);
2164 if ((options & MT_ST_BUFFER_WRITES) != 0)
2165 STm->do_buffer_writes = value;
2166 if ((options & MT_ST_ASYNC_WRITES) != 0)
2167 STm->do_async_writes = value;
2168 if ((options & MT_ST_DEF_WRITES) != 0)
2169 STm->defaults_for_writes = value;
2170 if ((options & MT_ST_READ_AHEAD) != 0)
2171 STm->do_read_ahead = value;
2172 if ((options & MT_ST_TWO_FM) != 0)
2173 STp->two_fm = value;
2174 if ((options & MT_ST_FAST_MTEOM) != 0)
2175 STp->fast_mteom = value;
2176 if ((options & MT_ST_AUTO_LOCK) != 0)
2177 STp->do_auto_lock = value;
2178 if ((options & MT_ST_CAN_BSR) != 0)
2179 STp->can_bsr = value;
2180 if ((options & MT_ST_NO_BLKLIMS) != 0)
2181 STp->omit_blklims = value;
2182 if ((STp->device)->scsi_level >= SCSI_2 &&
2183 (options & MT_ST_CAN_PARTITIONS) != 0)
2184 STp->can_partitions = value;
2185 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2186 STp->scsi2_logical = value;
2187 if ((options & MT_ST_NOWAIT) != 0)
2188 STp->immediate = value;
2189 if ((options & MT_ST_SYSV) != 0)
2191 if ((options & MT_ST_SILI) != 0)
2194 if ((options & MT_ST_DEBUGGING) != 0)
2196 st_log_options(STp, STm, name); )
2197 } else if (code == MT_ST_WRITE_THRESHOLD) {
2198 /* Retained for compatibility */
2199 } else if (code == MT_ST_DEF_BLKSIZE) {
2200 value = (options & ~MT_ST_OPTIONS);
2201 if (value == ~MT_ST_OPTIONS) {
2202 STm->default_blksize = (-1);
2203 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2205 STm->default_blksize = value;
2206 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2207 name, STm->default_blksize));
2208 if (STp->ready == ST_READY) {
2209 STp->blksize_changed = 0;
2210 set_mode_densblk(STp, STm);
2213 } else if (code == MT_ST_TIMEOUTS) {
2214 value = (options & ~MT_ST_OPTIONS);
2215 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2216 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2217 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2218 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2220 STp->device->timeout = value * HZ;
2221 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2224 } else if (code == MT_ST_SET_CLN) {
2225 value = (options & ~MT_ST_OPTIONS) & 0xff;
2227 value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2229 STp->cln_mode = value;
2230 STp->cln_sense_mask = (options >> 8) & 0xff;
2231 STp->cln_sense_value = (options >> 16) & 0xff;
2233 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2234 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2235 } else if (code == MT_ST_DEF_OPTIONS) {
2236 code = (options & ~MT_ST_CLEAR_DEFAULT);
2237 value = (options & MT_ST_CLEAR_DEFAULT);
2238 if (code == MT_ST_DEF_DENSITY) {
2239 if (value == MT_ST_CLEAR_DEFAULT) {
2240 STm->default_density = (-1);
2241 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2244 STm->default_density = value & 0xff;
2245 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2246 name, STm->default_density));
2247 if (STp->ready == ST_READY) {
2248 STp->density_changed = 0;
2249 set_mode_densblk(STp, STm);
2252 } else if (code == MT_ST_DEF_DRVBUFFER) {
2253 if (value == MT_ST_CLEAR_DEFAULT) {
2254 STp->default_drvbuffer = 0xff;
2255 DEBC( printk(KERN_INFO
2256 "%s: Drive buffer default disabled.\n", name));
2258 STp->default_drvbuffer = value & 7;
2259 DEBC( printk(KERN_INFO
2260 "%s: Drive buffer default set to %x\n",
2261 name, STp->default_drvbuffer));
2262 if (STp->ready == ST_READY)
2263 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2265 } else if (code == MT_ST_DEF_COMPRESSION) {
2266 if (value == MT_ST_CLEAR_DEFAULT) {
2267 STm->default_compression = ST_DONT_TOUCH;
2268 DEBC( printk(KERN_INFO
2269 "%s: Compression default disabled.\n", name));
2271 if ((value & 0xff00) != 0) {
2272 STp->c_algo = (value & 0xff00) >> 8;
2273 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2274 name, STp->c_algo));
2276 if ((value & 0xff) != 0xff) {
2277 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2278 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2279 name, (value & 1)));
2280 if (STp->ready == ST_READY) {
2281 STp->compression_changed = 0;
2282 st_compression(STp, (STm->default_compression == ST_YES));
2293 #define MODE_HEADER_LENGTH 4
2295 /* Mode header and page byte offsets */
2296 #define MH_OFF_DATA_LENGTH 0
2297 #define MH_OFF_MEDIUM_TYPE 1
2298 #define MH_OFF_DEV_SPECIFIC 2
2299 #define MH_OFF_BDESCS_LENGTH 3
2300 #define MP_OFF_PAGE_NBR 0
2301 #define MP_OFF_PAGE_LENGTH 1
2303 /* Mode header and page bit masks */
2304 #define MH_BIT_WP 0x80
2305 #define MP_MSK_PAGE_NBR 0x3f
2307 /* Don't return block descriptors */
2308 #define MODE_SENSE_OMIT_BDESCS 0x08
2310 #define MODE_SELECT_PAGE_FORMAT 0x10
2312 /* Read a mode page into the tape buffer. The block descriptors are included
2313 if incl_block_descs is true. The page control is ored to the page number
2314 parameter, if necessary. */
2315 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2317 unsigned char cmd[MAX_COMMAND_SIZE];
2318 struct st_request *SRpnt = NULL;
2320 memset(cmd, 0, MAX_COMMAND_SIZE);
2321 cmd[0] = MODE_SENSE;
2322 if (omit_block_descs)
2323 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2327 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2328 STp->device->timeout, 0, 1);
2330 return (STp->buffer)->syscall_result;
2332 st_release_request(SRpnt);
2334 return (STp->buffer)->syscall_result;
2338 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2339 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2340 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2343 unsigned char cmd[MAX_COMMAND_SIZE];
2344 struct st_request *SRpnt = NULL;
2346 memset(cmd, 0, MAX_COMMAND_SIZE);
2347 cmd[0] = MODE_SELECT;
2348 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2349 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2350 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2352 /* Clear reserved fields */
2353 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2354 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2355 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2356 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2358 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE,
2359 (slow ? STp->long_timeout : STp->device->timeout), 0, 1);
2361 return (STp->buffer)->syscall_result;
2363 st_release_request(SRpnt);
2365 return (STp->buffer)->syscall_result;
2369 #define COMPRESSION_PAGE 0x0f
2370 #define COMPRESSION_PAGE_LENGTH 16
2372 #define CP_OFF_DCE_DCC 2
2373 #define CP_OFF_C_ALGO 7
2375 #define DCE_MASK 0x80
2376 #define DCC_MASK 0x40
2377 #define RED_MASK 0x60
2380 /* Control the compression with mode page 15. Algorithm not changed if zero.
2382 The block descriptors are read and written because Sony SDT-7000 does not
2383 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2384 Including block descriptors should not cause any harm to other drives. */
2386 static int st_compression(struct scsi_tape * STp, int state)
2389 int mpoffs; /* Offset to mode page start */
2390 unsigned char *b_data = (STp->buffer)->b_data;
2391 DEB( char *name = tape_name(STp); )
2393 if (STp->ready != ST_READY)
2396 /* Read the current page contents */
2397 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2399 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2404 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2405 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2406 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2408 /* Check if compression can be changed */
2409 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2410 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2416 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2417 if (STp->c_algo != 0)
2418 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2421 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2422 if (STp->c_algo != 0)
2423 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2426 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2428 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2431 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2434 STp->compression_changed = 1;
2439 /* Process the load and unload commands (does unload if the load code is zero) */
2440 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2442 int retval = (-EIO), timeout;
2443 DEB( char *name = tape_name(STp); )
2444 unsigned char cmd[MAX_COMMAND_SIZE];
2445 struct st_partstat *STps;
2446 struct st_request *SRpnt;
2448 if (STp->ready != ST_READY && !load_code) {
2449 if (STp->ready == ST_NO_TAPE)
2450 return (-ENOMEDIUM);
2455 memset(cmd, 0, MAX_COMMAND_SIZE);
2456 cmd[0] = START_STOP;
2460 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2462 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2463 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2464 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2465 name, (cmd[4]) ? "" : "un",
2466 load_code - MT_ST_HPLOADER_OFFSET));
2467 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2469 if (STp->immediate) {
2470 cmd[1] = 1; /* Don't wait for completion */
2471 timeout = STp->device->timeout;
2474 timeout = STp->long_timeout;
2478 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2480 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2483 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2484 timeout, MAX_RETRIES, 1);
2486 return (STp->buffer)->syscall_result;
2488 retval = (STp->buffer)->syscall_result;
2489 st_release_request(SRpnt);
2491 if (!retval) { /* SCSI command successful */
2494 STp->rew_at_close = 0;
2495 STp->ready = ST_NO_TAPE;
2498 STp->rew_at_close = STp->autorew_dev;
2499 retval = check_tape(STp, filp);
2505 STps = &(STp->ps[STp->partition]);
2506 STps->drv_file = STps->drv_block = (-1);
2513 #define ST_DEB_FORWARD 0
2514 #define ST_DEB_BACKWARD 1
2515 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2519 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2520 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2523 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2524 direction ? "backward" : "forward", sc, units);
2529 /* Internal ioctl function */
2530 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2536 unsigned char cmd[MAX_COMMAND_SIZE];
2537 struct st_request *SRpnt;
2538 struct st_partstat *STps;
2539 int fileno, blkno, at_sm, undone;
2540 int datalen = 0, direction = DMA_NONE;
2541 char *name = tape_name(STp);
2543 WARN_ON(STp->buffer->do_dio != 0);
2544 if (STp->ready != ST_READY) {
2545 if (STp->ready == ST_NO_TAPE)
2546 return (-ENOMEDIUM);
2550 timeout = STp->long_timeout;
2551 STps = &(STp->ps[STp->partition]);
2552 fileno = STps->drv_file;
2553 blkno = STps->drv_block;
2554 at_sm = STps->at_sm;
2556 memset(cmd, 0, MAX_COMMAND_SIZE);
2559 chg_eof = 0; /* Changed from the FSF after this */
2562 cmd[1] = 0x01; /* Space FileMarks */
2563 cmd[2] = (arg >> 16);
2564 cmd[3] = (arg >> 8);
2566 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2570 at_sm &= (arg == 0);
2573 chg_eof = 0; /* Changed from the FSF after this */
2576 cmd[1] = 0x01; /* Space FileMarks */
2578 cmd[2] = (ltmp >> 16);
2579 cmd[3] = (ltmp >> 8);
2581 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2584 blkno = (-1); /* We can't know the block number */
2585 at_sm &= (arg == 0);
2589 cmd[1] = 0x00; /* Space Blocks */
2590 cmd[2] = (arg >> 16);
2591 cmd[3] = (arg >> 8);
2593 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2596 at_sm &= (arg == 0);
2600 cmd[1] = 0x00; /* Space Blocks */
2602 cmd[2] = (ltmp >> 16);
2603 cmd[3] = (ltmp >> 8);
2605 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2608 at_sm &= (arg == 0);
2612 cmd[1] = 0x04; /* Space Setmarks */
2613 cmd[2] = (arg >> 16);
2614 cmd[3] = (arg >> 8);
2616 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2618 blkno = fileno = (-1);
2624 cmd[1] = 0x04; /* Space Setmarks */
2626 cmd[2] = (ltmp >> 16);
2627 cmd[3] = (ltmp >> 8);
2629 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2631 blkno = fileno = (-1);
2637 if (STp->write_prot)
2639 cmd[0] = WRITE_FILEMARKS;
2640 if (cmd_in == MTWSM)
2642 cmd[2] = (arg >> 16);
2643 cmd[3] = (arg >> 8);
2645 timeout = STp->device->timeout;
2647 if (cmd_in == MTWEOF)
2648 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2649 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2651 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2652 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2657 at_sm = (cmd_in == MTWSM);
2660 cmd[0] = REZERO_UNIT;
2661 if (STp->immediate) {
2662 cmd[1] = 1; /* Don't wait for completion */
2663 timeout = STp->device->timeout;
2665 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2666 fileno = blkno = at_sm = 0;
2669 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2670 return 0; /* Should do something ? */
2673 cmd[0] = START_STOP;
2674 if (STp->immediate) {
2675 cmd[1] = 1; /* Don't wait for completion */
2676 timeout = STp->device->timeout;
2679 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2680 fileno = blkno = at_sm = 0;
2683 if (!STp->fast_mteom) {
2684 /* space to the end of tape */
2685 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2686 fileno = STps->drv_file;
2687 if (STps->eof >= ST_EOD_1)
2689 /* The next lines would hide the number of spaced FileMarks
2690 That's why I inserted the previous lines. I had no luck
2691 with detecting EOM with FSF, so we go now to EOM.
2697 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2703 if (STp->write_prot)
2706 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2707 if (STp->immediate) {
2708 cmd[1] |= 2; /* Don't wait for completion */
2709 timeout = STp->device->timeout;
2712 timeout = STp->long_timeout * 8;
2714 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2715 fileno = blkno = at_sm = 0;
2717 case MTSETBLK: /* Set block length */
2718 case MTSETDENSITY: /* Set tape density */
2719 case MTSETDRVBUFFER: /* Set drive buffering */
2720 case SET_DENS_AND_BLK: /* Set density and block size */
2722 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2723 return (-EIO); /* Not allowed if data in buffer */
2724 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2725 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2726 STp->max_block > 0 &&
2727 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2728 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2729 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2732 cmd[0] = MODE_SELECT;
2733 if ((STp->use_pf & USE_PF))
2734 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2735 cmd[4] = datalen = 12;
2736 direction = DMA_TO_DEVICE;
2738 memset((STp->buffer)->b_data, 0, 12);
2739 if (cmd_in == MTSETDRVBUFFER)
2740 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2742 (STp->buffer)->b_data[2] =
2743 STp->drv_buffer << 4;
2744 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2745 if (cmd_in == MTSETDENSITY) {
2746 (STp->buffer)->b_data[4] = arg;
2747 STp->density_changed = 1; /* At least we tried ;-) */
2748 } else if (cmd_in == SET_DENS_AND_BLK)
2749 (STp->buffer)->b_data[4] = arg >> 24;
2751 (STp->buffer)->b_data[4] = STp->density;
2752 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2753 ltmp = arg & MT_ST_BLKSIZE_MASK;
2754 if (cmd_in == MTSETBLK)
2755 STp->blksize_changed = 1; /* At least we tried ;-) */
2757 ltmp = STp->block_size;
2758 (STp->buffer)->b_data[9] = (ltmp >> 16);
2759 (STp->buffer)->b_data[10] = (ltmp >> 8);
2760 (STp->buffer)->b_data[11] = ltmp;
2761 timeout = STp->device->timeout;
2763 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2765 "%s: Setting block size to %d bytes.\n", name,
2766 (STp->buffer)->b_data[9] * 65536 +
2767 (STp->buffer)->b_data[10] * 256 +
2768 (STp->buffer)->b_data[11]);
2769 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2771 "%s: Setting density code to %x.\n", name,
2772 (STp->buffer)->b_data[4]);
2773 if (cmd_in == MTSETDRVBUFFER)
2775 "%s: Setting drive buffer code to %d.\n", name,
2776 ((STp->buffer)->b_data[2] >> 4) & 7);
2783 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2784 timeout, MAX_RETRIES, 1);
2786 return (STp->buffer)->syscall_result;
2788 ioctl_result = (STp->buffer)->syscall_result;
2790 if (!ioctl_result) { /* SCSI command successful */
2791 st_release_request(SRpnt);
2793 STps->drv_block = blkno;
2794 STps->drv_file = fileno;
2795 STps->at_sm = at_sm;
2797 if (cmd_in == MTBSFM)
2798 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2799 else if (cmd_in == MTFSFM)
2800 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2802 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2803 int old_block_size = STp->block_size;
2804 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2805 if (STp->block_size != 0) {
2806 if (old_block_size == 0)
2807 normalize_buffer(STp->buffer);
2808 (STp->buffer)->buffer_blocks =
2809 (STp->buffer)->buffer_size / STp->block_size;
2811 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2812 if (cmd_in == SET_DENS_AND_BLK)
2813 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2814 } else if (cmd_in == MTSETDRVBUFFER)
2815 STp->drv_buffer = (arg & 7);
2816 else if (cmd_in == MTSETDENSITY)
2819 if (cmd_in == MTEOM)
2821 else if (cmd_in == MTFSF)
2824 STps->eof = ST_NOEOF;
2826 if (cmd_in == MTWEOF)
2828 } else { /* SCSI command was not completely successful. Don't return
2829 from this block without releasing the SCSI command block! */
2830 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2832 if (cmdstatp->flags & SENSE_EOM) {
2833 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2834 cmd_in != MTBSR && cmd_in != MTBSS)
2835 STps->eof = ST_EOM_OK;
2836 STps->drv_block = 0;
2839 if (cmdstatp->remainder_valid)
2840 undone = (int)cmdstatp->uremainder64;
2844 if (cmd_in == MTWEOF &&
2845 cmdstatp->have_sense &&
2846 (cmdstatp->flags & SENSE_EOM)) {
2847 if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2848 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2849 ioctl_result = 0; /* EOF(s) written successfully at EOM */
2850 STps->eof = ST_NOEOF;
2851 } else { /* Writing EOF(s) failed */
2855 STps->eof = ST_NOEOF;
2857 STps->drv_file = fileno;
2858 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2860 STps->drv_file = fileno - undone;
2862 STps->drv_file = fileno;
2863 STps->drv_block = -1;
2864 STps->eof = ST_NOEOF;
2865 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2866 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2868 if (STps->drv_file >= 0)
2869 STps->drv_file = fileno + undone;
2870 STps->drv_block = 0;
2871 STps->eof = ST_NOEOF;
2872 } else if (cmd_in == MTFSR) {
2873 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2874 if (STps->drv_file >= 0)
2876 STps->drv_block = 0;
2879 if (blkno >= undone)
2880 STps->drv_block = blkno - undone;
2882 STps->drv_block = (-1);
2883 STps->eof = ST_NOEOF;
2885 } else if (cmd_in == MTBSR) {
2886 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2888 STps->drv_block = (-1);
2890 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2892 if (STps->drv_block >= 0)
2893 STps->drv_block = blkno + undone;
2895 STps->eof = ST_NOEOF;
2896 } else if (cmd_in == MTEOM) {
2897 STps->drv_file = (-1);
2898 STps->drv_block = (-1);
2900 } else if (cmd_in == MTSETBLK ||
2901 cmd_in == MTSETDENSITY ||
2902 cmd_in == MTSETDRVBUFFER ||
2903 cmd_in == SET_DENS_AND_BLK) {
2904 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2905 !(STp->use_pf & PF_TESTED)) {
2906 /* Try the other possible state of Page Format if not
2908 STp->use_pf = !STp->use_pf | PF_TESTED;
2909 st_release_request(SRpnt);
2911 return st_int_ioctl(STp, cmd_in, arg);
2914 STps->eof = ST_NOEOF;
2916 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2919 st_release_request(SRpnt);
2923 return ioctl_result;
2927 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2930 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2934 unsigned char scmd[MAX_COMMAND_SIZE];
2935 struct st_request *SRpnt;
2936 DEB( char *name = tape_name(STp); )
2938 if (STp->ready != ST_READY)
2941 memset(scmd, 0, MAX_COMMAND_SIZE);
2942 if ((STp->device)->scsi_level < SCSI_2) {
2943 scmd[0] = QFA_REQUEST_BLOCK;
2946 scmd[0] = READ_POSITION;
2947 if (!logical && !STp->scsi2_logical)
2950 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
2951 STp->device->timeout, MAX_READY_RETRIES, 1);
2953 return (STp->buffer)->syscall_result;
2955 if ((STp->buffer)->syscall_result != 0 ||
2956 (STp->device->scsi_level >= SCSI_2 &&
2957 ((STp->buffer)->b_data[0] & 4) != 0)) {
2958 *block = *partition = 0;
2959 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
2963 if ((STp->device)->scsi_level < SCSI_2) {
2964 *block = ((STp->buffer)->b_data[0] << 16)
2965 + ((STp->buffer)->b_data[1] << 8)
2966 + (STp->buffer)->b_data[2];
2969 *block = ((STp->buffer)->b_data[4] << 24)
2970 + ((STp->buffer)->b_data[5] << 16)
2971 + ((STp->buffer)->b_data[6] << 8)
2972 + (STp->buffer)->b_data[7];
2973 *partition = (STp->buffer)->b_data[1];
2974 if (((STp->buffer)->b_data[0] & 0x80) &&
2975 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
2976 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
2978 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
2979 *block, *partition));
2981 st_release_request(SRpnt);
2988 /* Set the tape block and partition. Negative partition means that only the
2989 block should be set in vendor specific way. */
2990 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
2993 struct st_partstat *STps;
2997 unsigned char scmd[MAX_COMMAND_SIZE];
2998 struct st_request *SRpnt;
2999 DEB( char *name = tape_name(STp); )
3001 if (STp->ready != ST_READY)
3003 timeout = STp->long_timeout;
3004 STps = &(STp->ps[STp->partition]);
3006 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3007 name, block, partition));
3008 DEB(if (partition < 0)
3011 /* Update the location at the partition we are leaving */
3012 if ((!STp->can_partitions && partition != 0) ||
3013 partition >= ST_NBR_PARTITIONS)
3015 if (partition != STp->partition) {
3016 if (get_location(STp, &blk, &p, 1))
3017 STps->last_block_valid = 0;
3019 STps->last_block_valid = 1;
3020 STps->last_block_visited = blk;
3021 DEBC(printk(ST_DEB_MSG
3022 "%s: Visited block %d for partition %d saved.\n",
3023 name, blk, STp->partition));
3027 memset(scmd, 0, MAX_COMMAND_SIZE);
3028 if ((STp->device)->scsi_level < SCSI_2) {
3029 scmd[0] = QFA_SEEK_BLOCK;
3030 scmd[2] = (block >> 16);
3031 scmd[3] = (block >> 8);
3036 scmd[3] = (block >> 24);
3037 scmd[4] = (block >> 16);
3038 scmd[5] = (block >> 8);
3040 if (!logical && !STp->scsi2_logical)
3042 if (STp->partition != partition) {
3044 scmd[8] = partition;
3045 DEBC(printk(ST_DEB_MSG
3046 "%s: Trying to change partition from %d to %d\n",
3047 name, STp->partition, partition));
3050 if (STp->immediate) {
3051 scmd[1] |= 1; /* Don't wait for completion */
3052 timeout = STp->device->timeout;
3055 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3056 timeout, MAX_READY_RETRIES, 1);
3058 return (STp->buffer)->syscall_result;
3060 STps->drv_block = STps->drv_file = (-1);
3061 STps->eof = ST_NOEOF;
3062 if ((STp->buffer)->syscall_result != 0) {
3064 if (STp->can_partitions &&
3065 (STp->device)->scsi_level >= SCSI_2 &&
3066 (p = find_partition(STp)) >= 0)
3069 if (STp->can_partitions) {
3070 STp->partition = partition;
3071 STps = &(STp->ps[partition]);
3072 if (!STps->last_block_valid ||
3073 STps->last_block_visited != block) {
3080 STps->drv_block = STps->drv_file = 0;
3084 st_release_request(SRpnt);
3091 /* Find the current partition number for the drive status. Called from open and
3092 returns either partition number of negative error code. */
3093 static int find_partition(struct scsi_tape *STp)
3098 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3100 if (partition >= ST_NBR_PARTITIONS)
3106 /* Change the partition if necessary */
3107 static int switch_partition(struct scsi_tape *STp)
3109 struct st_partstat *STps;
3111 if (STp->partition == STp->new_partition)
3113 STps = &(STp->ps[STp->new_partition]);
3114 if (!STps->last_block_valid)
3115 STps->last_block_visited = 0;
3116 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3119 /* Functions for reading and writing the medium partition mode page. */
3121 #define PART_PAGE 0x11
3122 #define PART_PAGE_FIXED_LENGTH 8
3124 #define PP_OFF_MAX_ADD_PARTS 2
3125 #define PP_OFF_NBR_ADD_PARTS 3
3126 #define PP_OFF_FLAGS 4
3127 #define PP_OFF_PART_UNITS 6
3128 #define PP_OFF_RESERVED 7
3130 #define PP_BIT_IDP 0x20
3131 #define PP_MSK_PSUM_MB 0x10
3133 /* Get the number of partitions on the tape. As a side effect reads the
3134 mode page into the tape buffer. */
3135 static int nbr_partitions(struct scsi_tape *STp)
3138 DEB( char *name = tape_name(STp); )
3140 if (STp->ready != ST_READY)
3143 result = read_mode_page(STp, PART_PAGE, 1);
3146 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3150 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3151 PP_OFF_NBR_ADD_PARTS] + 1;
3152 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3159 /* Partition the tape into two partitions if size > 0 or one partition if
3162 The block descriptors are read and written because Sony SDT-7000 does not
3163 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3165 My HP C1533A drive returns only one partition size field. This is used to
3166 set the size of partition 1. There is no size field for the default partition.
3167 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3168 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3169 The following algorithm is used to accommodate both drives: if the number of
3170 partition size fields is greater than the maximum number of additional partitions
3171 in the mode page, the second field is used. Otherwise the first field is used.
3173 For Seagate DDS drives the page length must be 8 when no partitions is defined
3174 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3175 is acceptable also to some other old drives and enforced if the first partition
3176 size field is used for the first additional partition size.
3178 static int partition_tape(struct scsi_tape *STp, int size)
3180 char *name = tape_name(STp);
3182 int pgo, psd_cnt, psdo;
3185 result = read_mode_page(STp, PART_PAGE, 0);
3187 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3190 /* The mode page is in the buffer. Let's modify it and write it. */
3191 bp = (STp->buffer)->b_data;
3192 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3193 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3194 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3196 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3197 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3198 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3199 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3202 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3204 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3205 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3206 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3209 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3210 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3211 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3212 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3215 bp[psdo] = (size >> 8) & 0xff;
3216 bp[psdo + 1] = size & 0xff;
3218 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3219 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3220 DEBC(printk(ST_DEB_MSG
3221 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3224 bp[pgo + PP_OFF_PART_UNITS] = 0;
3225 bp[pgo + PP_OFF_RESERVED] = 0;
3226 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3228 result = write_mode_page(STp, PART_PAGE, 1);
3230 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3239 /* The ioctl command */
3240 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3242 int i, cmd_nr, cmd_type, bt;
3245 struct scsi_tape *STp = file->private_data;
3246 struct st_modedef *STm;
3247 struct st_partstat *STps;
3248 char *name = tape_name(STp);
3249 void __user *p = (void __user *)arg;
3251 if (mutex_lock_interruptible(&STp->lock))
3252 return -ERESTARTSYS;
3255 if (debugging && !STp->in_use) {
3256 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3261 STm = &(STp->modes[STp->current_mode]);
3262 STps = &(STp->ps[STp->partition]);
3265 * If we are in the middle of error recovery, don't let anyone
3266 * else try and use this device. Also, if error recovery fails, it
3267 * may try and take the device offline, in which case all further
3268 * access to the device is prohibited.
3270 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p, file);
3271 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3275 cmd_type = _IOC_TYPE(cmd_in);
3276 cmd_nr = _IOC_NR(cmd_in);
3278 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3281 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3286 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3292 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3294 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3298 if (!STm->defined &&
3299 (mtc.mt_op != MTSETDRVBUFFER &&
3300 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3305 if (!STp->pos_unknown) {
3307 if (STps->eof == ST_FM_HIT) {
3308 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3309 mtc.mt_op == MTEOM) {
3311 if (STps->drv_file >= 0)
3312 STps->drv_file += 1;
3313 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3315 if (STps->drv_file >= 0)
3316 STps->drv_file += 1;
3320 if (mtc.mt_op == MTSEEK) {
3321 /* Old position must be restored if partition will be
3323 i = !STp->can_partitions ||
3324 (STp->new_partition != STp->partition);
3326 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3327 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3328 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3329 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3330 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3331 mtc.mt_op == MTCOMPRESSION;
3333 i = flush_buffer(STp, i);
3338 if (STps->rw == ST_WRITING &&
3339 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3340 mtc.mt_op == MTSEEK ||
3341 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3342 i = st_int_ioctl(STp, MTWEOF, 1);
3347 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3354 * If there was a bus reset, block further access
3355 * to this device. If the user wants to rewind the tape,
3356 * then reset the flag and allow access again.
3358 if (mtc.mt_op != MTREW &&
3359 mtc.mt_op != MTOFFL &&
3360 mtc.mt_op != MTRETEN &&
3361 mtc.mt_op != MTERASE &&
3362 mtc.mt_op != MTSEEK &&
3363 mtc.mt_op != MTEOM) {
3368 /* remove this when the midlevel properly clears was_reset */
3369 STp->device->was_reset = 0;
3372 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3373 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3374 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3375 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3377 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3378 do_door_lock(STp, 0); /* Ignore result! */
3380 if (mtc.mt_op == MTSETDRVBUFFER &&
3381 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3382 retval = st_set_options(STp, mtc.mt_count);
3386 if (mtc.mt_op == MTSETPART) {
3387 if (!STp->can_partitions ||
3388 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3392 if (mtc.mt_count >= STp->nbr_partitions &&
3393 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3397 if (mtc.mt_count >= STp->nbr_partitions) {
3401 STp->new_partition = mtc.mt_count;
3406 if (mtc.mt_op == MTMKPART) {
3407 if (!STp->can_partitions) {
3411 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3412 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3416 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3417 STp->ps[i].rw = ST_IDLE;
3418 STp->ps[i].at_sm = 0;
3419 STp->ps[i].last_block_valid = 0;
3421 STp->partition = STp->new_partition = 0;
3422 STp->nbr_partitions = 1; /* Bad guess ?-) */
3423 STps->drv_block = STps->drv_file = 0;
3428 if (mtc.mt_op == MTSEEK) {
3429 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3430 if (!STp->can_partitions)
3431 STp->ps[0].rw = ST_IDLE;
3436 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3437 retval = do_load_unload(STp, file, 0);
3441 if (mtc.mt_op == MTLOAD) {
3442 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3446 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3447 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3451 if (STp->can_partitions && STp->ready == ST_READY &&
3452 (i = switch_partition(STp)) < 0) {
3457 if (mtc.mt_op == MTCOMPRESSION)
3458 retval = st_compression(STp, (mtc.mt_count & 1));
3460 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3463 if (!STm->defined) {
3468 if ((i = flush_buffer(STp, 0)) < 0) {
3472 if (STp->can_partitions &&
3473 (i = switch_partition(STp)) < 0) {
3478 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3479 struct mtget mt_status;
3481 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3486 mt_status.mt_type = STp->tape_type;
3487 mt_status.mt_dsreg =
3488 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3489 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3490 mt_status.mt_blkno = STps->drv_block;
3491 mt_status.mt_fileno = STps->drv_file;
3492 if (STp->block_size != 0) {
3493 if (STps->rw == ST_WRITING)
3494 mt_status.mt_blkno +=
3495 (STp->buffer)->buffer_bytes / STp->block_size;
3496 else if (STps->rw == ST_READING)
3497 mt_status.mt_blkno -=
3498 ((STp->buffer)->buffer_bytes +
3499 STp->block_size - 1) / STp->block_size;
3502 mt_status.mt_gstat = 0;
3503 if (STp->drv_write_prot)
3504 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3505 if (mt_status.mt_blkno == 0) {
3506 if (mt_status.mt_fileno == 0)
3507 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3509 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3511 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3512 mt_status.mt_resid = STp->partition;
3513 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3514 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3515 else if (STps->eof >= ST_EOM_OK)
3516 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3517 if (STp->density == 1)
3518 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3519 else if (STp->density == 2)
3520 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3521 else if (STp->density == 3)
3522 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3523 if (STp->ready == ST_READY)
3524 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3525 if (STp->ready == ST_NO_TAPE)
3526 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3528 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3529 if (STm->do_async_writes ||
3530 (STm->do_buffer_writes && STp->block_size != 0) ||
3531 STp->drv_buffer != 0)
3532 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3533 if (STp->cleaning_req)
3534 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3536 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3542 STp->recover_reg = 0; /* Clear after read */
3545 } /* End of MTIOCGET */
3546 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3547 struct mtpos mt_pos;
3548 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3552 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3556 mt_pos.mt_blkno = blk;
3557 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3562 mutex_unlock(&STp->lock);
3564 case SCSI_IOCTL_GET_IDLUN:
3565 case SCSI_IOCTL_GET_BUS_NUMBER:
3568 if ((cmd_in == SG_IO ||
3569 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3570 cmd_in == CDROM_SEND_PACKET) &&
3571 !capable(CAP_SYS_RAWIO))
3574 i = scsi_cmd_ioctl(file, STp->disk->queue,
3575 STp->disk, cmd_in, p);
3580 retval = scsi_ioctl(STp->device, cmd_in, p);
3581 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3582 STp->rew_at_close = 0;
3583 STp->ready = ST_NO_TAPE;
3588 mutex_unlock(&STp->lock);
3592 #ifdef CONFIG_COMPAT
3593 static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3595 struct scsi_tape *STp = file->private_data;
3596 struct scsi_device *sdev = STp->device;
3597 int ret = -ENOIOCTLCMD;
3598 if (sdev->host->hostt->compat_ioctl) {
3600 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3609 /* Try to allocate a new tape buffer. Calling function must not hold
3611 static struct st_buffer *
3612 new_tape_buffer(int from_initialization, int need_dma, int max_sg)
3616 struct st_buffer *tb;
3618 if (from_initialization)
3619 priority = GFP_ATOMIC;
3621 priority = GFP_KERNEL;
3623 i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3624 max_sg * sizeof(struct st_buf_fragment);
3625 tb = kzalloc(i, priority);
3627 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3630 tb->frp_segs = tb->orig_frp_segs = 0;
3631 tb->use_sg = max_sg;
3632 tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
3635 tb->buffer_size = got;
3636 sg_init_table(tb->sg, max_sg);
3642 /* Try to allocate enough space in the tape buffer */
3643 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3645 int segs, nbr, max_segs, b_size, order, got;
3648 if (new_size <= STbuffer->buffer_size)
3651 if (STbuffer->buffer_size <= PAGE_SIZE)
3652 normalize_buffer(STbuffer); /* Avoid extra segment */
3654 max_segs = STbuffer->use_sg;
3655 nbr = max_segs - STbuffer->frp_segs;
3659 priority = GFP_KERNEL | __GFP_NOWARN;
3661 priority |= GFP_DMA;
3662 for (b_size = PAGE_SIZE, order=0; order <= 6 &&
3663 b_size < new_size - STbuffer->buffer_size;
3664 order++, b_size *= 2)
3667 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3668 segs < max_segs && got < new_size;) {
3669 STbuffer->frp[segs].page = alloc_pages(priority, order);
3670 if (STbuffer->frp[segs].page == NULL) {
3671 if (new_size - got <= (max_segs - segs) * b_size / 2) {
3672 b_size /= 2; /* Large enough for the rest of the buffers */
3676 DEB(STbuffer->buffer_size = got);
3677 normalize_buffer(STbuffer);
3680 STbuffer->frp[segs].length = b_size;
3681 STbuffer->frp_segs += 1;
3683 STbuffer->buffer_size = got;
3684 if (STbuffer->cleared)
3685 memset(page_address(STbuffer->frp[segs].page), 0, b_size);
3688 STbuffer->b_data = page_address(STbuffer->frp[0].page);
3694 /* Make sure that no data from previous user is in the internal buffer */
3695 static void clear_buffer(struct st_buffer * st_bp)
3699 for (i=0; i < st_bp->frp_segs; i++)
3700 memset(page_address(st_bp->frp[i].page), 0, st_bp->frp[i].length);
3705 /* Release the extra buffer */
3706 static void normalize_buffer(struct st_buffer * STbuffer)
3710 for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3711 order = get_order(STbuffer->frp[i].length);
3712 __free_pages(STbuffer->frp[i].page, order);
3713 STbuffer->buffer_size -= STbuffer->frp[i].length;
3715 STbuffer->frp_segs = STbuffer->orig_frp_segs;
3716 STbuffer->frp_sg_current = 0;
3717 STbuffer->sg_segs = 0;
3721 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3722 negative error code. */
3723 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3725 int i, cnt, res, offset;
3727 for (i = 0, offset = st_bp->buffer_bytes;
3728 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3729 offset -= st_bp->frp[i].length;
3730 if (i == st_bp->frp_segs) { /* Should never happen */
3731 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3734 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3735 cnt = st_bp->frp[i].length - offset < do_count ?
3736 st_bp->frp[i].length - offset : do_count;
3737 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3741 st_bp->buffer_bytes += cnt;
3745 if (do_count) /* Should never happen */
3752 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3753 negative error code. */
3754 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3756 int i, cnt, res, offset;
3758 for (i = 0, offset = st_bp->read_pointer;
3759 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3760 offset -= st_bp->frp[i].length;
3761 if (i == st_bp->frp_segs) { /* Should never happen */
3762 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3765 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3766 cnt = st_bp->frp[i].length - offset < do_count ?
3767 st_bp->frp[i].length - offset : do_count;
3768 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3772 st_bp->buffer_bytes -= cnt;
3773 st_bp->read_pointer += cnt;
3777 if (do_count) /* Should never happen */
3784 /* Move data towards start of buffer */
3785 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3787 int src_seg, dst_seg, src_offset = 0, dst_offset;
3793 total=st_bp->buffer_bytes - offset;
3794 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3795 src_offset = offset;
3796 if (src_offset < st_bp->frp[src_seg].length)
3798 offset -= st_bp->frp[src_seg].length;
3801 st_bp->buffer_bytes = st_bp->read_pointer = total;
3802 for (dst_seg=dst_offset=0; total > 0; ) {
3803 count = min(st_bp->frp[dst_seg].length - dst_offset,
3804 st_bp->frp[src_seg].length - src_offset);
3805 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3806 page_address(st_bp->frp[src_seg].page) + src_offset, count);
3807 src_offset += count;
3808 if (src_offset >= st_bp->frp[src_seg].length) {
3812 dst_offset += count;
3813 if (dst_offset >= st_bp->frp[dst_seg].length) {
3822 /* Fill the s/g list up to the length required for this transfer */
3823 static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
3827 struct scatterlist *sg;
3828 struct st_buf_fragment *frp;
3830 if (length == STbp->frp_sg_current)
3831 return; /* work already done */
3833 sg = &(STbp->sg[0]);
3835 for (i=count=0; count < length; i++) {
3836 if (length - count > frp[i].length)
3837 sg_set_page(&sg[i], frp[i].page, frp[i].length, 0);
3839 sg_set_page(&sg[i], frp[i].page, length - count, 0);
3840 count += sg[i].length;
3843 STbp->frp_sg_current = length;
3847 /* Validate the options from command line or module parameters */
3848 static void validate_options(void)
3851 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3852 if (max_sg_segs >= ST_FIRST_SG)
3853 st_max_sg_segs = max_sg_segs;
3857 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3859 static int __init st_setup(char *str)
3861 int i, len, ints[5];
3864 stp = get_options(str, ARRAY_SIZE(ints), ints);
3867 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3869 *parms[i].val = ints[i + 1];
3871 while (stp != NULL) {
3872 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3873 len = strlen(parms[i].name);
3874 if (!strncmp(stp, parms[i].name, len) &&
3875 (*(stp + len) == ':' || *(stp + len) == '=')) {
3878 simple_strtoul(stp + len + 1, NULL, 0);
3880 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3885 if (i >= ARRAY_SIZE(parms))
3886 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3888 stp = strchr(stp, ',');
3899 __setup("st=", st_setup);
3903 static const struct file_operations st_fops =
3905 .owner = THIS_MODULE,
3908 .unlocked_ioctl = st_ioctl,
3909 #ifdef CONFIG_COMPAT
3910 .compat_ioctl = st_compat_ioctl,
3914 .release = st_release,
3917 static int st_probe(struct device *dev)
3919 struct scsi_device *SDp = to_scsi_device(dev);
3920 struct gendisk *disk = NULL;
3921 struct cdev *cdev = NULL;
3922 struct scsi_tape *tpnt = NULL;
3923 struct st_modedef *STm;
3924 struct st_partstat *STps;
3925 struct st_buffer *buffer;
3926 int i, j, mode, dev_num, error;
3929 if (SDp->type != TYPE_TAPE)
3931 if ((stp = st_incompatible(SDp))) {
3932 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
3933 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3937 i = min(SDp->request_queue->max_hw_segments,
3938 SDp->request_queue->max_phys_segments);
3939 if (st_max_sg_segs < i)
3941 buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i);
3942 if (buffer == NULL) {
3944 "st: Can't allocate new tape buffer. Device not attached.\n");
3948 disk = alloc_disk(1);
3950 printk(KERN_ERR "st: out of memory. Device not attached.\n");
3951 goto out_buffer_free;
3954 write_lock(&st_dev_arr_lock);
3955 if (st_nr_dev >= st_dev_max) {
3956 struct scsi_tape **tmp_da;
3959 tmp_dev_max = max(st_nr_dev * 2, 8);
3960 if (tmp_dev_max > ST_MAX_TAPES)
3961 tmp_dev_max = ST_MAX_TAPES;
3962 if (tmp_dev_max <= st_nr_dev) {
3963 write_unlock(&st_dev_arr_lock);
3964 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
3969 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
3970 if (tmp_da == NULL) {
3971 write_unlock(&st_dev_arr_lock);
3972 printk(KERN_ERR "st: Can't extend device array.\n");
3976 if (scsi_tapes != NULL) {
3977 memcpy(tmp_da, scsi_tapes,
3978 st_dev_max * sizeof(struct scsi_tape *));
3981 scsi_tapes = tmp_da;
3983 st_dev_max = tmp_dev_max;
3986 for (i = 0; i < st_dev_max; i++)
3987 if (scsi_tapes[i] == NULL)
3989 if (i >= st_dev_max)
3990 panic("scsi_devices corrupt (st)");
3992 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
3994 write_unlock(&st_dev_arr_lock);
3995 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
3998 kref_init(&tpnt->kref);
4000 sprintf(disk->disk_name, "st%d", i);
4001 disk->private_data = &tpnt->driver;
4002 disk->queue = SDp->request_queue;
4003 tpnt->driver = &st_template;
4004 scsi_tapes[i] = tpnt;
4008 if (SDp->scsi_level <= 2)
4009 tpnt->tape_type = MT_ISSCSI1;
4011 tpnt->tape_type = MT_ISSCSI2;
4013 tpnt->buffer = buffer;
4014 tpnt->buffer->last_SRpnt = NULL;
4019 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
4020 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4021 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4023 tpnt->do_auto_lock = ST_AUTO_LOCK;
4024 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4025 tpnt->can_partitions = 0;
4026 tpnt->two_fm = ST_TWO_FM;
4027 tpnt->fast_mteom = ST_FAST_MTEOM;
4028 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4029 tpnt->sili = ST_SILI;
4030 tpnt->immediate = ST_NOWAIT;
4031 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
4032 tpnt->partition = 0;
4033 tpnt->new_partition = 0;
4034 tpnt->nbr_partitions = 0;
4035 tpnt->device->timeout = ST_TIMEOUT;
4036 tpnt->long_timeout = ST_LONG_TIMEOUT;
4037 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4039 for (i = 0; i < ST_NBR_MODES; i++) {
4040 STm = &(tpnt->modes[i]);
4042 STm->sysv = ST_SYSV;
4043 STm->defaults_for_writes = 0;
4044 STm->do_async_writes = ST_ASYNC_WRITES;
4045 STm->do_buffer_writes = ST_BUFFER_WRITES;
4046 STm->do_read_ahead = ST_READ_AHEAD;
4047 STm->default_compression = ST_DONT_TOUCH;
4048 STm->default_blksize = (-1); /* No forced size */
4049 STm->default_density = (-1); /* No forced density */
4052 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4053 STps = &(tpnt->ps[i]);
4055 STps->eof = ST_NOEOF;
4057 STps->last_block_valid = 0;
4058 STps->drv_block = (-1);
4059 STps->drv_file = (-1);
4062 tpnt->current_mode = 0;
4063 tpnt->modes[0].defined = 1;
4065 tpnt->density_changed = tpnt->compression_changed =
4066 tpnt->blksize_changed = 0;
4067 mutex_init(&tpnt->lock);
4070 write_unlock(&st_dev_arr_lock);
4072 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4073 STm = &(tpnt->modes[mode]);
4074 for (j=0; j < 2; j++) {
4075 cdev = cdev_alloc();
4078 "st%d: out of memory. Device not attached.\n",
4082 cdev->owner = THIS_MODULE;
4083 cdev->ops = &st_fops;
4085 error = cdev_add(cdev,
4086 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4089 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4090 dev_num, j ? "non" : "auto", mode);
4091 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4094 STm->cdevs[j] = cdev;
4097 error = do_create_class_files(tpnt, dev_num, mode);
4102 sdev_printk(KERN_NOTICE, SDp,
4103 "Attached scsi tape %s\n", tape_name(tpnt));
4104 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4105 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4106 queue_dma_alignment(SDp->request_queue) + 1);
4111 for (mode=0; mode < ST_NBR_MODES; mode++) {
4112 STm = &(tpnt->modes[mode]);
4113 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4115 for (j=0; j < 2; j++) {
4116 if (STm->cdevs[j]) {
4117 if (cdev == STm->cdevs[j])
4119 device_destroy(st_sysfs_class,
4120 MKDEV(SCSI_TAPE_MAJOR,
4121 TAPE_MINOR(i, mode, j)));
4122 cdev_del(STm->cdevs[j]);
4128 write_lock(&st_dev_arr_lock);
4129 scsi_tapes[dev_num] = NULL;
4131 write_unlock(&st_dev_arr_lock);
4142 static int st_remove(struct device *dev)
4144 struct scsi_device *SDp = to_scsi_device(dev);
4145 struct scsi_tape *tpnt;
4148 write_lock(&st_dev_arr_lock);
4149 for (i = 0; i < st_dev_max; i++) {
4150 tpnt = scsi_tapes[i];
4151 if (tpnt != NULL && tpnt->device == SDp) {
4152 scsi_tapes[i] = NULL;
4154 write_unlock(&st_dev_arr_lock);
4155 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4157 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4158 for (j=0; j < 2; j++) {
4159 device_destroy(st_sysfs_class,
4160 MKDEV(SCSI_TAPE_MAJOR,
4161 TAPE_MINOR(i, mode, j)));
4162 cdev_del(tpnt->modes[mode].cdevs[j]);
4163 tpnt->modes[mode].cdevs[j] = NULL;
4167 mutex_lock(&st_ref_mutex);
4168 kref_put(&tpnt->kref, scsi_tape_release);
4169 mutex_unlock(&st_ref_mutex);
4174 write_unlock(&st_dev_arr_lock);
4179 * scsi_tape_release - Called to free the Scsi_Tape structure
4180 * @kref: pointer to embedded kref
4182 * st_ref_mutex must be held entering this routine. Because it is
4183 * called on last put, you should always use the scsi_tape_get()
4184 * scsi_tape_put() helpers which manipulate the semaphore directly
4185 * and never do a direct kref_put().
4187 static void scsi_tape_release(struct kref *kref)
4189 struct scsi_tape *tpnt = to_scsi_tape(kref);
4190 struct gendisk *disk = tpnt->disk;
4192 tpnt->device = NULL;
4195 tpnt->buffer->orig_frp_segs = 0;
4196 normalize_buffer(tpnt->buffer);
4197 kfree(tpnt->buffer);
4200 disk->private_data = NULL;
4206 static int __init init_st(void)
4212 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4213 verstr, st_fixed_buffer_size, st_max_sg_segs);
4215 st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
4216 if (IS_ERR(st_sysfs_class)) {
4217 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4218 return PTR_ERR(st_sysfs_class);
4221 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4222 ST_MAX_TAPE_ENTRIES, "st");
4224 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4229 err = scsi_register_driver(&st_template.gendrv);
4233 err = do_create_sysfs_files();
4240 scsi_unregister_driver(&st_template.gendrv);
4242 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4243 ST_MAX_TAPE_ENTRIES);
4245 class_destroy(st_sysfs_class);
4249 static void __exit exit_st(void)
4251 do_remove_sysfs_files();
4252 scsi_unregister_driver(&st_template.gendrv);
4253 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4254 ST_MAX_TAPE_ENTRIES);
4255 class_destroy(st_sysfs_class);
4257 printk(KERN_INFO "st: Unloaded.\n");
4260 module_init(init_st);
4261 module_exit(exit_st);
4264 /* The sysfs driver interface. Read-only at the moment */
4265 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4267 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4269 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4271 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4273 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4275 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4277 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4279 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4281 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4283 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4285 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4287 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4289 static int do_create_sysfs_files(void)
4291 struct device_driver *sysfs = &st_template.gendrv;
4294 err = driver_create_file(sysfs, &driver_attr_try_direct_io);
4297 err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
4299 goto err_try_direct_io;
4300 err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
4302 goto err_attr_fixed_buf;
4303 err = driver_create_file(sysfs, &driver_attr_version);
4305 goto err_attr_max_sg;
4310 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4312 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4314 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4318 static void do_remove_sysfs_files(void)
4320 struct device_driver *sysfs = &st_template.gendrv;
4322 driver_remove_file(sysfs, &driver_attr_version);
4323 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4324 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4325 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4329 /* The sysfs simple class interface */
4331 st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4333 struct st_modedef *STm = dev_get_drvdata(dev);
4336 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4340 DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4343 st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
4345 struct st_modedef *STm = dev_get_drvdata(dev);
4348 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4352 DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4355 st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
4357 struct st_modedef *STm = dev_get_drvdata(dev);
4361 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4362 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4366 DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4369 st_defcompression_show(struct device *dev, struct device_attribute *attr,
4372 struct st_modedef *STm = dev_get_drvdata(dev);
4375 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4379 DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4382 st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
4384 struct st_modedef *STm = dev_get_drvdata(dev);
4385 struct scsi_tape *STp;
4389 for (i=0; i < st_dev_max; i++) {
4390 for (j=0; j < ST_NBR_MODES; j++)
4391 if (&scsi_tapes[i]->modes[j] == STm)
4393 if (j < ST_NBR_MODES)
4396 if (i == st_dev_max)
4397 return 0; /* should never happen */
4399 STp = scsi_tapes[i];
4401 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4402 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4403 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4404 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4405 options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4406 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4407 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4408 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4409 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4410 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4411 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4412 options |= STm->sysv ? MT_ST_SYSV : 0;
4413 options |= STp->immediate ? MT_ST_NOWAIT : 0;
4414 options |= STp->sili ? MT_ST_SILI : 0;
4416 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4420 DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
4422 static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4426 struct device *st_class_member;
4428 for (rew=0; rew < 2; rew++) {
4429 /* Make sure that the minor numbers corresponding to the four
4430 first modes always get the same names */
4431 i = mode << (4 - ST_NBR_MODE_BITS);
4432 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4433 STp->disk->disk_name, st_formats[i]);
4435 device_create_drvdata(st_sysfs_class,
4436 &STp->device->sdev_gendev,
4437 MKDEV(SCSI_TAPE_MAJOR,
4442 if (IS_ERR(st_class_member)) {
4443 printk(KERN_WARNING "st%d: device_create failed\n",
4445 error = PTR_ERR(st_class_member);
4449 error = device_create_file(st_class_member,
4451 if (error) goto out;
4452 error = device_create_file(st_class_member,
4453 &dev_attr_default_blksize);
4454 if (error) goto out;
4455 error = device_create_file(st_class_member,
4456 &dev_attr_default_density);
4457 if (error) goto out;
4458 error = device_create_file(st_class_member,
4459 &dev_attr_default_compression);
4460 if (error) goto out;
4461 error = device_create_file(st_class_member,
4463 if (error) goto out;
4465 if (mode == 0 && rew == 0) {
4466 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4467 &st_class_member->kobj,
4471 "st%d: Can't create sysfs link from SCSI device.\n",
4484 /* The following functions may be useful for a larger audience. */
4485 static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4486 unsigned long uaddr, size_t count, int rw)
4488 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4489 unsigned long start = uaddr >> PAGE_SHIFT;
4490 const int nr_pages = end - start;
4492 struct page **pages;
4494 /* User attempted Overflow! */
4495 if ((uaddr + count) < uaddr)
4499 if (nr_pages > max_pages)
4506 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4509 /* Try to fault in all of the necessary pages */
4510 down_read(¤t->mm->mmap_sem);
4511 /* rw==READ means read from drive, write into memory area */
4512 res = get_user_pages(
4518 0, /* don't force */
4521 up_read(¤t->mm->mmap_sem);
4523 /* Errors and no page mapped should return here */
4527 for (i=0; i < nr_pages; i++) {
4528 /* FIXME: flush superflous for rw==READ,
4529 * probably wrong function for rw==WRITE
4531 flush_dcache_page(pages[i]);
4534 /* Populate the scatter/gather list */
4535 sg_set_page(&sgl[0], pages[0], 0, uaddr & ~PAGE_MASK);
4537 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4538 count -= sgl[0].length;
4539 for (i=1; i < nr_pages ; i++) {
4540 sg_set_page(&sgl[i], pages[i],
4541 count < PAGE_SIZE ? count : PAGE_SIZE, 0);;
4546 sgl[0].length = count;
4554 for (j=0; j < res; j++)
4555 page_cache_release(pages[j]);
4563 /* And unmap them... */
4564 static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4569 for (i=0; i < nr_pages; i++) {
4570 struct page *page = sg_page(&sgl[i]);
4574 /* FIXME: cache flush missing for rw==READ
4575 * FIXME: call the correct reference counting function
4577 page_cache_release(page);