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 - 2007 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 = "20070203";
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>
42 #include <asm/uaccess.h>
44 #include <asm/system.h>
46 #include <scsi/scsi.h>
47 #include <scsi/scsi_dbg.h>
48 #include <scsi/scsi_device.h>
49 #include <scsi/scsi_driver.h>
50 #include <scsi/scsi_eh.h>
51 #include <scsi/scsi_host.h>
52 #include <scsi/scsi_ioctl.h>
56 /* The driver prints some debugging information on the console if DEBUG
57 is defined and non-zero. */
61 /* The message level for the debug messages is currently set to KERN_NOTICE
62 so that people can easily see the messages. Later when the debugging messages
63 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
64 #define ST_DEB_MSG KERN_NOTICE
66 #define DEBC(a) if (debugging) { a ; }
72 #define ST_KILOBYTE 1024
74 #include "st_options.h"
77 static int buffer_kbs;
78 static int max_sg_segs;
79 static int try_direct_io = TRY_DIRECT_IO;
80 static int try_rdio = 1;
81 static int try_wdio = 1;
83 static int st_dev_max;
86 static struct class *st_sysfs_class;
88 MODULE_AUTHOR("Kai Makisara");
89 MODULE_DESCRIPTION("SCSI tape (st) driver");
90 MODULE_LICENSE("GPL");
91 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
93 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
94 * of sysfs parameters (which module_param doesn't yet support).
95 * Sysfs parameters defined explicitly later.
97 module_param_named(buffer_kbs, buffer_kbs, int, 0);
98 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
99 module_param_named(max_sg_segs, max_sg_segs, int, 0);
100 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
101 module_param_named(try_direct_io, try_direct_io, int, 0);
102 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
104 /* Extra parameters for testing */
105 module_param_named(try_rdio, try_rdio, int, 0);
106 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
107 module_param_named(try_wdio, try_wdio, int, 0);
108 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
111 static int write_threshold_kbs; /* retained for compatibility */
112 static struct st_dev_parm {
115 } parms[] __initdata = {
117 "buffer_kbs", &buffer_kbs
119 { /* Retained for compatibility with 2.4 */
120 "write_threshold_kbs", &write_threshold_kbs
126 "try_direct_io", &try_direct_io
131 /* Restrict the number of modes so that names for all are assigned */
132 #if ST_NBR_MODES > 16
133 #error "Maximum number of modes is 16"
135 /* Bit reversed order to get same names for same minors with all
137 static const char *st_formats[] = {
138 "", "r", "k", "s", "l", "t", "o", "u",
139 "m", "v", "p", "x", "a", "y", "q", "z"};
141 /* The default definitions have been moved to st_options.h */
143 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
145 /* The buffer size should fit into the 24 bits for length in the
146 6-byte SCSI read and write commands. */
147 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
148 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
151 static int debugging = DEBUG;
153 #define MAX_RETRIES 0
154 #define MAX_WRITE_RETRIES 0
155 #define MAX_READY_RETRIES 0
156 #define NO_TAPE NOT_READY
158 #define ST_TIMEOUT (900 * HZ)
159 #define ST_LONG_TIMEOUT (14000 * HZ)
161 /* Remove mode bits and auto-rewind bit (7) */
162 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
163 (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
164 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
166 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
167 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
168 (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
170 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
172 #define SET_DENS_AND_BLK 0x10001
174 static DEFINE_RWLOCK(st_dev_arr_lock);
176 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
177 static int st_max_sg_segs = ST_MAX_SG;
179 static struct scsi_tape **scsi_tapes = NULL;
181 static int modes_defined;
183 static struct st_buffer *new_tape_buffer(int, int, int);
184 static int enlarge_buffer(struct st_buffer *, int, int);
185 static void normalize_buffer(struct st_buffer *);
186 static int append_to_buffer(const char __user *, struct st_buffer *, int);
187 static int from_buffer(struct st_buffer *, char __user *, int);
188 static void move_buffer_data(struct st_buffer *, int);
189 static void buf_to_sg(struct st_buffer *, unsigned int);
191 static int sgl_map_user_pages(struct scatterlist *, const unsigned int,
192 unsigned long, size_t, int);
193 static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int);
195 static int st_probe(struct device *);
196 static int st_remove(struct device *);
198 static int do_create_driverfs_files(void);
199 static void do_remove_driverfs_files(void);
200 static int do_create_class_files(struct scsi_tape *, int, int);
202 static struct scsi_driver st_template = {
203 .owner = THIS_MODULE,
211 static int st_compression(struct scsi_tape *, int);
213 static int find_partition(struct scsi_tape *);
214 static int switch_partition(struct scsi_tape *);
216 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
218 static void scsi_tape_release(struct kref *);
220 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
222 static DEFINE_MUTEX(st_ref_mutex);
225 #include "osst_detect.h"
226 #ifndef SIGS_FROM_OSST
227 #define SIGS_FROM_OSST \
228 {"OnStream", "SC-", "", "osst"}, \
229 {"OnStream", "DI-", "", "osst"}, \
230 {"OnStream", "DP-", "", "osst"}, \
231 {"OnStream", "USB", "", "osst"}, \
232 {"OnStream", "FW-", "", "osst"}
235 static struct scsi_tape *scsi_tape_get(int dev)
237 struct scsi_tape *STp = NULL;
239 mutex_lock(&st_ref_mutex);
240 write_lock(&st_dev_arr_lock);
242 if (dev < st_dev_max && scsi_tapes != NULL)
243 STp = scsi_tapes[dev];
246 kref_get(&STp->kref);
251 if (scsi_device_get(STp->device))
257 kref_put(&STp->kref, scsi_tape_release);
260 write_unlock(&st_dev_arr_lock);
261 mutex_unlock(&st_ref_mutex);
265 static void scsi_tape_put(struct scsi_tape *STp)
267 struct scsi_device *sdev = STp->device;
269 mutex_lock(&st_ref_mutex);
270 kref_put(&STp->kref, scsi_tape_release);
271 scsi_device_put(sdev);
272 mutex_unlock(&st_ref_mutex);
275 struct st_reject_data {
279 char *driver_hint; /* Name of the correct driver, NULL if unknown */
282 static struct st_reject_data reject_list[] = {
283 /* {"XXX", "Yy-", "", NULL}, example */
287 /* If the device signature is on the list of incompatible drives, the
288 function returns a pointer to the name of the correct driver (if known) */
289 static char * st_incompatible(struct scsi_device* SDp)
291 struct st_reject_data *rp;
293 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
294 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
295 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
296 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
298 return rp->driver_hint;
306 static inline char *tape_name(struct scsi_tape *tape)
308 return tape->disk->disk_name;
312 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
315 const u8 *sense = SRpnt->sense;
317 s->have_sense = scsi_normalize_sense(SRpnt->sense,
318 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
324 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
325 switch (sense[0] & 0x7f) {
330 s->flags = sense[2] & 0xe0;
336 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
337 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
344 /* Convert the result to success code */
345 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
347 int result = SRpnt->result;
349 DEB(const char *stp;)
350 char *name = tape_name(STp);
351 struct st_cmdstatus *cmdstatp;
356 cmdstatp = &STp->buffer->cmdstat;
357 st_analyze_sense(SRpnt, cmdstatp);
359 if (cmdstatp->have_sense)
360 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
366 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
368 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
369 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
370 if (cmdstatp->have_sense)
371 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
373 if (!debugging) { /* Abnormal conditions for tape */
374 if (!cmdstatp->have_sense)
376 "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
377 name, result, suggestion(result),
378 driver_byte(result) & DRIVER_MASK, host_byte(result));
379 else if (cmdstatp->have_sense &&
381 scode != RECOVERED_ERROR &&
382 /* scode != UNIT_ATTENTION && */
383 scode != BLANK_CHECK &&
384 scode != VOLUME_OVERFLOW &&
385 SRpnt->cmd[0] != MODE_SENSE &&
386 SRpnt->cmd[0] != TEST_UNIT_READY) {
388 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
392 if (cmdstatp->fixed_format &&
393 STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */
394 if (STp->cln_sense_value)
395 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
396 STp->cln_sense_mask) == STp->cln_sense_value);
398 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
399 STp->cln_sense_mask) != 0);
401 if (cmdstatp->have_sense &&
402 cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
403 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
405 STp->pos_unknown |= STp->device->was_reset;
407 if (cmdstatp->have_sense &&
408 scode == RECOVERED_ERROR
409 #if ST_RECOVERED_WRITE_FATAL
410 && SRpnt->cmd[0] != WRITE_6
411 && SRpnt->cmd[0] != WRITE_FILEMARKS
414 STp->recover_count++;
419 if (SRpnt->cmd[0] == READ_6)
421 else if (SRpnt->cmd[0] == WRITE_6)
425 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
429 if (cmdstatp->flags == 0)
436 /* Wakeup from interrupt */
437 static void st_sleep_done(void *data, char *sense, int result, int resid)
439 struct st_request *SRpnt = data;
440 struct scsi_tape *STp = SRpnt->stp;
442 memcpy(SRpnt->sense, sense, SCSI_SENSE_BUFFERSIZE);
443 (STp->buffer)->cmdstat.midlevel_result = SRpnt->result = result;
444 DEB( STp->write_pending = 0; )
447 complete(SRpnt->waiting);
450 static struct st_request *st_allocate_request(void)
452 return kzalloc(sizeof(struct st_request), GFP_KERNEL);
455 static void st_release_request(struct st_request *streq)
460 /* Do the scsi command. Waits until command performed if do_wait is true.
461 Otherwise write_behind_check() is used to check that the command
463 static struct st_request *
464 st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
465 int bytes, int direction, int timeout, int retries, int do_wait)
467 struct completion *waiting;
469 /* if async, make sure there's no command outstanding */
470 if (!do_wait && ((STp->buffer)->last_SRpnt)) {
471 printk(KERN_ERR "%s: Async command already active.\n",
473 if (signal_pending(current))
474 (STp->buffer)->syscall_result = (-EINTR);
476 (STp->buffer)->syscall_result = (-EBUSY);
481 SRpnt = st_allocate_request();
483 DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n",
485 if (signal_pending(current))
486 (STp->buffer)->syscall_result = (-EINTR);
488 (STp->buffer)->syscall_result = (-EBUSY);
494 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
495 which IO is outstanding. It's nulled out when the IO completes. */
497 (STp->buffer)->last_SRpnt = SRpnt;
499 waiting = &STp->wait;
500 init_completion(waiting);
501 SRpnt->waiting = waiting;
503 if (!STp->buffer->do_dio)
504 buf_to_sg(STp->buffer, bytes);
506 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
507 STp->buffer->cmdstat.have_sense = 0;
508 STp->buffer->syscall_result = 0;
510 if (scsi_execute_async(STp->device, cmd, COMMAND_SIZE(cmd[0]), direction,
511 &((STp->buffer)->sg[0]), bytes, (STp->buffer)->sg_segs,
512 timeout, retries, SRpnt, st_sleep_done, GFP_KERNEL)) {
513 /* could not allocate the buffer or request was too large */
514 (STp->buffer)->syscall_result = (-EBUSY);
515 (STp->buffer)->last_SRpnt = NULL;
518 wait_for_completion(waiting);
519 SRpnt->waiting = NULL;
520 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
527 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
528 write has been correct but EOM early warning reached, -EIO if write ended in
529 error or zero if write successful. Asynchronous writes are used only in
530 variable block mode. */
531 static int write_behind_check(struct scsi_tape * STp)
534 struct st_buffer *STbuffer;
535 struct st_partstat *STps;
536 struct st_cmdstatus *cmdstatp;
537 struct st_request *SRpnt;
539 STbuffer = STp->buffer;
540 if (!STbuffer->writing)
544 if (STp->write_pending)
550 wait_for_completion(&(STp->wait));
551 SRpnt = STbuffer->last_SRpnt;
552 STbuffer->last_SRpnt = NULL;
553 SRpnt->waiting = NULL;
555 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
556 st_release_request(SRpnt);
558 STbuffer->buffer_bytes -= STbuffer->writing;
559 STps = &(STp->ps[STp->partition]);
560 if (STps->drv_block >= 0) {
561 if (STp->block_size == 0)
564 STps->drv_block += STbuffer->writing / STp->block_size;
567 cmdstatp = &STbuffer->cmdstat;
568 if (STbuffer->syscall_result) {
570 if (cmdstatp->have_sense && !cmdstatp->deferred &&
571 (cmdstatp->flags & SENSE_EOM) &&
572 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
573 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
574 /* EOM at write-behind, has all data been written? */
575 if (!cmdstatp->remainder_valid ||
576 cmdstatp->uremainder64 == 0)
580 STps->drv_block = -1;
582 STbuffer->writing = 0;
584 DEB(if (debugging && retval)
585 printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n",
586 tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
592 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
593 it messes up the block number). */
594 static int cross_eof(struct scsi_tape * STp, int forward)
596 struct st_request *SRpnt;
597 unsigned char cmd[MAX_COMMAND_SIZE];
600 cmd[1] = 0x01; /* Space FileMarks */
605 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
608 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
609 tape_name(STp), forward ? "forward" : "backward"));
611 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
612 STp->device->timeout, MAX_RETRIES, 1);
614 return (STp->buffer)->syscall_result;
616 st_release_request(SRpnt);
619 if ((STp->buffer)->cmdstat.midlevel_result != 0)
620 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
621 tape_name(STp), forward ? "forward" : "backward");
623 return (STp->buffer)->syscall_result;
627 /* Flush the write buffer (never need to write if variable blocksize). */
628 static int flush_write_buffer(struct scsi_tape * STp)
630 int offset, transfer, blks;
632 unsigned char cmd[MAX_COMMAND_SIZE];
633 struct st_request *SRpnt;
634 struct st_partstat *STps;
636 result = write_behind_check(STp);
641 if (STp->dirty == 1) {
643 offset = (STp->buffer)->buffer_bytes;
644 transfer = ((offset + STp->block_size - 1) /
645 STp->block_size) * STp->block_size;
646 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
647 tape_name(STp), transfer));
649 memset((STp->buffer)->b_data + offset, 0, transfer - offset);
651 memset(cmd, 0, MAX_COMMAND_SIZE);
654 blks = transfer / STp->block_size;
659 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
660 STp->device->timeout, MAX_WRITE_RETRIES, 1);
662 return (STp->buffer)->syscall_result;
664 STps = &(STp->ps[STp->partition]);
665 if ((STp->buffer)->syscall_result != 0) {
666 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
668 if (cmdstatp->have_sense && !cmdstatp->deferred &&
669 (cmdstatp->flags & SENSE_EOM) &&
670 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
671 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
672 (!cmdstatp->remainder_valid ||
673 cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
675 (STp->buffer)->buffer_bytes = 0;
676 if (STps->drv_block >= 0)
677 STps->drv_block += blks;
680 printk(KERN_ERR "%s: Error on flush.\n",
682 STps->drv_block = (-1);
686 if (STps->drv_block >= 0)
687 STps->drv_block += blks;
689 (STp->buffer)->buffer_bytes = 0;
691 st_release_request(SRpnt);
698 /* Flush the tape buffer. The tape will be positioned correctly unless
699 seek_next is true. */
700 static int flush_buffer(struct scsi_tape *STp, int seek_next)
702 int backspace, result;
703 struct st_buffer *STbuffer;
704 struct st_partstat *STps;
706 STbuffer = STp->buffer;
709 * If there was a bus reset, block further access
712 if (STp->pos_unknown)
715 if (STp->ready != ST_READY)
717 STps = &(STp->ps[STp->partition]);
718 if (STps->rw == ST_WRITING) /* Writing */
719 return flush_write_buffer(STp);
721 if (STp->block_size == 0)
724 backspace = ((STp->buffer)->buffer_bytes +
725 (STp->buffer)->read_pointer) / STp->block_size -
726 ((STp->buffer)->read_pointer + STp->block_size - 1) /
728 (STp->buffer)->buffer_bytes = 0;
729 (STp->buffer)->read_pointer = 0;
732 if (STps->eof == ST_FM_HIT) {
733 result = cross_eof(STp, 0); /* Back over the EOF hit */
735 STps->eof = ST_NOEOF;
737 if (STps->drv_file >= 0)
742 if (!result && backspace > 0)
743 result = st_int_ioctl(STp, MTBSR, backspace);
744 } else if (STps->eof == ST_FM_HIT) {
745 if (STps->drv_file >= 0)
748 STps->eof = ST_NOEOF;
754 /* Set the mode parameters */
755 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
759 char *name = tape_name(STp);
761 if (!STp->density_changed &&
762 STm->default_density >= 0 &&
763 STm->default_density != STp->density) {
764 arg = STm->default_density;
768 arg <<= MT_ST_DENSITY_SHIFT;
769 if (!STp->blksize_changed &&
770 STm->default_blksize >= 0 &&
771 STm->default_blksize != STp->block_size) {
772 arg |= STm->default_blksize;
775 arg |= STp->block_size;
777 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
779 "%s: Can't set default block size to %d bytes and density %x.\n",
780 name, STm->default_blksize, STm->default_density);
788 /* Lock or unlock the drive door. Don't use when st_request allocated. */
789 static int do_door_lock(struct scsi_tape * STp, int do_lock)
792 DEB(char *name = tape_name(STp);)
795 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
796 DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
797 do_lock ? "L" : "Unl"));
798 retval = scsi_ioctl(STp->device, cmd, NULL);
800 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
803 STp->door_locked = ST_LOCK_FAILS;
809 /* Set the internal state after reset */
810 static void reset_state(struct scsi_tape *STp)
813 struct st_partstat *STps;
815 STp->pos_unknown = 0;
816 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
817 STps = &(STp->ps[i]);
819 STps->eof = ST_NOEOF;
821 STps->last_block_valid = 0;
822 STps->drv_block = -1;
825 if (STp->can_partitions) {
826 STp->partition = find_partition(STp);
827 if (STp->partition < 0)
829 STp->new_partition = STp->partition;
833 /* Test if the drive is ready. Returns either one of the codes below or a negative system
835 #define CHKRES_READY 0
836 #define CHKRES_NEW_SESSION 1
837 #define CHKRES_NOT_READY 2
838 #define CHKRES_NO_TAPE 3
840 #define MAX_ATTENTIONS 10
842 static int test_ready(struct scsi_tape *STp, int do_wait)
844 int attentions, waits, max_wait, scode;
845 int retval = CHKRES_READY, new_session = 0;
846 unsigned char cmd[MAX_COMMAND_SIZE];
847 struct st_request *SRpnt = NULL;
848 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
850 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
852 for (attentions=waits=0; ; ) {
853 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
854 cmd[0] = TEST_UNIT_READY;
855 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
856 STp->long_timeout, MAX_READY_RETRIES, 1);
859 retval = (STp->buffer)->syscall_result;
863 if (cmdstatp->have_sense) {
865 scode = cmdstatp->sense_hdr.sense_key;
867 if (scode == UNIT_ATTENTION) { /* New media? */
869 if (attentions < MAX_ATTENTIONS) {
879 if (scode == NOT_READY) {
880 if (waits < max_wait) {
881 if (msleep_interruptible(1000)) {
889 if ((STp->device)->scsi_level >= SCSI_2 &&
890 cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
891 retval = CHKRES_NO_TAPE;
893 retval = CHKRES_NOT_READY;
899 retval = (STp->buffer)->syscall_result;
901 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
906 st_release_request(SRpnt);
911 /* See if the drive is ready and gather information about the tape. Return values:
912 < 0 negative error code from errno.h
914 1 drive not ready (possibly no tape)
916 static int check_tape(struct scsi_tape *STp, struct file *filp)
918 int i, retval, new_session = 0, do_wait;
919 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
920 unsigned short st_flags = filp->f_flags;
921 struct st_request *SRpnt = NULL;
922 struct st_modedef *STm;
923 struct st_partstat *STps;
924 char *name = tape_name(STp);
925 struct inode *inode = filp->f_path.dentry->d_inode;
926 int mode = TAPE_MODE(inode);
928 STp->ready = ST_READY;
930 if (mode != STp->current_mode) {
931 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
932 name, STp->current_mode, mode));
934 STp->current_mode = mode;
936 STm = &(STp->modes[STp->current_mode]);
938 saved_cleaning = STp->cleaning_req;
939 STp->cleaning_req = 0;
941 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
942 retval = test_ready(STp, do_wait);
947 if (retval == CHKRES_NEW_SESSION) {
948 STp->pos_unknown = 0;
949 STp->partition = STp->new_partition = 0;
950 if (STp->can_partitions)
951 STp->nbr_partitions = 1; /* This guess will be updated later
953 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
954 STps = &(STp->ps[i]);
956 STps->eof = ST_NOEOF;
958 STps->last_block_valid = 0;
965 STp->cleaning_req |= saved_cleaning;
967 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
968 if (retval == CHKRES_NO_TAPE)
969 STp->ready = ST_NO_TAPE;
971 STp->ready = ST_NOT_READY;
973 STp->density = 0; /* Clear the erroneous "residue" */
976 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
977 STp->partition = STp->new_partition = 0;
978 STp->door_locked = ST_UNLOCKED;
979 return CHKRES_NOT_READY;
983 if (STp->omit_blklims)
984 STp->min_block = STp->max_block = (-1);
986 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
987 cmd[0] = READ_BLOCK_LIMITS;
989 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
990 STp->device->timeout, MAX_READY_RETRIES, 1);
992 retval = (STp->buffer)->syscall_result;
996 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
997 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
998 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
999 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1000 (STp->buffer)->b_data[5];
1001 if ( DEB( debugging || ) !STp->inited)
1003 "%s: Block limits %d - %d bytes.\n", name,
1004 STp->min_block, STp->max_block);
1006 STp->min_block = STp->max_block = (-1);
1007 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1012 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1013 cmd[0] = MODE_SENSE;
1016 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1017 STp->device->timeout, MAX_READY_RETRIES, 1);
1019 retval = (STp->buffer)->syscall_result;
1023 if ((STp->buffer)->syscall_result != 0) {
1024 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1025 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
1026 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */
1027 STp->drv_write_prot = 0;
1029 DEBC(printk(ST_DEB_MSG
1030 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1032 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1033 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1035 if ((STp->buffer)->b_data[3] >= 8) {
1036 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1037 STp->density = (STp->buffer)->b_data[4];
1038 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1039 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1040 DEBC(printk(ST_DEB_MSG
1041 "%s: Density %x, tape length: %x, drv buffer: %d\n",
1042 name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1043 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1046 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1048 st_release_request(SRpnt);
1052 if (STp->block_size > 0)
1053 (STp->buffer)->buffer_blocks =
1054 (STp->buffer)->buffer_size / STp->block_size;
1056 (STp->buffer)->buffer_blocks = 1;
1057 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1059 DEBC(printk(ST_DEB_MSG
1060 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1061 STp->block_size, (STp->buffer)->buffer_size,
1062 (STp->buffer)->buffer_blocks));
1064 if (STp->drv_write_prot) {
1065 STp->write_prot = 1;
1067 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1070 ((st_flags & O_ACCMODE) == O_WRONLY ||
1071 (st_flags & O_ACCMODE) == O_RDWR)) {
1077 if (STp->can_partitions && STp->nbr_partitions < 1) {
1078 /* This code is reached when the device is opened for the first time
1079 after the driver has been initialized with tape in the drive and the
1080 partition support has been enabled. */
1081 DEBC(printk(ST_DEB_MSG
1082 "%s: Updating partition number in status.\n", name));
1083 if ((STp->partition = find_partition(STp)) < 0) {
1084 retval = STp->partition;
1087 STp->new_partition = STp->partition;
1088 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1091 if (new_session) { /* Change the drive parameters for the new mode */
1092 STp->density_changed = STp->blksize_changed = 0;
1093 STp->compression_changed = 0;
1094 if (!(STm->defaults_for_writes) &&
1095 (retval = set_mode_densblk(STp, STm)) < 0)
1098 if (STp->default_drvbuffer != 0xff) {
1099 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1101 "%s: Can't set default drive buffering to %d.\n",
1102 name, STp->default_drvbuffer);
1106 return CHKRES_READY;
1113 \f/* Open the device. Needs to be called with BKL only because of incrementing the SCSI host
1115 static int st_open(struct inode *inode, struct file *filp)
1117 int i, retval = (-EIO);
1118 struct scsi_tape *STp;
1119 struct st_partstat *STps;
1120 int dev = TAPE_NR(inode);
1124 * We really want to do nonseekable_open(inode, filp); here, but some
1125 * versions of tar incorrectly call lseek on tapes and bail out if that
1126 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1128 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1130 if (!(STp = scsi_tape_get(dev)))
1133 write_lock(&st_dev_arr_lock);
1134 filp->private_data = STp;
1135 name = tape_name(STp);
1138 write_unlock(&st_dev_arr_lock);
1140 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1145 write_unlock(&st_dev_arr_lock);
1146 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1148 if (!scsi_block_when_processing_errors(STp->device)) {
1153 /* See that we have at least a one page buffer available */
1154 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1155 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1157 retval = (-EOVERFLOW);
1161 (STp->buffer)->writing = 0;
1162 (STp->buffer)->syscall_result = 0;
1164 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1167 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1168 STps = &(STp->ps[i]);
1171 STp->try_dio_now = STp->try_dio;
1172 STp->recover_count = 0;
1173 DEB( STp->nbr_waits = STp->nbr_finished = 0;
1174 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = STp->nbr_combinable = 0; )
1176 retval = check_tape(STp, filp);
1179 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1180 retval != CHKRES_READY) {
1181 if (STp->ready == NO_TAPE)
1182 retval = (-ENOMEDIUM);
1190 normalize_buffer(STp->buffer);
1198 /* Flush the tape buffer before close */
1199 static int st_flush(struct file *filp, fl_owner_t id)
1201 int result = 0, result2;
1202 unsigned char cmd[MAX_COMMAND_SIZE];
1203 struct st_request *SRpnt;
1204 struct scsi_tape *STp = filp->private_data;
1205 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1206 struct st_partstat *STps = &(STp->ps[STp->partition]);
1207 char *name = tape_name(STp);
1209 if (file_count(filp) > 1)
1212 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1213 result = flush_write_buffer(STp);
1214 if (result != 0 && result != (-ENOSPC))
1218 if (STp->can_partitions &&
1219 (result2 = switch_partition(STp)) < 0) {
1220 DEBC(printk(ST_DEB_MSG
1221 "%s: switch_partition at close failed.\n", name));
1227 DEBC( if (STp->nbr_requests)
1228 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d (%d).\n",
1229 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages, STp->nbr_combinable));
1231 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1232 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1234 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1235 name, STp->nbr_waits, STp->nbr_finished);
1238 memset(cmd, 0, MAX_COMMAND_SIZE);
1239 cmd[0] = WRITE_FILEMARKS;
1240 cmd[4] = 1 + STp->two_fm;
1242 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1243 STp->device->timeout, MAX_WRITE_RETRIES, 1);
1245 result = (STp->buffer)->syscall_result;
1249 if (STp->buffer->syscall_result == 0 ||
1250 (cmdstatp->have_sense && !cmdstatp->deferred &&
1251 (cmdstatp->flags & SENSE_EOM) &&
1252 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1253 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1254 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1255 /* Write successful at EOM */
1256 st_release_request(SRpnt);
1258 if (STps->drv_file >= 0)
1260 STps->drv_block = 0;
1265 else { /* Write error */
1266 st_release_request(SRpnt);
1268 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1273 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1275 } else if (!STp->rew_at_close) {
1276 STps = &(STp->ps[STp->partition]);
1277 if (!STm->sysv || STps->rw != ST_READING) {
1279 result = flush_buffer(STp, 0);
1280 else if (STps->eof == ST_FM_HIT) {
1281 result = cross_eof(STp, 0);
1283 if (STps->drv_file >= 0)
1285 STps->drv_block = 0;
1288 STps->eof = ST_NOEOF;
1290 } else if ((STps->eof == ST_NOEOF &&
1291 !(result = cross_eof(STp, 1))) ||
1292 STps->eof == ST_FM_HIT) {
1293 if (STps->drv_file >= 0)
1295 STps->drv_block = 0;
1301 if (STp->rew_at_close) {
1302 result2 = st_int_ioctl(STp, MTREW, 1);
1310 /* Close the device and release it. BKL is not needed: this is the only thread
1311 accessing this tape. */
1312 static int st_release(struct inode *inode, struct file *filp)
1315 struct scsi_tape *STp = filp->private_data;
1317 if (STp->door_locked == ST_LOCKED_AUTO)
1318 do_door_lock(STp, 0);
1320 normalize_buffer(STp->buffer);
1321 write_lock(&st_dev_arr_lock);
1323 write_unlock(&st_dev_arr_lock);
1329 /* The checks common to both reading and writing */
1330 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1335 * If we are in the middle of error recovery, don't let anyone
1336 * else try and use this device. Also, if error recovery fails, it
1337 * may try and take the device offline, in which case all further
1338 * access to the device is prohibited.
1340 if (!scsi_block_when_processing_errors(STp->device)) {
1345 if (STp->ready != ST_READY) {
1346 if (STp->ready == ST_NO_TAPE)
1347 retval = (-ENOMEDIUM);
1353 if (! STp->modes[STp->current_mode].defined) {
1360 * If there was a bus reset, block further access
1363 if (STp->pos_unknown) {
1373 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1378 if (STp->can_partitions &&
1379 (retval = switch_partition(STp)) < 0)
1382 if (STp->block_size == 0 && STp->max_block > 0 &&
1383 (count < STp->min_block || count > STp->max_block)) {
1388 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1389 !do_door_lock(STp, 1))
1390 STp->door_locked = ST_LOCKED_AUTO;
1397 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1398 size_t count, int is_read)
1400 int i, bufsize, retval = 0;
1401 struct st_buffer *STbp = STp->buffer;
1404 i = STp->try_dio_now && try_rdio;
1406 i = STp->try_dio_now && try_wdio;
1408 if (i && ((unsigned long)buf & queue_dma_alignment(
1409 STp->device->request_queue)) == 0) {
1410 i = sgl_map_user_pages(&(STbp->sg[0]), STbp->use_sg,
1411 (unsigned long)buf, count, (is_read ? READ : WRITE));
1414 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1417 STbp->do_dio = 0; /* fall back to buffering with any error */
1418 STbp->sg_segs = STbp->do_dio;
1419 STbp->frp_sg_current = 0;
1423 STp->nbr_pages += STbp->do_dio;
1424 for (i=1; i < STbp->do_dio; i++)
1425 if (page_to_pfn(STbp->sg[i].page) == page_to_pfn(STbp->sg[i-1].page) + 1)
1426 STp->nbr_combinable++;
1431 DEB( STp->nbr_requests++; )
1433 if (!STbp->do_dio) {
1434 if (STp->block_size)
1435 bufsize = STp->block_size > st_fixed_buffer_size ?
1436 STp->block_size : st_fixed_buffer_size;
1439 if (bufsize > STbp->buffer_size &&
1440 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1441 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1442 tape_name(STp), bufsize);
1443 retval = (-EOVERFLOW);
1446 if (STp->block_size)
1447 STbp->buffer_blocks = bufsize / STp->block_size;
1455 /* Can be called more than once after each setup_buffer() */
1456 static void release_buffering(struct scsi_tape *STp, int is_read)
1458 struct st_buffer *STbp;
1462 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, is_read);
1471 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1474 ssize_t i, do_count, blks, transfer;
1476 int undone, retry_eot = 0, scode;
1478 unsigned char cmd[MAX_COMMAND_SIZE];
1479 const char __user *b_point;
1480 struct st_request *SRpnt = NULL;
1481 struct scsi_tape *STp = filp->private_data;
1482 struct st_modedef *STm;
1483 struct st_partstat *STps;
1484 struct st_buffer *STbp;
1485 char *name = tape_name(STp);
1487 if (down_interruptible(&STp->lock))
1488 return -ERESTARTSYS;
1490 retval = rw_checks(STp, filp, count);
1491 if (retval || count == 0)
1494 /* Write must be integral number of blocks */
1495 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1496 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1502 STm = &(STp->modes[STp->current_mode]);
1503 STps = &(STp->ps[STp->partition]);
1505 if (STp->write_prot) {
1511 if (STps->rw == ST_READING) {
1512 retval = flush_buffer(STp, 0);
1515 STps->rw = ST_WRITING;
1516 } else if (STps->rw != ST_WRITING &&
1517 STps->drv_file == 0 && STps->drv_block == 0) {
1518 if ((retval = set_mode_densblk(STp, STm)) < 0)
1520 if (STm->default_compression != ST_DONT_TOUCH &&
1521 !(STp->compression_changed)) {
1522 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1523 printk(KERN_WARNING "%s: Can't set default compression.\n",
1525 if (modes_defined) {
1534 i = write_behind_check(STp);
1537 STps->eof = ST_EOM_OK;
1539 STps->eof = ST_EOM_ERROR;
1542 if (STps->eof == ST_EOM_OK) {
1543 STps->eof = ST_EOD_1; /* allow next write */
1547 else if (STps->eof == ST_EOM_ERROR) {
1552 /* Check the buffer readability in cases where copy_user might catch
1553 the problems after some tape movement. */
1554 if (STp->block_size != 0 &&
1556 (copy_from_user(&i, buf, 1) != 0 ||
1557 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1562 retval = setup_buffering(STp, buf, count, 0);
1568 memset(cmd, 0, MAX_COMMAND_SIZE);
1570 cmd[1] = (STp->block_size != 0);
1572 STps->rw = ST_WRITING;
1575 while (count > 0 && !retry_eot) {
1581 if (STp->block_size == 0)
1584 do_count = STbp->buffer_blocks * STp->block_size -
1586 if (do_count > count)
1590 i = append_to_buffer(b_point, STbp, do_count);
1597 b_point += do_count;
1599 async_write = STp->block_size == 0 && !STbp->do_dio &&
1600 STm->do_async_writes && STps->eof < ST_EOM_OK;
1602 if (STp->block_size != 0 && STm->do_buffer_writes &&
1603 !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1604 STbp->buffer_bytes < STbp->buffer_size) {
1606 /* Don't write a buffer that is not full enough. */
1607 if (!async_write && count == 0)
1612 if (STp->block_size == 0)
1613 blks = transfer = do_count;
1616 blks = STbp->buffer_bytes;
1619 blks /= STp->block_size;
1620 transfer = blks * STp->block_size;
1622 cmd[2] = blks >> 16;
1626 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1627 STp->device->timeout, MAX_WRITE_RETRIES, !async_write);
1629 retval = STbp->syscall_result;
1632 if (async_write && !STbp->syscall_result) {
1633 STbp->writing = transfer;
1634 STp->dirty = !(STbp->writing ==
1635 STbp->buffer_bytes);
1636 SRpnt = NULL; /* Prevent releasing this request! */
1637 DEB( STp->write_pending = 1; )
1641 if (STbp->syscall_result != 0) {
1642 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1644 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1645 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1646 scode = cmdstatp->sense_hdr.sense_key;
1647 if (cmdstatp->remainder_valid)
1648 undone = (int)cmdstatp->uremainder64;
1649 else if (STp->block_size == 0 &&
1650 scode == VOLUME_OVERFLOW)
1654 if (STp->block_size != 0)
1655 undone *= STp->block_size;
1656 if (undone <= do_count) {
1657 /* Only data from this write is not written */
1660 if (STp->block_size)
1661 blks = (transfer - undone) / STp->block_size;
1662 STps->eof = ST_EOM_OK;
1663 /* Continue in fixed block mode if all written
1664 in this request but still something left to write
1665 (retval left to zero)
1667 if (STp->block_size == 0 ||
1668 undone > 0 || count == 0)
1669 retval = (-ENOSPC); /* EOM within current request */
1670 DEBC(printk(ST_DEB_MSG
1671 "%s: EOM with %d bytes unwritten.\n",
1674 /* EOT within data buffered earlier (possible only
1675 in fixed block mode without direct i/o) */
1676 if (!retry_eot && !cmdstatp->deferred &&
1677 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1678 move_buffer_data(STp->buffer, transfer - undone);
1680 if (STps->drv_block >= 0) {
1681 STps->drv_block += (transfer - undone) /
1684 STps->eof = ST_EOM_OK;
1685 DEBC(printk(ST_DEB_MSG
1686 "%s: Retry write of %d bytes at EOM.\n",
1687 name, STp->buffer->buffer_bytes));
1691 /* Either error within data buffered by driver or
1694 blks = do_count = 0;
1695 STps->eof = ST_EOM_ERROR;
1696 STps->drv_block = (-1); /* Too cautious? */
1697 retval = (-EIO); /* EOM for old data */
1698 DEBC(printk(ST_DEB_MSG
1699 "%s: EOM with lost data.\n",
1705 STps->drv_block = (-1); /* Too cautious? */
1706 retval = STbp->syscall_result;
1711 if (STps->drv_block >= 0) {
1712 if (STp->block_size == 0)
1713 STps->drv_block += (do_count > 0);
1715 STps->drv_block += blks;
1718 STbp->buffer_bytes = 0;
1721 if (retval || retry_eot) {
1723 retval = total - count;
1728 if (STps->eof == ST_EOD_1)
1729 STps->eof = ST_EOM_OK;
1730 else if (STps->eof != ST_EOM_OK)
1731 STps->eof = ST_NOEOF;
1732 retval = total - count;
1736 st_release_request(SRpnt);
1737 release_buffering(STp, 0);
1743 /* Read data from the tape. Returns zero in the normal case, one if the
1744 eof status has changed, and the negative error code in case of a
1745 fatal error. Otherwise updates the buffer and the eof state.
1747 Does release user buffer mapping if it is set.
1749 static long read_tape(struct scsi_tape *STp, long count,
1750 struct st_request ** aSRpnt)
1752 int transfer, blks, bytes;
1753 unsigned char cmd[MAX_COMMAND_SIZE];
1754 struct st_request *SRpnt;
1755 struct st_modedef *STm;
1756 struct st_partstat *STps;
1757 struct st_buffer *STbp;
1759 char *name = tape_name(STp);
1764 STm = &(STp->modes[STp->current_mode]);
1765 STps = &(STp->ps[STp->partition]);
1766 if (STps->eof == ST_FM_HIT)
1770 if (STp->block_size == 0)
1771 blks = bytes = count;
1773 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1774 blks = (STp->buffer)->buffer_blocks;
1775 bytes = blks * STp->block_size;
1778 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1779 bytes = (STp->buffer)->buffer_size;
1780 blks = bytes / STp->block_size;
1781 bytes = blks * STp->block_size;
1785 memset(cmd, 0, MAX_COMMAND_SIZE);
1787 cmd[1] = (STp->block_size != 0);
1788 cmd[2] = blks >> 16;
1793 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1794 STp->device->timeout, MAX_RETRIES, 1);
1795 release_buffering(STp, 1);
1798 return STbp->syscall_result;
1800 STbp->read_pointer = 0;
1803 /* Something to check */
1804 if (STbp->syscall_result) {
1805 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1808 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1810 SRpnt->sense[0], SRpnt->sense[1],
1811 SRpnt->sense[2], SRpnt->sense[3],
1812 SRpnt->sense[4], SRpnt->sense[5],
1813 SRpnt->sense[6], SRpnt->sense[7]));
1814 if (cmdstatp->have_sense) {
1816 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1817 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1819 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1820 /* Compute the residual count */
1821 if (cmdstatp->remainder_valid)
1822 transfer = (int)cmdstatp->uremainder64;
1825 if (STp->block_size == 0 &&
1826 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1829 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
1830 if (STp->block_size == 0) {
1831 if (transfer <= 0) {
1834 "%s: Failed to read %d byte block with %d byte transfer.\n",
1835 name, bytes - transfer, bytes);
1836 if (STps->drv_block >= 0)
1837 STps->drv_block += 1;
1838 STbp->buffer_bytes = 0;
1841 STbp->buffer_bytes = bytes - transfer;
1843 st_release_request(SRpnt);
1844 SRpnt = *aSRpnt = NULL;
1845 if (transfer == blks) { /* We did not get anything, error */
1846 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1847 if (STps->drv_block >= 0)
1848 STps->drv_block += blks - transfer + 1;
1849 st_int_ioctl(STp, MTBSR, 1);
1852 /* We have some data, deliver it */
1853 STbp->buffer_bytes = (blks - transfer) *
1855 DEBC(printk(ST_DEB_MSG
1856 "%s: ILI but enough data received %ld %d.\n",
1857 name, count, STbp->buffer_bytes));
1858 if (STps->drv_block >= 0)
1859 STps->drv_block += 1;
1860 if (st_int_ioctl(STp, MTBSR, 1))
1863 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
1864 if (STps->eof != ST_FM_HIT)
1865 STps->eof = ST_FM_HIT;
1867 STps->eof = ST_EOD_2;
1868 if (STp->block_size == 0)
1869 STbp->buffer_bytes = 0;
1871 STbp->buffer_bytes =
1872 bytes - transfer * STp->block_size;
1873 DEBC(printk(ST_DEB_MSG
1874 "%s: EOF detected (%d bytes read).\n",
1875 name, STbp->buffer_bytes));
1876 } else if (cmdstatp->flags & SENSE_EOM) {
1877 if (STps->eof == ST_FM)
1878 STps->eof = ST_EOD_1;
1880 STps->eof = ST_EOM_OK;
1881 if (STp->block_size == 0)
1882 STbp->buffer_bytes = bytes - transfer;
1884 STbp->buffer_bytes =
1885 bytes - transfer * STp->block_size;
1887 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1888 name, STbp->buffer_bytes));
1891 /* end of EOF, EOM, ILI test */
1892 else { /* nonzero sense key */
1893 DEBC(printk(ST_DEB_MSG
1894 "%s: Tape error while reading.\n", name));
1895 STps->drv_block = (-1);
1896 if (STps->eof == ST_FM &&
1897 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1898 DEBC(printk(ST_DEB_MSG
1899 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1901 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1902 } else /* Some other extended sense code */
1906 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
1907 STbp->buffer_bytes = 0;
1909 /* End of extended sense test */
1910 else { /* Non-extended sense */
1911 retval = STbp->syscall_result;
1915 /* End of error handling */
1916 else /* Read successful */
1917 STbp->buffer_bytes = bytes;
1919 if (STps->drv_block >= 0) {
1920 if (STp->block_size == 0)
1923 STps->drv_block += STbp->buffer_bytes / STp->block_size;
1931 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
1935 ssize_t i, transfer;
1936 int special, do_dio = 0;
1937 struct st_request *SRpnt = NULL;
1938 struct scsi_tape *STp = filp->private_data;
1939 struct st_modedef *STm;
1940 struct st_partstat *STps;
1941 struct st_buffer *STbp = STp->buffer;
1942 DEB( char *name = tape_name(STp); )
1944 if (down_interruptible(&STp->lock))
1945 return -ERESTARTSYS;
1947 retval = rw_checks(STp, filp, count);
1948 if (retval || count == 0)
1951 STm = &(STp->modes[STp->current_mode]);
1952 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1953 if (!STm->do_read_ahead) {
1954 retval = (-EINVAL); /* Read must be integral number of blocks */
1957 STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */
1960 STps = &(STp->ps[STp->partition]);
1961 if (STps->rw == ST_WRITING) {
1962 retval = flush_buffer(STp, 0);
1965 STps->rw = ST_READING;
1968 if (debugging && STps->eof != ST_NOEOF)
1969 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
1970 STps->eof, STbp->buffer_bytes);
1973 retval = setup_buffering(STp, buf, count, 1);
1976 do_dio = STbp->do_dio;
1978 if (STbp->buffer_bytes == 0 &&
1979 STps->eof >= ST_EOD_1) {
1980 if (STps->eof < ST_EOD) {
1985 retval = (-EIO); /* EOM or Blank Check */
1990 /* Check the buffer writability before any tape movement. Don't alter
1992 if (copy_from_user(&i, buf, 1) != 0 ||
1993 copy_to_user(buf, &i, 1) != 0 ||
1994 copy_from_user(&i, buf + count - 1, 1) != 0 ||
1995 copy_to_user(buf + count - 1, &i, 1) != 0) {
2001 STps->rw = ST_READING;
2004 /* Loop until enough data in buffer or a special condition found */
2005 for (total = 0, special = 0; total < count && !special;) {
2007 /* Get new data if the buffer is empty */
2008 if (STbp->buffer_bytes == 0) {
2009 special = read_tape(STp, count - total, &SRpnt);
2010 if (special < 0) { /* No need to continue read */
2016 /* Move the data from driver buffer to user buffer */
2017 if (STbp->buffer_bytes > 0) {
2019 if (debugging && STps->eof != ST_NOEOF)
2021 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2022 STps->eof, STbp->buffer_bytes,
2023 (int)(count - total));
2025 transfer = STbp->buffer_bytes < count - total ?
2026 STbp->buffer_bytes : count - total;
2028 i = from_buffer(STbp, buf, transfer);
2038 if (STp->block_size == 0)
2039 break; /* Read only one variable length block */
2041 } /* for (total = 0, special = 0;
2042 total < count && !special; ) */
2044 /* Change the eof state if no data from tape or buffer */
2046 if (STps->eof == ST_FM_HIT) {
2048 STps->drv_block = 0;
2049 if (STps->drv_file >= 0)
2051 } else if (STps->eof == ST_EOD_1) {
2052 STps->eof = ST_EOD_2;
2053 STps->drv_block = 0;
2054 if (STps->drv_file >= 0)
2056 } else if (STps->eof == ST_EOD_2)
2058 } else if (STps->eof == ST_FM)
2059 STps->eof = ST_NOEOF;
2063 if (SRpnt != NULL) {
2064 st_release_request(SRpnt);
2068 release_buffering(STp, 1);
2069 STbp->buffer_bytes = 0;
2079 /* Set the driver options */
2080 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2084 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2085 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2086 STm->do_read_ahead);
2088 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2089 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2091 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2092 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2093 STp->scsi2_logical);
2095 "%s: sysv: %d nowait: %d\n", name, STm->sysv, STp->immediate);
2096 printk(KERN_INFO "%s: debugging: %d\n",
2103 static int st_set_options(struct scsi_tape *STp, long options)
2107 struct st_modedef *STm;
2108 char *name = tape_name(STp);
2109 struct cdev *cd0, *cd1;
2111 STm = &(STp->modes[STp->current_mode]);
2112 if (!STm->defined) {
2113 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2114 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2115 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2117 DEBC(printk(ST_DEB_MSG
2118 "%s: Initialized mode %d definition from mode 0\n",
2119 name, STp->current_mode));
2122 code = options & MT_ST_OPTIONS;
2123 if (code == MT_ST_BOOLEANS) {
2124 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2125 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2126 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2127 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2128 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2129 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2130 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2131 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2132 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2133 if ((STp->device)->scsi_level >= SCSI_2)
2134 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2135 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2136 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2137 STm->sysv = (options & MT_ST_SYSV) != 0;
2138 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2139 st_log_options(STp, STm, name); )
2140 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2141 value = (code == MT_ST_SETBOOLEANS);
2142 if ((options & MT_ST_BUFFER_WRITES) != 0)
2143 STm->do_buffer_writes = value;
2144 if ((options & MT_ST_ASYNC_WRITES) != 0)
2145 STm->do_async_writes = value;
2146 if ((options & MT_ST_DEF_WRITES) != 0)
2147 STm->defaults_for_writes = value;
2148 if ((options & MT_ST_READ_AHEAD) != 0)
2149 STm->do_read_ahead = value;
2150 if ((options & MT_ST_TWO_FM) != 0)
2151 STp->two_fm = value;
2152 if ((options & MT_ST_FAST_MTEOM) != 0)
2153 STp->fast_mteom = value;
2154 if ((options & MT_ST_AUTO_LOCK) != 0)
2155 STp->do_auto_lock = value;
2156 if ((options & MT_ST_CAN_BSR) != 0)
2157 STp->can_bsr = value;
2158 if ((options & MT_ST_NO_BLKLIMS) != 0)
2159 STp->omit_blklims = value;
2160 if ((STp->device)->scsi_level >= SCSI_2 &&
2161 (options & MT_ST_CAN_PARTITIONS) != 0)
2162 STp->can_partitions = value;
2163 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2164 STp->scsi2_logical = value;
2165 if ((options & MT_ST_NOWAIT) != 0)
2166 STp->immediate = value;
2167 if ((options & MT_ST_SYSV) != 0)
2170 if ((options & MT_ST_DEBUGGING) != 0)
2172 st_log_options(STp, STm, name); )
2173 } else if (code == MT_ST_WRITE_THRESHOLD) {
2174 /* Retained for compatibility */
2175 } else if (code == MT_ST_DEF_BLKSIZE) {
2176 value = (options & ~MT_ST_OPTIONS);
2177 if (value == ~MT_ST_OPTIONS) {
2178 STm->default_blksize = (-1);
2179 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2181 STm->default_blksize = value;
2182 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2183 name, STm->default_blksize));
2184 if (STp->ready == ST_READY) {
2185 STp->blksize_changed = 0;
2186 set_mode_densblk(STp, STm);
2189 } else if (code == MT_ST_TIMEOUTS) {
2190 value = (options & ~MT_ST_OPTIONS);
2191 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2192 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2193 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2194 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2196 STp->device->timeout = value * HZ;
2197 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2200 } else if (code == MT_ST_SET_CLN) {
2201 value = (options & ~MT_ST_OPTIONS) & 0xff;
2203 value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2205 STp->cln_mode = value;
2206 STp->cln_sense_mask = (options >> 8) & 0xff;
2207 STp->cln_sense_value = (options >> 16) & 0xff;
2209 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2210 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2211 } else if (code == MT_ST_DEF_OPTIONS) {
2212 code = (options & ~MT_ST_CLEAR_DEFAULT);
2213 value = (options & MT_ST_CLEAR_DEFAULT);
2214 if (code == MT_ST_DEF_DENSITY) {
2215 if (value == MT_ST_CLEAR_DEFAULT) {
2216 STm->default_density = (-1);
2217 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2220 STm->default_density = value & 0xff;
2221 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2222 name, STm->default_density));
2223 if (STp->ready == ST_READY) {
2224 STp->density_changed = 0;
2225 set_mode_densblk(STp, STm);
2228 } else if (code == MT_ST_DEF_DRVBUFFER) {
2229 if (value == MT_ST_CLEAR_DEFAULT) {
2230 STp->default_drvbuffer = 0xff;
2231 DEBC( printk(KERN_INFO
2232 "%s: Drive buffer default disabled.\n", name));
2234 STp->default_drvbuffer = value & 7;
2235 DEBC( printk(KERN_INFO
2236 "%s: Drive buffer default set to %x\n",
2237 name, STp->default_drvbuffer));
2238 if (STp->ready == ST_READY)
2239 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2241 } else if (code == MT_ST_DEF_COMPRESSION) {
2242 if (value == MT_ST_CLEAR_DEFAULT) {
2243 STm->default_compression = ST_DONT_TOUCH;
2244 DEBC( printk(KERN_INFO
2245 "%s: Compression default disabled.\n", name));
2247 if ((value & 0xff00) != 0) {
2248 STp->c_algo = (value & 0xff00) >> 8;
2249 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2250 name, STp->c_algo));
2252 if ((value & 0xff) != 0xff) {
2253 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2254 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2255 name, (value & 1)));
2256 if (STp->ready == ST_READY) {
2257 STp->compression_changed = 0;
2258 st_compression(STp, (STm->default_compression == ST_YES));
2269 #define MODE_HEADER_LENGTH 4
2271 /* Mode header and page byte offsets */
2272 #define MH_OFF_DATA_LENGTH 0
2273 #define MH_OFF_MEDIUM_TYPE 1
2274 #define MH_OFF_DEV_SPECIFIC 2
2275 #define MH_OFF_BDESCS_LENGTH 3
2276 #define MP_OFF_PAGE_NBR 0
2277 #define MP_OFF_PAGE_LENGTH 1
2279 /* Mode header and page bit masks */
2280 #define MH_BIT_WP 0x80
2281 #define MP_MSK_PAGE_NBR 0x3f
2283 /* Don't return block descriptors */
2284 #define MODE_SENSE_OMIT_BDESCS 0x08
2286 #define MODE_SELECT_PAGE_FORMAT 0x10
2288 /* Read a mode page into the tape buffer. The block descriptors are included
2289 if incl_block_descs is true. The page control is ored to the page number
2290 parameter, if necessary. */
2291 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2293 unsigned char cmd[MAX_COMMAND_SIZE];
2294 struct st_request *SRpnt = NULL;
2296 memset(cmd, 0, MAX_COMMAND_SIZE);
2297 cmd[0] = MODE_SENSE;
2298 if (omit_block_descs)
2299 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2303 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2304 STp->device->timeout, 0, 1);
2306 return (STp->buffer)->syscall_result;
2308 st_release_request(SRpnt);
2310 return (STp->buffer)->syscall_result;
2314 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2315 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2316 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2319 unsigned char cmd[MAX_COMMAND_SIZE];
2320 struct st_request *SRpnt = NULL;
2322 memset(cmd, 0, MAX_COMMAND_SIZE);
2323 cmd[0] = MODE_SELECT;
2324 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2325 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2326 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2328 /* Clear reserved fields */
2329 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2330 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2331 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2332 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2334 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE,
2335 (slow ? STp->long_timeout : STp->device->timeout), 0, 1);
2337 return (STp->buffer)->syscall_result;
2339 st_release_request(SRpnt);
2341 return (STp->buffer)->syscall_result;
2345 #define COMPRESSION_PAGE 0x0f
2346 #define COMPRESSION_PAGE_LENGTH 16
2348 #define CP_OFF_DCE_DCC 2
2349 #define CP_OFF_C_ALGO 7
2351 #define DCE_MASK 0x80
2352 #define DCC_MASK 0x40
2353 #define RED_MASK 0x60
2356 /* Control the compression with mode page 15. Algorithm not changed if zero.
2358 The block descriptors are read and written because Sony SDT-7000 does not
2359 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2360 Including block descriptors should not cause any harm to other drives. */
2362 static int st_compression(struct scsi_tape * STp, int state)
2365 int mpoffs; /* Offset to mode page start */
2366 unsigned char *b_data = (STp->buffer)->b_data;
2367 DEB( char *name = tape_name(STp); )
2369 if (STp->ready != ST_READY)
2372 /* Read the current page contents */
2373 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2375 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2380 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2381 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2382 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2384 /* Check if compression can be changed */
2385 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2386 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2392 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2393 if (STp->c_algo != 0)
2394 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2397 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2398 if (STp->c_algo != 0)
2399 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2402 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2404 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2407 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2410 STp->compression_changed = 1;
2415 /* Process the load and unload commands (does unload if the load code is zero) */
2416 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2418 int retval = (-EIO), timeout;
2419 DEB( char *name = tape_name(STp); )
2420 unsigned char cmd[MAX_COMMAND_SIZE];
2421 struct st_partstat *STps;
2422 struct st_request *SRpnt;
2424 if (STp->ready != ST_READY && !load_code) {
2425 if (STp->ready == ST_NO_TAPE)
2426 return (-ENOMEDIUM);
2431 memset(cmd, 0, MAX_COMMAND_SIZE);
2432 cmd[0] = START_STOP;
2436 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2438 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2439 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2440 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2441 name, (cmd[4]) ? "" : "un",
2442 load_code - MT_ST_HPLOADER_OFFSET));
2443 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2445 if (STp->immediate) {
2446 cmd[1] = 1; /* Don't wait for completion */
2447 timeout = STp->device->timeout;
2450 timeout = STp->long_timeout;
2454 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2456 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2459 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2460 timeout, MAX_RETRIES, 1);
2462 return (STp->buffer)->syscall_result;
2464 retval = (STp->buffer)->syscall_result;
2465 st_release_request(SRpnt);
2467 if (!retval) { /* SCSI command successful */
2470 STp->rew_at_close = 0;
2471 STp->ready = ST_NO_TAPE;
2474 STp->rew_at_close = STp->autorew_dev;
2475 retval = check_tape(STp, filp);
2481 STps = &(STp->ps[STp->partition]);
2482 STps->drv_file = STps->drv_block = (-1);
2489 #define ST_DEB_FORWARD 0
2490 #define ST_DEB_BACKWARD 1
2491 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2495 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2496 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2499 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2500 direction ? "backward" : "forward", sc, units);
2505 /* Internal ioctl function */
2506 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2512 unsigned char cmd[MAX_COMMAND_SIZE];
2513 struct st_request *SRpnt;
2514 struct st_partstat *STps;
2515 int fileno, blkno, at_sm, undone;
2516 int datalen = 0, direction = DMA_NONE;
2517 char *name = tape_name(STp);
2519 WARN_ON(STp->buffer->do_dio != 0);
2520 if (STp->ready != ST_READY) {
2521 if (STp->ready == ST_NO_TAPE)
2522 return (-ENOMEDIUM);
2526 timeout = STp->long_timeout;
2527 STps = &(STp->ps[STp->partition]);
2528 fileno = STps->drv_file;
2529 blkno = STps->drv_block;
2530 at_sm = STps->at_sm;
2532 memset(cmd, 0, MAX_COMMAND_SIZE);
2535 chg_eof = 0; /* Changed from the FSF after this */
2538 cmd[1] = 0x01; /* Space FileMarks */
2539 cmd[2] = (arg >> 16);
2540 cmd[3] = (arg >> 8);
2542 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2546 at_sm &= (arg == 0);
2549 chg_eof = 0; /* Changed from the FSF after this */
2552 cmd[1] = 0x01; /* Space FileMarks */
2554 cmd[2] = (ltmp >> 16);
2555 cmd[3] = (ltmp >> 8);
2557 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2560 blkno = (-1); /* We can't know the block number */
2561 at_sm &= (arg == 0);
2565 cmd[1] = 0x00; /* Space Blocks */
2566 cmd[2] = (arg >> 16);
2567 cmd[3] = (arg >> 8);
2569 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2572 at_sm &= (arg == 0);
2576 cmd[1] = 0x00; /* Space Blocks */
2578 cmd[2] = (ltmp >> 16);
2579 cmd[3] = (ltmp >> 8);
2581 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2584 at_sm &= (arg == 0);
2588 cmd[1] = 0x04; /* Space Setmarks */
2589 cmd[2] = (arg >> 16);
2590 cmd[3] = (arg >> 8);
2592 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2594 blkno = fileno = (-1);
2600 cmd[1] = 0x04; /* Space Setmarks */
2602 cmd[2] = (ltmp >> 16);
2603 cmd[3] = (ltmp >> 8);
2605 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2607 blkno = fileno = (-1);
2613 if (STp->write_prot)
2615 cmd[0] = WRITE_FILEMARKS;
2616 if (cmd_in == MTWSM)
2618 cmd[2] = (arg >> 16);
2619 cmd[3] = (arg >> 8);
2621 timeout = STp->device->timeout;
2623 if (cmd_in == MTWEOF)
2624 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2625 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2627 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2628 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2633 at_sm = (cmd_in == MTWSM);
2636 cmd[0] = REZERO_UNIT;
2637 if (STp->immediate) {
2638 cmd[1] = 1; /* Don't wait for completion */
2639 timeout = STp->device->timeout;
2641 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2642 fileno = blkno = at_sm = 0;
2645 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2646 return 0; /* Should do something ? */
2649 cmd[0] = START_STOP;
2650 if (STp->immediate) {
2651 cmd[1] = 1; /* Don't wait for completion */
2652 timeout = STp->device->timeout;
2655 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2656 fileno = blkno = at_sm = 0;
2659 if (!STp->fast_mteom) {
2660 /* space to the end of tape */
2661 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2662 fileno = STps->drv_file;
2663 if (STps->eof >= ST_EOD_1)
2665 /* The next lines would hide the number of spaced FileMarks
2666 That's why I inserted the previous lines. I had no luck
2667 with detecting EOM with FSF, so we go now to EOM.
2673 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2679 if (STp->write_prot)
2682 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2683 if (STp->immediate) {
2684 cmd[1] |= 2; /* Don't wait for completion */
2685 timeout = STp->device->timeout;
2688 timeout = STp->long_timeout * 8;
2690 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2691 fileno = blkno = at_sm = 0;
2693 case MTSETBLK: /* Set block length */
2694 case MTSETDENSITY: /* Set tape density */
2695 case MTSETDRVBUFFER: /* Set drive buffering */
2696 case SET_DENS_AND_BLK: /* Set density and block size */
2698 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2699 return (-EIO); /* Not allowed if data in buffer */
2700 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2701 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2702 STp->max_block > 0 &&
2703 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2704 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2705 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2708 cmd[0] = MODE_SELECT;
2709 if ((STp->use_pf & USE_PF))
2710 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2711 cmd[4] = datalen = 12;
2712 direction = DMA_TO_DEVICE;
2714 memset((STp->buffer)->b_data, 0, 12);
2715 if (cmd_in == MTSETDRVBUFFER)
2716 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2718 (STp->buffer)->b_data[2] =
2719 STp->drv_buffer << 4;
2720 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2721 if (cmd_in == MTSETDENSITY) {
2722 (STp->buffer)->b_data[4] = arg;
2723 STp->density_changed = 1; /* At least we tried ;-) */
2724 } else if (cmd_in == SET_DENS_AND_BLK)
2725 (STp->buffer)->b_data[4] = arg >> 24;
2727 (STp->buffer)->b_data[4] = STp->density;
2728 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2729 ltmp = arg & MT_ST_BLKSIZE_MASK;
2730 if (cmd_in == MTSETBLK)
2731 STp->blksize_changed = 1; /* At least we tried ;-) */
2733 ltmp = STp->block_size;
2734 (STp->buffer)->b_data[9] = (ltmp >> 16);
2735 (STp->buffer)->b_data[10] = (ltmp >> 8);
2736 (STp->buffer)->b_data[11] = ltmp;
2737 timeout = STp->device->timeout;
2739 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2741 "%s: Setting block size to %d bytes.\n", name,
2742 (STp->buffer)->b_data[9] * 65536 +
2743 (STp->buffer)->b_data[10] * 256 +
2744 (STp->buffer)->b_data[11]);
2745 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2747 "%s: Setting density code to %x.\n", name,
2748 (STp->buffer)->b_data[4]);
2749 if (cmd_in == MTSETDRVBUFFER)
2751 "%s: Setting drive buffer code to %d.\n", name,
2752 ((STp->buffer)->b_data[2] >> 4) & 7);
2759 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2760 timeout, MAX_RETRIES, 1);
2762 return (STp->buffer)->syscall_result;
2764 ioctl_result = (STp->buffer)->syscall_result;
2766 if (!ioctl_result) { /* SCSI command successful */
2767 st_release_request(SRpnt);
2769 STps->drv_block = blkno;
2770 STps->drv_file = fileno;
2771 STps->at_sm = at_sm;
2773 if (cmd_in == MTBSFM)
2774 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2775 else if (cmd_in == MTFSFM)
2776 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2778 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2779 int old_block_size = STp->block_size;
2780 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2781 if (STp->block_size != 0) {
2782 if (old_block_size == 0)
2783 normalize_buffer(STp->buffer);
2784 (STp->buffer)->buffer_blocks =
2785 (STp->buffer)->buffer_size / STp->block_size;
2787 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2788 if (cmd_in == SET_DENS_AND_BLK)
2789 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2790 } else if (cmd_in == MTSETDRVBUFFER)
2791 STp->drv_buffer = (arg & 7);
2792 else if (cmd_in == MTSETDENSITY)
2795 if (cmd_in == MTEOM)
2797 else if (cmd_in == MTFSF)
2800 STps->eof = ST_NOEOF;
2802 if (cmd_in == MTWEOF)
2804 } else { /* SCSI command was not completely successful. Don't return
2805 from this block without releasing the SCSI command block! */
2806 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2808 if (cmdstatp->flags & SENSE_EOM) {
2809 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2810 cmd_in != MTBSR && cmd_in != MTBSS)
2811 STps->eof = ST_EOM_OK;
2812 STps->drv_block = 0;
2815 if (cmdstatp->remainder_valid)
2816 undone = (int)cmdstatp->uremainder64;
2820 if (cmd_in == MTWEOF &&
2821 cmdstatp->have_sense &&
2822 (cmdstatp->flags & SENSE_EOM) &&
2823 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2824 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
2826 ioctl_result = 0; /* EOF written successfully at EOM */
2829 STps->drv_file = fileno;
2830 STps->eof = ST_NOEOF;
2831 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2833 STps->drv_file = fileno - undone;
2835 STps->drv_file = fileno;
2836 STps->drv_block = -1;
2837 STps->eof = ST_NOEOF;
2838 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2839 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2841 if (STps->drv_file >= 0)
2842 STps->drv_file = fileno + undone;
2843 STps->drv_block = 0;
2844 STps->eof = ST_NOEOF;
2845 } else if (cmd_in == MTFSR) {
2846 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2847 if (STps->drv_file >= 0)
2849 STps->drv_block = 0;
2852 if (blkno >= undone)
2853 STps->drv_block = blkno - undone;
2855 STps->drv_block = (-1);
2856 STps->eof = ST_NOEOF;
2858 } else if (cmd_in == MTBSR) {
2859 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2861 STps->drv_block = (-1);
2863 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2865 if (STps->drv_block >= 0)
2866 STps->drv_block = blkno + undone;
2868 STps->eof = ST_NOEOF;
2869 } else if (cmd_in == MTEOM) {
2870 STps->drv_file = (-1);
2871 STps->drv_block = (-1);
2873 } else if (cmd_in == MTSETBLK ||
2874 cmd_in == MTSETDENSITY ||
2875 cmd_in == MTSETDRVBUFFER ||
2876 cmd_in == SET_DENS_AND_BLK) {
2877 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2878 !(STp->use_pf & PF_TESTED)) {
2879 /* Try the other possible state of Page Format if not
2881 STp->use_pf = !STp->use_pf | PF_TESTED;
2882 st_release_request(SRpnt);
2884 return st_int_ioctl(STp, cmd_in, arg);
2887 STps->eof = ST_NOEOF;
2889 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2892 st_release_request(SRpnt);
2896 return ioctl_result;
2900 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2903 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2907 unsigned char scmd[MAX_COMMAND_SIZE];
2908 struct st_request *SRpnt;
2909 DEB( char *name = tape_name(STp); )
2911 if (STp->ready != ST_READY)
2914 memset(scmd, 0, MAX_COMMAND_SIZE);
2915 if ((STp->device)->scsi_level < SCSI_2) {
2916 scmd[0] = QFA_REQUEST_BLOCK;
2919 scmd[0] = READ_POSITION;
2920 if (!logical && !STp->scsi2_logical)
2923 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
2924 STp->device->timeout, MAX_READY_RETRIES, 1);
2926 return (STp->buffer)->syscall_result;
2928 if ((STp->buffer)->syscall_result != 0 ||
2929 (STp->device->scsi_level >= SCSI_2 &&
2930 ((STp->buffer)->b_data[0] & 4) != 0)) {
2931 *block = *partition = 0;
2932 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
2936 if ((STp->device)->scsi_level < SCSI_2) {
2937 *block = ((STp->buffer)->b_data[0] << 16)
2938 + ((STp->buffer)->b_data[1] << 8)
2939 + (STp->buffer)->b_data[2];
2942 *block = ((STp->buffer)->b_data[4] << 24)
2943 + ((STp->buffer)->b_data[5] << 16)
2944 + ((STp->buffer)->b_data[6] << 8)
2945 + (STp->buffer)->b_data[7];
2946 *partition = (STp->buffer)->b_data[1];
2947 if (((STp->buffer)->b_data[0] & 0x80) &&
2948 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
2949 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
2951 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
2952 *block, *partition));
2954 st_release_request(SRpnt);
2961 /* Set the tape block and partition. Negative partition means that only the
2962 block should be set in vendor specific way. */
2963 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
2966 struct st_partstat *STps;
2970 unsigned char scmd[MAX_COMMAND_SIZE];
2971 struct st_request *SRpnt;
2972 DEB( char *name = tape_name(STp); )
2974 if (STp->ready != ST_READY)
2976 timeout = STp->long_timeout;
2977 STps = &(STp->ps[STp->partition]);
2979 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
2980 name, block, partition));
2981 DEB(if (partition < 0)
2984 /* Update the location at the partition we are leaving */
2985 if ((!STp->can_partitions && partition != 0) ||
2986 partition >= ST_NBR_PARTITIONS)
2988 if (partition != STp->partition) {
2989 if (get_location(STp, &blk, &p, 1))
2990 STps->last_block_valid = 0;
2992 STps->last_block_valid = 1;
2993 STps->last_block_visited = blk;
2994 DEBC(printk(ST_DEB_MSG
2995 "%s: Visited block %d for partition %d saved.\n",
2996 name, blk, STp->partition));
3000 memset(scmd, 0, MAX_COMMAND_SIZE);
3001 if ((STp->device)->scsi_level < SCSI_2) {
3002 scmd[0] = QFA_SEEK_BLOCK;
3003 scmd[2] = (block >> 16);
3004 scmd[3] = (block >> 8);
3009 scmd[3] = (block >> 24);
3010 scmd[4] = (block >> 16);
3011 scmd[5] = (block >> 8);
3013 if (!logical && !STp->scsi2_logical)
3015 if (STp->partition != partition) {
3017 scmd[8] = partition;
3018 DEBC(printk(ST_DEB_MSG
3019 "%s: Trying to change partition from %d to %d\n",
3020 name, STp->partition, partition));
3023 if (STp->immediate) {
3024 scmd[1] |= 1; /* Don't wait for completion */
3025 timeout = STp->device->timeout;
3028 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3029 timeout, MAX_READY_RETRIES, 1);
3031 return (STp->buffer)->syscall_result;
3033 STps->drv_block = STps->drv_file = (-1);
3034 STps->eof = ST_NOEOF;
3035 if ((STp->buffer)->syscall_result != 0) {
3037 if (STp->can_partitions &&
3038 (STp->device)->scsi_level >= SCSI_2 &&
3039 (p = find_partition(STp)) >= 0)
3042 if (STp->can_partitions) {
3043 STp->partition = partition;
3044 STps = &(STp->ps[partition]);
3045 if (!STps->last_block_valid ||
3046 STps->last_block_visited != block) {
3053 STps->drv_block = STps->drv_file = 0;
3057 st_release_request(SRpnt);
3064 /* Find the current partition number for the drive status. Called from open and
3065 returns either partition number of negative error code. */
3066 static int find_partition(struct scsi_tape *STp)
3071 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3073 if (partition >= ST_NBR_PARTITIONS)
3079 /* Change the partition if necessary */
3080 static int switch_partition(struct scsi_tape *STp)
3082 struct st_partstat *STps;
3084 if (STp->partition == STp->new_partition)
3086 STps = &(STp->ps[STp->new_partition]);
3087 if (!STps->last_block_valid)
3088 STps->last_block_visited = 0;
3089 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3092 /* Functions for reading and writing the medium partition mode page. */
3094 #define PART_PAGE 0x11
3095 #define PART_PAGE_FIXED_LENGTH 8
3097 #define PP_OFF_MAX_ADD_PARTS 2
3098 #define PP_OFF_NBR_ADD_PARTS 3
3099 #define PP_OFF_FLAGS 4
3100 #define PP_OFF_PART_UNITS 6
3101 #define PP_OFF_RESERVED 7
3103 #define PP_BIT_IDP 0x20
3104 #define PP_MSK_PSUM_MB 0x10
3106 /* Get the number of partitions on the tape. As a side effect reads the
3107 mode page into the tape buffer. */
3108 static int nbr_partitions(struct scsi_tape *STp)
3111 DEB( char *name = tape_name(STp); )
3113 if (STp->ready != ST_READY)
3116 result = read_mode_page(STp, PART_PAGE, 1);
3119 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3123 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3124 PP_OFF_NBR_ADD_PARTS] + 1;
3125 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3132 /* Partition the tape into two partitions if size > 0 or one partition if
3135 The block descriptors are read and written because Sony SDT-7000 does not
3136 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3138 My HP C1533A drive returns only one partition size field. This is used to
3139 set the size of partition 1. There is no size field for the default partition.
3140 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3141 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3142 The following algorithm is used to accommodate both drives: if the number of
3143 partition size fields is greater than the maximum number of additional partitions
3144 in the mode page, the second field is used. Otherwise the first field is used.
3146 For Seagate DDS drives the page length must be 8 when no partitions is defined
3147 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3148 is acceptable also to some other old drives and enforced if the first partition
3149 size field is used for the first additional partition size.
3151 static int partition_tape(struct scsi_tape *STp, int size)
3153 char *name = tape_name(STp);
3155 int pgo, psd_cnt, psdo;
3158 result = read_mode_page(STp, PART_PAGE, 0);
3160 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3163 /* The mode page is in the buffer. Let's modify it and write it. */
3164 bp = (STp->buffer)->b_data;
3165 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3166 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3167 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3169 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3170 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3171 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3172 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3175 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3177 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3178 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3179 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3182 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3183 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3184 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3185 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3188 bp[psdo] = (size >> 8) & 0xff;
3189 bp[psdo + 1] = size & 0xff;
3191 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3192 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3193 DEBC(printk(ST_DEB_MSG
3194 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3197 bp[pgo + PP_OFF_PART_UNITS] = 0;
3198 bp[pgo + PP_OFF_RESERVED] = 0;
3199 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3201 result = write_mode_page(STp, PART_PAGE, 1);
3203 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3212 /* The ioctl command */
3213 static int st_ioctl(struct inode *inode, struct file *file,
3214 unsigned int cmd_in, unsigned long arg)
3216 int i, cmd_nr, cmd_type, bt;
3219 struct scsi_tape *STp = file->private_data;
3220 struct st_modedef *STm;
3221 struct st_partstat *STps;
3222 char *name = tape_name(STp);
3223 void __user *p = (void __user *)arg;
3225 if (down_interruptible(&STp->lock))
3226 return -ERESTARTSYS;
3229 if (debugging && !STp->in_use) {
3230 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3235 STm = &(STp->modes[STp->current_mode]);
3236 STps = &(STp->ps[STp->partition]);
3239 * If we are in the middle of error recovery, don't let anyone
3240 * else try and use this device. Also, if error recovery fails, it
3241 * may try and take the device offline, in which case all further
3242 * access to the device is prohibited.
3244 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p, file);
3245 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3249 cmd_type = _IOC_TYPE(cmd_in);
3250 cmd_nr = _IOC_NR(cmd_in);
3252 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3255 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3260 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3266 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3268 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3272 if (!STm->defined &&
3273 (mtc.mt_op != MTSETDRVBUFFER &&
3274 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3279 if (!STp->pos_unknown) {
3281 if (STps->eof == ST_FM_HIT) {
3282 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3283 mtc.mt_op == MTEOM) {
3285 if (STps->drv_file >= 0)
3286 STps->drv_file += 1;
3287 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3289 if (STps->drv_file >= 0)
3290 STps->drv_file += 1;
3294 if (mtc.mt_op == MTSEEK) {
3295 /* Old position must be restored if partition will be
3297 i = !STp->can_partitions ||
3298 (STp->new_partition != STp->partition);
3300 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3301 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3302 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3303 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3304 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3305 mtc.mt_op == MTCOMPRESSION;
3307 i = flush_buffer(STp, i);
3312 if (STps->rw == ST_WRITING &&
3313 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3314 mtc.mt_op == MTSEEK ||
3315 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3316 i = st_int_ioctl(STp, MTWEOF, 1);
3321 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3328 * If there was a bus reset, block further access
3329 * to this device. If the user wants to rewind the tape,
3330 * then reset the flag and allow access again.
3332 if (mtc.mt_op != MTREW &&
3333 mtc.mt_op != MTOFFL &&
3334 mtc.mt_op != MTRETEN &&
3335 mtc.mt_op != MTERASE &&
3336 mtc.mt_op != MTSEEK &&
3337 mtc.mt_op != MTEOM) {
3342 /* remove this when the midlevel properly clears was_reset */
3343 STp->device->was_reset = 0;
3346 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3347 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3348 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3349 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3351 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3352 do_door_lock(STp, 0); /* Ignore result! */
3354 if (mtc.mt_op == MTSETDRVBUFFER &&
3355 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3356 retval = st_set_options(STp, mtc.mt_count);
3360 if (mtc.mt_op == MTSETPART) {
3361 if (!STp->can_partitions ||
3362 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3366 if (mtc.mt_count >= STp->nbr_partitions &&
3367 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3371 if (mtc.mt_count >= STp->nbr_partitions) {
3375 STp->new_partition = mtc.mt_count;
3380 if (mtc.mt_op == MTMKPART) {
3381 if (!STp->can_partitions) {
3385 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3386 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3390 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3391 STp->ps[i].rw = ST_IDLE;
3392 STp->ps[i].at_sm = 0;
3393 STp->ps[i].last_block_valid = 0;
3395 STp->partition = STp->new_partition = 0;
3396 STp->nbr_partitions = 1; /* Bad guess ?-) */
3397 STps->drv_block = STps->drv_file = 0;
3402 if (mtc.mt_op == MTSEEK) {
3403 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3404 if (!STp->can_partitions)
3405 STp->ps[0].rw = ST_IDLE;
3410 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3411 retval = do_load_unload(STp, file, 0);
3415 if (mtc.mt_op == MTLOAD) {
3416 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3420 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3421 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3425 if (STp->can_partitions && STp->ready == ST_READY &&
3426 (i = switch_partition(STp)) < 0) {
3431 if (mtc.mt_op == MTCOMPRESSION)
3432 retval = st_compression(STp, (mtc.mt_count & 1));
3434 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3437 if (!STm->defined) {
3442 if ((i = flush_buffer(STp, 0)) < 0) {
3446 if (STp->can_partitions &&
3447 (i = switch_partition(STp)) < 0) {
3452 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3453 struct mtget mt_status;
3455 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3460 mt_status.mt_type = STp->tape_type;
3461 mt_status.mt_dsreg =
3462 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3463 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3464 mt_status.mt_blkno = STps->drv_block;
3465 mt_status.mt_fileno = STps->drv_file;
3466 if (STp->block_size != 0) {
3467 if (STps->rw == ST_WRITING)
3468 mt_status.mt_blkno +=
3469 (STp->buffer)->buffer_bytes / STp->block_size;
3470 else if (STps->rw == ST_READING)
3471 mt_status.mt_blkno -=
3472 ((STp->buffer)->buffer_bytes +
3473 STp->block_size - 1) / STp->block_size;
3476 mt_status.mt_gstat = 0;
3477 if (STp->drv_write_prot)
3478 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3479 if (mt_status.mt_blkno == 0) {
3480 if (mt_status.mt_fileno == 0)
3481 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3483 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3485 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3486 mt_status.mt_resid = STp->partition;
3487 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3488 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3489 else if (STps->eof >= ST_EOM_OK)
3490 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3491 if (STp->density == 1)
3492 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3493 else if (STp->density == 2)
3494 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3495 else if (STp->density == 3)
3496 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3497 if (STp->ready == ST_READY)
3498 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3499 if (STp->ready == ST_NO_TAPE)
3500 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3502 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3503 if (STm->do_async_writes ||
3504 (STm->do_buffer_writes && STp->block_size != 0) ||
3505 STp->drv_buffer != 0)
3506 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3507 if (STp->cleaning_req)
3508 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3510 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3516 STp->recover_reg = 0; /* Clear after read */
3519 } /* End of MTIOCGET */
3520 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3521 struct mtpos mt_pos;
3522 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3526 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3530 mt_pos.mt_blkno = blk;
3531 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3538 case SCSI_IOCTL_GET_IDLUN:
3539 case SCSI_IOCTL_GET_BUS_NUMBER:
3542 if ((cmd_in == SG_IO ||
3543 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3544 cmd_in == CDROM_SEND_PACKET) &&
3545 !capable(CAP_SYS_RAWIO))
3548 i = scsi_cmd_ioctl(file, STp->disk, cmd_in, p);
3553 retval = scsi_ioctl(STp->device, cmd_in, p);
3554 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3555 STp->rew_at_close = 0;
3556 STp->ready = ST_NO_TAPE;
3565 #ifdef CONFIG_COMPAT
3566 static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3568 struct scsi_tape *STp = file->private_data;
3569 struct scsi_device *sdev = STp->device;
3570 int ret = -ENOIOCTLCMD;
3571 if (sdev->host->hostt->compat_ioctl) {
3573 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3582 /* Try to allocate a new tape buffer. Calling function must not hold
3584 static struct st_buffer *
3585 new_tape_buffer(int from_initialization, int need_dma, int max_sg)
3589 struct st_buffer *tb;
3591 if (from_initialization)
3592 priority = GFP_ATOMIC;
3594 priority = GFP_KERNEL;
3596 i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3597 max_sg * sizeof(struct st_buf_fragment);
3598 tb = kzalloc(i, priority);
3600 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3603 tb->frp_segs = tb->orig_frp_segs = 0;
3604 tb->use_sg = max_sg;
3605 tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
3608 tb->buffer_size = got;
3614 /* Try to allocate enough space in the tape buffer */
3615 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3617 int segs, nbr, max_segs, b_size, order, got;
3620 if (new_size <= STbuffer->buffer_size)
3623 if (STbuffer->buffer_size <= PAGE_SIZE)
3624 normalize_buffer(STbuffer); /* Avoid extra segment */
3626 max_segs = STbuffer->use_sg;
3627 nbr = max_segs - STbuffer->frp_segs;
3631 priority = GFP_KERNEL | __GFP_NOWARN;
3633 priority |= GFP_DMA;
3634 for (b_size = PAGE_SIZE, order=0; order <= 6 &&
3635 b_size < new_size - STbuffer->buffer_size;
3636 order++, b_size *= 2)
3639 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3640 segs < max_segs && got < new_size;) {
3641 STbuffer->frp[segs].page = alloc_pages(priority, order);
3642 if (STbuffer->frp[segs].page == NULL) {
3643 if (new_size - got <= (max_segs - segs) * b_size / 2) {
3644 b_size /= 2; /* Large enough for the rest of the buffers */
3648 DEB(STbuffer->buffer_size = got);
3649 normalize_buffer(STbuffer);
3652 STbuffer->frp[segs].length = b_size;
3653 STbuffer->frp_segs += 1;
3655 STbuffer->buffer_size = got;
3658 STbuffer->b_data = page_address(STbuffer->frp[0].page);
3664 /* Release the extra buffer */
3665 static void normalize_buffer(struct st_buffer * STbuffer)
3669 for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3670 order = get_order(STbuffer->frp[i].length);
3671 __free_pages(STbuffer->frp[i].page, order);
3672 STbuffer->buffer_size -= STbuffer->frp[i].length;
3674 STbuffer->frp_segs = STbuffer->orig_frp_segs;
3675 STbuffer->frp_sg_current = 0;
3676 STbuffer->sg_segs = 0;
3680 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3681 negative error code. */
3682 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3684 int i, cnt, res, offset;
3686 for (i = 0, offset = st_bp->buffer_bytes;
3687 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3688 offset -= st_bp->frp[i].length;
3689 if (i == st_bp->frp_segs) { /* Should never happen */
3690 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3693 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3694 cnt = st_bp->frp[i].length - offset < do_count ?
3695 st_bp->frp[i].length - offset : do_count;
3696 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3700 st_bp->buffer_bytes += cnt;
3704 if (do_count) /* Should never happen */
3711 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3712 negative error code. */
3713 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3715 int i, cnt, res, offset;
3717 for (i = 0, offset = st_bp->read_pointer;
3718 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3719 offset -= st_bp->frp[i].length;
3720 if (i == st_bp->frp_segs) { /* Should never happen */
3721 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3724 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3725 cnt = st_bp->frp[i].length - offset < do_count ?
3726 st_bp->frp[i].length - offset : do_count;
3727 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3731 st_bp->buffer_bytes -= cnt;
3732 st_bp->read_pointer += cnt;
3736 if (do_count) /* Should never happen */
3743 /* Move data towards start of buffer */
3744 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3746 int src_seg, dst_seg, src_offset = 0, dst_offset;
3752 total=st_bp->buffer_bytes - offset;
3753 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3754 src_offset = offset;
3755 if (src_offset < st_bp->frp[src_seg].length)
3757 offset -= st_bp->frp[src_seg].length;
3760 st_bp->buffer_bytes = st_bp->read_pointer = total;
3761 for (dst_seg=dst_offset=0; total > 0; ) {
3762 count = min(st_bp->frp[dst_seg].length - dst_offset,
3763 st_bp->frp[src_seg].length - src_offset);
3764 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3765 page_address(st_bp->frp[src_seg].page) + src_offset, count);
3766 src_offset += count;
3767 if (src_offset >= st_bp->frp[src_seg].length) {
3771 dst_offset += count;
3772 if (dst_offset >= st_bp->frp[dst_seg].length) {
3781 /* Fill the s/g list up to the length required for this transfer */
3782 static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
3786 struct scatterlist *sg;
3787 struct st_buf_fragment *frp;
3789 if (length == STbp->frp_sg_current)
3790 return; /* work already done */
3792 sg = &(STbp->sg[0]);
3794 for (i=count=0; count < length; i++) {
3795 sg[i].page = frp[i].page;
3796 if (length - count > frp[i].length)
3797 sg[i].length = frp[i].length;
3799 sg[i].length = length - count;
3800 count += sg[i].length;
3804 STbp->frp_sg_current = length;
3808 /* Validate the options from command line or module parameters */
3809 static void validate_options(void)
3812 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3813 if (max_sg_segs >= ST_FIRST_SG)
3814 st_max_sg_segs = max_sg_segs;
3818 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3820 static int __init st_setup(char *str)
3822 int i, len, ints[5];
3825 stp = get_options(str, ARRAY_SIZE(ints), ints);
3828 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3830 *parms[i].val = ints[i + 1];
3832 while (stp != NULL) {
3833 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3834 len = strlen(parms[i].name);
3835 if (!strncmp(stp, parms[i].name, len) &&
3836 (*(stp + len) == ':' || *(stp + len) == '=')) {
3839 simple_strtoul(stp + len + 1, NULL, 0);
3841 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3846 if (i >= ARRAY_SIZE(parms))
3847 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3849 stp = strchr(stp, ',');
3860 __setup("st=", st_setup);
3864 static struct file_operations st_fops =
3866 .owner = THIS_MODULE,
3870 #ifdef CONFIG_COMPAT
3871 .compat_ioctl = st_compat_ioctl,
3875 .release = st_release,
3878 static int st_probe(struct device *dev)
3880 struct scsi_device *SDp = to_scsi_device(dev);
3881 struct gendisk *disk = NULL;
3882 struct cdev *cdev = NULL;
3883 struct scsi_tape *tpnt = NULL;
3884 struct st_modedef *STm;
3885 struct st_partstat *STps;
3886 struct st_buffer *buffer;
3887 int i, j, mode, dev_num, error;
3890 if (SDp->type != TYPE_TAPE)
3892 if ((stp = st_incompatible(SDp))) {
3893 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
3894 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3898 i = min(SDp->request_queue->max_hw_segments,
3899 SDp->request_queue->max_phys_segments);
3900 if (st_max_sg_segs < i)
3902 buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i);
3903 if (buffer == NULL) {
3905 "st: Can't allocate new tape buffer. Device not attached.\n");
3909 disk = alloc_disk(1);
3911 printk(KERN_ERR "st: out of memory. Device not attached.\n");
3912 goto out_buffer_free;
3915 write_lock(&st_dev_arr_lock);
3916 if (st_nr_dev >= st_dev_max) {
3917 struct scsi_tape **tmp_da;
3920 tmp_dev_max = max(st_nr_dev * 2, 8);
3921 if (tmp_dev_max > ST_MAX_TAPES)
3922 tmp_dev_max = ST_MAX_TAPES;
3923 if (tmp_dev_max <= st_nr_dev) {
3924 write_unlock(&st_dev_arr_lock);
3925 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
3930 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
3931 if (tmp_da == NULL) {
3932 write_unlock(&st_dev_arr_lock);
3933 printk(KERN_ERR "st: Can't extend device array.\n");
3937 if (scsi_tapes != NULL) {
3938 memcpy(tmp_da, scsi_tapes,
3939 st_dev_max * sizeof(struct scsi_tape *));
3942 scsi_tapes = tmp_da;
3944 st_dev_max = tmp_dev_max;
3947 for (i = 0; i < st_dev_max; i++)
3948 if (scsi_tapes[i] == NULL)
3950 if (i >= st_dev_max)
3951 panic("scsi_devices corrupt (st)");
3953 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
3955 write_unlock(&st_dev_arr_lock);
3956 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
3959 kref_init(&tpnt->kref);
3961 sprintf(disk->disk_name, "st%d", i);
3962 disk->private_data = &tpnt->driver;
3963 disk->queue = SDp->request_queue;
3964 tpnt->driver = &st_template;
3965 scsi_tapes[i] = tpnt;
3969 if (SDp->scsi_level <= 2)
3970 tpnt->tape_type = MT_ISSCSI1;
3972 tpnt->tape_type = MT_ISSCSI2;
3974 tpnt->buffer = buffer;
3975 tpnt->buffer->last_SRpnt = NULL;
3980 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
3981 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
3982 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
3984 tpnt->do_auto_lock = ST_AUTO_LOCK;
3985 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
3986 tpnt->can_partitions = 0;
3987 tpnt->two_fm = ST_TWO_FM;
3988 tpnt->fast_mteom = ST_FAST_MTEOM;
3989 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
3990 tpnt->immediate = ST_NOWAIT;
3991 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
3992 tpnt->partition = 0;
3993 tpnt->new_partition = 0;
3994 tpnt->nbr_partitions = 0;
3995 tpnt->device->timeout = ST_TIMEOUT;
3996 tpnt->long_timeout = ST_LONG_TIMEOUT;
3997 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
3999 for (i = 0; i < ST_NBR_MODES; i++) {
4000 STm = &(tpnt->modes[i]);
4002 STm->sysv = ST_SYSV;
4003 STm->defaults_for_writes = 0;
4004 STm->do_async_writes = ST_ASYNC_WRITES;
4005 STm->do_buffer_writes = ST_BUFFER_WRITES;
4006 STm->do_read_ahead = ST_READ_AHEAD;
4007 STm->default_compression = ST_DONT_TOUCH;
4008 STm->default_blksize = (-1); /* No forced size */
4009 STm->default_density = (-1); /* No forced density */
4012 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4013 STps = &(tpnt->ps[i]);
4015 STps->eof = ST_NOEOF;
4017 STps->last_block_valid = 0;
4018 STps->drv_block = (-1);
4019 STps->drv_file = (-1);
4022 tpnt->current_mode = 0;
4023 tpnt->modes[0].defined = 1;
4025 tpnt->density_changed = tpnt->compression_changed =
4026 tpnt->blksize_changed = 0;
4027 init_MUTEX(&tpnt->lock);
4030 write_unlock(&st_dev_arr_lock);
4032 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4033 STm = &(tpnt->modes[mode]);
4034 for (j=0; j < 2; j++) {
4035 cdev = cdev_alloc();
4038 "st%d: out of memory. Device not attached.\n",
4042 cdev->owner = THIS_MODULE;
4043 cdev->ops = &st_fops;
4045 error = cdev_add(cdev,
4046 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4049 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4050 dev_num, j ? "non" : "auto", mode);
4051 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4054 STm->cdevs[j] = cdev;
4057 error = do_create_class_files(tpnt, dev_num, mode);
4062 sdev_printk(KERN_NOTICE, SDp,
4063 "Attached scsi tape %s\n", tape_name(tpnt));
4064 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4065 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4066 queue_dma_alignment(SDp->request_queue) + 1);
4071 for (mode=0; mode < ST_NBR_MODES; mode++) {
4072 STm = &(tpnt->modes[mode]);
4073 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4075 for (j=0; j < 2; j++) {
4076 if (STm->cdevs[j]) {
4077 if (cdev == STm->cdevs[j])
4079 class_device_destroy(st_sysfs_class,
4080 MKDEV(SCSI_TAPE_MAJOR,
4081 TAPE_MINOR(i, mode, j)));
4082 cdev_del(STm->cdevs[j]);
4088 write_lock(&st_dev_arr_lock);
4089 scsi_tapes[dev_num] = NULL;
4091 write_unlock(&st_dev_arr_lock);
4102 static int st_remove(struct device *dev)
4104 struct scsi_device *SDp = to_scsi_device(dev);
4105 struct scsi_tape *tpnt;
4108 write_lock(&st_dev_arr_lock);
4109 for (i = 0; i < st_dev_max; i++) {
4110 tpnt = scsi_tapes[i];
4111 if (tpnt != NULL && tpnt->device == SDp) {
4112 scsi_tapes[i] = NULL;
4114 write_unlock(&st_dev_arr_lock);
4115 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4117 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4118 for (j=0; j < 2; j++) {
4119 class_device_destroy(st_sysfs_class,
4120 MKDEV(SCSI_TAPE_MAJOR,
4121 TAPE_MINOR(i, mode, j)));
4122 cdev_del(tpnt->modes[mode].cdevs[j]);
4123 tpnt->modes[mode].cdevs[j] = NULL;
4127 mutex_lock(&st_ref_mutex);
4128 kref_put(&tpnt->kref, scsi_tape_release);
4129 mutex_unlock(&st_ref_mutex);
4134 write_unlock(&st_dev_arr_lock);
4139 * scsi_tape_release - Called to free the Scsi_Tape structure
4140 * @kref: pointer to embedded kref
4142 * st_ref_mutex must be held entering this routine. Because it is
4143 * called on last put, you should always use the scsi_tape_get()
4144 * scsi_tape_put() helpers which manipulate the semaphore directly
4145 * and never do a direct kref_put().
4147 static void scsi_tape_release(struct kref *kref)
4149 struct scsi_tape *tpnt = to_scsi_tape(kref);
4150 struct gendisk *disk = tpnt->disk;
4152 tpnt->device = NULL;
4155 tpnt->buffer->orig_frp_segs = 0;
4156 normalize_buffer(tpnt->buffer);
4157 kfree(tpnt->buffer);
4160 disk->private_data = NULL;
4166 static int __init init_st(void)
4172 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4173 verstr, st_fixed_buffer_size, st_max_sg_segs);
4175 st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
4176 if (IS_ERR(st_sysfs_class)) {
4177 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4178 return PTR_ERR(st_sysfs_class);
4181 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4182 ST_MAX_TAPE_ENTRIES, "st");
4184 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4189 err = scsi_register_driver(&st_template.gendrv);
4193 err = do_create_driverfs_files();
4200 scsi_unregister_driver(&st_template.gendrv);
4202 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4203 ST_MAX_TAPE_ENTRIES);
4205 class_destroy(st_sysfs_class);
4209 static void __exit exit_st(void)
4211 do_remove_driverfs_files();
4212 scsi_unregister_driver(&st_template.gendrv);
4213 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4214 ST_MAX_TAPE_ENTRIES);
4215 class_destroy(st_sysfs_class);
4217 printk(KERN_INFO "st: Unloaded.\n");
4220 module_init(init_st);
4221 module_exit(exit_st);
4224 /* The sysfs driver interface. Read-only at the moment */
4225 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4227 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4229 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4231 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4233 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4235 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4237 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4239 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4241 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4243 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4245 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4247 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4249 static int do_create_driverfs_files(void)
4251 struct device_driver *driverfs = &st_template.gendrv;
4254 err = driver_create_file(driverfs, &driver_attr_try_direct_io);
4257 err = driver_create_file(driverfs, &driver_attr_fixed_buffer_size);
4259 goto err_try_direct_io;
4260 err = driver_create_file(driverfs, &driver_attr_max_sg_segs);
4262 goto err_attr_fixed_buf;
4263 err = driver_create_file(driverfs, &driver_attr_version);
4265 goto err_attr_max_sg;
4270 driver_remove_file(driverfs, &driver_attr_max_sg_segs);
4272 driver_remove_file(driverfs, &driver_attr_fixed_buffer_size);
4274 driver_remove_file(driverfs, &driver_attr_try_direct_io);
4278 static void do_remove_driverfs_files(void)
4280 struct device_driver *driverfs = &st_template.gendrv;
4282 driver_remove_file(driverfs, &driver_attr_version);
4283 driver_remove_file(driverfs, &driver_attr_max_sg_segs);
4284 driver_remove_file(driverfs, &driver_attr_fixed_buffer_size);
4285 driver_remove_file(driverfs, &driver_attr_try_direct_io);
4289 /* The sysfs simple class interface */
4290 static ssize_t st_defined_show(struct class_device *class_dev, char *buf)
4292 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4295 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4299 CLASS_DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4301 static ssize_t st_defblk_show(struct class_device *class_dev, char *buf)
4303 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4306 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4310 CLASS_DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4312 static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf)
4314 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4318 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4319 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4323 CLASS_DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4325 static ssize_t st_defcompression_show(struct class_device *class_dev, char *buf)
4327 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4330 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4334 CLASS_DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4336 static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4340 struct class_device *st_class_member;
4342 for (rew=0; rew < 2; rew++) {
4343 /* Make sure that the minor numbers corresponding to the four
4344 first modes always get the same names */
4345 i = mode << (4 - ST_NBR_MODE_BITS);
4346 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4347 STp->disk->disk_name, st_formats[i]);
4349 class_device_create(st_sysfs_class, NULL,
4350 MKDEV(SCSI_TAPE_MAJOR,
4351 TAPE_MINOR(dev_num, mode, rew)),
4352 &STp->device->sdev_gendev, "%s", name);
4353 if (IS_ERR(st_class_member)) {
4354 printk(KERN_WARNING "st%d: class_device_create failed\n",
4356 error = PTR_ERR(st_class_member);
4359 class_set_devdata(st_class_member, &STp->modes[mode]);
4361 error = class_device_create_file(st_class_member,
4362 &class_device_attr_defined);
4363 if (error) goto out;
4364 error = class_device_create_file(st_class_member,
4365 &class_device_attr_default_blksize);
4366 if (error) goto out;
4367 error = class_device_create_file(st_class_member,
4368 &class_device_attr_default_density);
4369 if (error) goto out;
4370 error = class_device_create_file(st_class_member,
4371 &class_device_attr_default_compression);
4372 if (error) goto out;
4374 if (mode == 0 && rew == 0) {
4375 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4376 &st_class_member->kobj,
4380 "st%d: Can't create sysfs link from SCSI device.\n",
4393 /* The following functions may be useful for a larger audience. */
4394 static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4395 unsigned long uaddr, size_t count, int rw)
4397 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4398 unsigned long start = uaddr >> PAGE_SHIFT;
4399 const int nr_pages = end - start;
4401 struct page **pages;
4403 /* User attempted Overflow! */
4404 if ((uaddr + count) < uaddr)
4408 if (nr_pages > max_pages)
4415 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4418 /* Try to fault in all of the necessary pages */
4419 down_read(¤t->mm->mmap_sem);
4420 /* rw==READ means read from drive, write into memory area */
4421 res = get_user_pages(
4427 0, /* don't force */
4430 up_read(¤t->mm->mmap_sem);
4432 /* Errors and no page mapped should return here */
4436 for (i=0; i < nr_pages; i++) {
4437 /* FIXME: flush superflous for rw==READ,
4438 * probably wrong function for rw==WRITE
4440 flush_dcache_page(pages[i]);
4443 /* Populate the scatter/gather list */
4444 sgl[0].page = pages[0];
4445 sgl[0].offset = uaddr & ~PAGE_MASK;
4447 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4448 count -= sgl[0].length;
4449 for (i=1; i < nr_pages ; i++) {
4451 sgl[i].page = pages[i];
4452 sgl[i].length = count < PAGE_SIZE ? count : PAGE_SIZE;
4457 sgl[0].length = count;
4465 for (j=0; j < res; j++)
4466 page_cache_release(pages[j]);
4474 /* And unmap them... */
4475 static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4480 for (i=0; i < nr_pages; i++) {
4481 struct page *page = sgl[i].page;
4485 /* FIXME: cache flush missing for rw==READ
4486 * FIXME: call the correct reference counting function
4488 page_cache_release(page);