2 SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
3 file Documentation/scsi/st.txt for more information.
6 Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.
7 Contribution and ideas from several people including (in alphabetical
8 order) Klaus Ehrenfried, Eugene Exarevsky, Eric Lee Green, Wolfgang Denk,
9 Steve Hirsch, Andreas Koppenh"ofer, Michael Leodolter, Eyal Lebedinsky,
10 Michael Schaefer, J"org Weule, and Eric Youngdale.
12 Copyright 1992 - 2008 Kai Makisara
13 email Kai.Makisara@kolumbus.fi
15 Some small formal changes - aeb, 950809
17 Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
20 static const char *verstr = "20080504";
22 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/sched.h>
28 #include <linux/init.h>
29 #include <linux/string.h>
30 #include <linux/errno.h>
31 #include <linux/mtio.h>
32 #include <linux/cdrom.h>
33 #include <linux/ioctl.h>
34 #include <linux/fcntl.h>
35 #include <linux/spinlock.h>
36 #include <linux/blkdev.h>
37 #include <linux/moduleparam.h>
38 #include <linux/cdev.h>
39 #include <linux/delay.h>
40 #include <linux/mutex.h>
41 #include <linux/smp_lock.h>
43 #include <asm/uaccess.h>
45 #include <asm/system.h>
47 #include <scsi/scsi.h>
48 #include <scsi/scsi_dbg.h>
49 #include <scsi/scsi_device.h>
50 #include <scsi/scsi_driver.h>
51 #include <scsi/scsi_eh.h>
52 #include <scsi/scsi_host.h>
53 #include <scsi/scsi_ioctl.h>
57 /* The driver prints some debugging information on the console if DEBUG
58 is defined and non-zero. */
62 /* The message level for the debug messages is currently set to KERN_NOTICE
63 so that people can easily see the messages. Later when the debugging messages
64 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
65 #define ST_DEB_MSG KERN_NOTICE
67 #define DEBC(a) if (debugging) { a ; }
73 #define ST_KILOBYTE 1024
75 #include "st_options.h"
78 static int buffer_kbs;
79 static int max_sg_segs;
80 static int try_direct_io = TRY_DIRECT_IO;
81 static int try_rdio = 1;
82 static int try_wdio = 1;
84 static int st_dev_max;
87 static struct class *st_sysfs_class;
89 MODULE_AUTHOR("Kai Makisara");
90 MODULE_DESCRIPTION("SCSI tape (st) driver");
91 MODULE_LICENSE("GPL");
92 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
93 MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE);
95 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
96 * of sysfs parameters (which module_param doesn't yet support).
97 * Sysfs parameters defined explicitly later.
99 module_param_named(buffer_kbs, buffer_kbs, int, 0);
100 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
101 module_param_named(max_sg_segs, max_sg_segs, int, 0);
102 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
103 module_param_named(try_direct_io, try_direct_io, int, 0);
104 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
106 /* Extra parameters for testing */
107 module_param_named(try_rdio, try_rdio, int, 0);
108 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
109 module_param_named(try_wdio, try_wdio, int, 0);
110 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
113 static int write_threshold_kbs; /* retained for compatibility */
114 static struct st_dev_parm {
117 } parms[] __initdata = {
119 "buffer_kbs", &buffer_kbs
121 { /* Retained for compatibility with 2.4 */
122 "write_threshold_kbs", &write_threshold_kbs
128 "try_direct_io", &try_direct_io
133 /* Restrict the number of modes so that names for all are assigned */
134 #if ST_NBR_MODES > 16
135 #error "Maximum number of modes is 16"
137 /* Bit reversed order to get same names for same minors with all
139 static const char *st_formats[] = {
140 "", "r", "k", "s", "l", "t", "o", "u",
141 "m", "v", "p", "x", "a", "y", "q", "z"};
143 /* The default definitions have been moved to st_options.h */
145 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
147 /* The buffer size should fit into the 24 bits for length in the
148 6-byte SCSI read and write commands. */
149 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
150 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
153 static int debugging = DEBUG;
155 #define MAX_RETRIES 0
156 #define MAX_WRITE_RETRIES 0
157 #define MAX_READY_RETRIES 0
158 #define NO_TAPE NOT_READY
160 #define ST_TIMEOUT (900 * HZ)
161 #define ST_LONG_TIMEOUT (14000 * HZ)
163 /* Remove mode bits and auto-rewind bit (7) */
164 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
165 (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
166 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
168 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
169 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
170 (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
172 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
174 #define SET_DENS_AND_BLK 0x10001
176 static DEFINE_RWLOCK(st_dev_arr_lock);
178 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
179 static int st_max_sg_segs = ST_MAX_SG;
181 static struct scsi_tape **scsi_tapes = NULL;
183 static int modes_defined;
185 static struct st_buffer *new_tape_buffer(int, int, int);
186 static int enlarge_buffer(struct st_buffer *, int, int);
187 static void clear_buffer(struct st_buffer *);
188 static void normalize_buffer(struct st_buffer *);
189 static int append_to_buffer(const char __user *, struct st_buffer *, int);
190 static int from_buffer(struct st_buffer *, char __user *, int);
191 static void move_buffer_data(struct st_buffer *, int);
192 static void buf_to_sg(struct st_buffer *, unsigned int);
194 static int sgl_map_user_pages(struct scatterlist *, const unsigned int,
195 unsigned long, size_t, int);
196 static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int);
198 static int st_probe(struct device *);
199 static int st_remove(struct device *);
201 static int do_create_sysfs_files(void);
202 static void do_remove_sysfs_files(void);
203 static int do_create_class_files(struct scsi_tape *, int, int);
205 static struct scsi_driver st_template = {
206 .owner = THIS_MODULE,
214 static int st_compression(struct scsi_tape *, int);
216 static int find_partition(struct scsi_tape *);
217 static int switch_partition(struct scsi_tape *);
219 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
221 static void scsi_tape_release(struct kref *);
223 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
225 static DEFINE_MUTEX(st_ref_mutex);
228 #include "osst_detect.h"
229 #ifndef SIGS_FROM_OSST
230 #define SIGS_FROM_OSST \
231 {"OnStream", "SC-", "", "osst"}, \
232 {"OnStream", "DI-", "", "osst"}, \
233 {"OnStream", "DP-", "", "osst"}, \
234 {"OnStream", "USB", "", "osst"}, \
235 {"OnStream", "FW-", "", "osst"}
238 static struct scsi_tape *scsi_tape_get(int dev)
240 struct scsi_tape *STp = NULL;
242 mutex_lock(&st_ref_mutex);
243 write_lock(&st_dev_arr_lock);
245 if (dev < st_dev_max && scsi_tapes != NULL)
246 STp = scsi_tapes[dev];
249 kref_get(&STp->kref);
254 if (scsi_device_get(STp->device))
260 kref_put(&STp->kref, scsi_tape_release);
263 write_unlock(&st_dev_arr_lock);
264 mutex_unlock(&st_ref_mutex);
268 static void scsi_tape_put(struct scsi_tape *STp)
270 struct scsi_device *sdev = STp->device;
272 mutex_lock(&st_ref_mutex);
273 kref_put(&STp->kref, scsi_tape_release);
274 scsi_device_put(sdev);
275 mutex_unlock(&st_ref_mutex);
278 struct st_reject_data {
282 char *driver_hint; /* Name of the correct driver, NULL if unknown */
285 static struct st_reject_data reject_list[] = {
286 /* {"XXX", "Yy-", "", NULL}, example */
290 /* If the device signature is on the list of incompatible drives, the
291 function returns a pointer to the name of the correct driver (if known) */
292 static char * st_incompatible(struct scsi_device* SDp)
294 struct st_reject_data *rp;
296 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
297 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
298 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
299 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
301 return rp->driver_hint;
309 static inline char *tape_name(struct scsi_tape *tape)
311 return tape->disk->disk_name;
315 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
318 const u8 *sense = SRpnt->sense;
320 s->have_sense = scsi_normalize_sense(SRpnt->sense,
321 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
327 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
328 switch (sense[0] & 0x7f) {
333 s->flags = sense[2] & 0xe0;
339 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
340 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
347 /* Convert the result to success code */
348 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
350 int result = SRpnt->result;
352 DEB(const char *stp;)
353 char *name = tape_name(STp);
354 struct st_cmdstatus *cmdstatp;
359 cmdstatp = &STp->buffer->cmdstat;
360 st_analyze_sense(SRpnt, cmdstatp);
362 if (cmdstatp->have_sense)
363 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
369 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
371 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
372 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
373 if (cmdstatp->have_sense)
374 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
376 if (!debugging) { /* Abnormal conditions for tape */
377 if (!cmdstatp->have_sense)
379 "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
380 name, result, suggestion(result),
381 driver_byte(result) & DRIVER_MASK, host_byte(result));
382 else if (cmdstatp->have_sense &&
384 scode != RECOVERED_ERROR &&
385 /* scode != UNIT_ATTENTION && */
386 scode != BLANK_CHECK &&
387 scode != VOLUME_OVERFLOW &&
388 SRpnt->cmd[0] != MODE_SENSE &&
389 SRpnt->cmd[0] != TEST_UNIT_READY) {
391 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
395 if (cmdstatp->fixed_format &&
396 STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */
397 if (STp->cln_sense_value)
398 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
399 STp->cln_sense_mask) == STp->cln_sense_value);
401 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
402 STp->cln_sense_mask) != 0);
404 if (cmdstatp->have_sense &&
405 cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
406 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
408 STp->pos_unknown |= STp->device->was_reset;
410 if (cmdstatp->have_sense &&
411 scode == RECOVERED_ERROR
412 #if ST_RECOVERED_WRITE_FATAL
413 && SRpnt->cmd[0] != WRITE_6
414 && SRpnt->cmd[0] != WRITE_FILEMARKS
417 STp->recover_count++;
422 if (SRpnt->cmd[0] == READ_6)
424 else if (SRpnt->cmd[0] == WRITE_6)
428 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
432 if (cmdstatp->flags == 0)
439 /* Wakeup from interrupt */
440 static void st_sleep_done(void *data, char *sense, int result, int resid)
442 struct st_request *SRpnt = data;
443 struct scsi_tape *STp = SRpnt->stp;
445 memcpy(SRpnt->sense, sense, SCSI_SENSE_BUFFERSIZE);
446 (STp->buffer)->cmdstat.midlevel_result = SRpnt->result = result;
447 (STp->buffer)->cmdstat.residual = resid;
448 DEB( STp->write_pending = 0; )
451 complete(SRpnt->waiting);
454 static struct st_request *st_allocate_request(struct scsi_tape *stp)
456 struct st_request *streq;
458 streq = kzalloc(sizeof(*streq), GFP_KERNEL);
462 DEBC(printk(KERN_ERR "%s: Can't get SCSI request.\n",
464 if (signal_pending(current))
465 stp->buffer->syscall_result = -EINTR;
467 stp->buffer->syscall_result = -EBUSY;
473 static void st_release_request(struct st_request *streq)
478 /* Do the scsi command. Waits until command performed if do_wait is true.
479 Otherwise write_behind_check() is used to check that the command
481 static struct st_request *
482 st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
483 int bytes, int direction, int timeout, int retries, int do_wait)
485 struct completion *waiting;
487 /* if async, make sure there's no command outstanding */
488 if (!do_wait && ((STp->buffer)->last_SRpnt)) {
489 printk(KERN_ERR "%s: Async command already active.\n",
491 if (signal_pending(current))
492 (STp->buffer)->syscall_result = (-EINTR);
494 (STp->buffer)->syscall_result = (-EBUSY);
499 SRpnt = st_allocate_request(STp);
504 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
505 which IO is outstanding. It's nulled out when the IO completes. */
507 (STp->buffer)->last_SRpnt = SRpnt;
509 waiting = &STp->wait;
510 init_completion(waiting);
511 SRpnt->waiting = waiting;
513 if (!STp->buffer->do_dio)
514 buf_to_sg(STp->buffer, bytes);
516 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
517 STp->buffer->cmdstat.have_sense = 0;
518 STp->buffer->syscall_result = 0;
520 if (scsi_execute_async(STp->device, cmd, COMMAND_SIZE(cmd[0]), direction,
521 &((STp->buffer)->sg[0]), bytes, (STp->buffer)->sg_segs,
522 timeout, retries, SRpnt, st_sleep_done, GFP_KERNEL)) {
523 /* could not allocate the buffer or request was too large */
524 (STp->buffer)->syscall_result = (-EBUSY);
525 (STp->buffer)->last_SRpnt = NULL;
528 wait_for_completion(waiting);
529 SRpnt->waiting = NULL;
530 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
536 static int st_scsi_kern_execute(struct st_request *streq,
537 const unsigned char *cmd, int data_direction,
538 void *buffer, unsigned bufflen, int timeout,
541 struct scsi_tape *stp = streq->stp;
544 stp->buffer->cmdstat.have_sense = 0;
545 memcpy(streq->cmd, cmd, sizeof(streq->cmd));
547 ret = scsi_execute(stp->device, cmd, data_direction, buffer, bufflen,
548 streq->sense, timeout, retries, 0, &resid);
549 if (driver_byte(ret) & DRIVER_ERROR)
552 stp->buffer->cmdstat.midlevel_result = streq->result = ret;
553 stp->buffer->cmdstat.residual = resid;
554 stp->buffer->syscall_result = st_chk_result(stp, streq);
559 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
560 write has been correct but EOM early warning reached, -EIO if write ended in
561 error or zero if write successful. Asynchronous writes are used only in
562 variable block mode. */
563 static int write_behind_check(struct scsi_tape * STp)
566 struct st_buffer *STbuffer;
567 struct st_partstat *STps;
568 struct st_cmdstatus *cmdstatp;
569 struct st_request *SRpnt;
571 STbuffer = STp->buffer;
572 if (!STbuffer->writing)
576 if (STp->write_pending)
582 wait_for_completion(&(STp->wait));
583 SRpnt = STbuffer->last_SRpnt;
584 STbuffer->last_SRpnt = NULL;
585 SRpnt->waiting = NULL;
587 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
588 st_release_request(SRpnt);
590 STbuffer->buffer_bytes -= STbuffer->writing;
591 STps = &(STp->ps[STp->partition]);
592 if (STps->drv_block >= 0) {
593 if (STp->block_size == 0)
596 STps->drv_block += STbuffer->writing / STp->block_size;
599 cmdstatp = &STbuffer->cmdstat;
600 if (STbuffer->syscall_result) {
602 if (cmdstatp->have_sense && !cmdstatp->deferred &&
603 (cmdstatp->flags & SENSE_EOM) &&
604 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
605 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
606 /* EOM at write-behind, has all data been written? */
607 if (!cmdstatp->remainder_valid ||
608 cmdstatp->uremainder64 == 0)
612 STps->drv_block = -1;
614 STbuffer->writing = 0;
616 DEB(if (debugging && retval)
617 printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n",
618 tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
624 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
625 it messes up the block number). */
626 static int cross_eof(struct scsi_tape * STp, int forward)
628 struct st_request *SRpnt;
629 unsigned char cmd[MAX_COMMAND_SIZE];
633 cmd[1] = 0x01; /* Space FileMarks */
638 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
641 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
642 tape_name(STp), forward ? "forward" : "backward"));
644 SRpnt = st_allocate_request(STp);
646 return STp->buffer->syscall_result;
648 ret = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0,
649 STp->device->request_queue->rq_timeout,
654 ret = STp->buffer->syscall_result;
656 if ((STp->buffer)->cmdstat.midlevel_result != 0)
657 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
658 tape_name(STp), forward ? "forward" : "backward");
661 st_release_request(SRpnt);
667 /* Flush the write buffer (never need to write if variable blocksize). */
668 static int st_flush_write_buffer(struct scsi_tape * STp)
672 unsigned char cmd[MAX_COMMAND_SIZE];
673 struct st_request *SRpnt;
674 struct st_partstat *STps;
676 result = write_behind_check(STp);
681 if (STp->dirty == 1) {
683 transfer = STp->buffer->buffer_bytes;
684 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
685 tape_name(STp), transfer));
687 memset(cmd, 0, MAX_COMMAND_SIZE);
690 blks = transfer / STp->block_size;
695 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
696 STp->device->request_queue->rq_timeout,
697 MAX_WRITE_RETRIES, 1);
699 return (STp->buffer)->syscall_result;
701 STps = &(STp->ps[STp->partition]);
702 if ((STp->buffer)->syscall_result != 0) {
703 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
705 if (cmdstatp->have_sense && !cmdstatp->deferred &&
706 (cmdstatp->flags & SENSE_EOM) &&
707 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
708 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
709 (!cmdstatp->remainder_valid ||
710 cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
712 (STp->buffer)->buffer_bytes = 0;
713 if (STps->drv_block >= 0)
714 STps->drv_block += blks;
717 printk(KERN_ERR "%s: Error on flush.\n",
719 STps->drv_block = (-1);
723 if (STps->drv_block >= 0)
724 STps->drv_block += blks;
726 (STp->buffer)->buffer_bytes = 0;
728 st_release_request(SRpnt);
735 /* Flush the tape buffer. The tape will be positioned correctly unless
736 seek_next is true. */
737 static int flush_buffer(struct scsi_tape *STp, int seek_next)
739 int backspace, result;
740 struct st_buffer *STbuffer;
741 struct st_partstat *STps;
743 STbuffer = STp->buffer;
746 * If there was a bus reset, block further access
749 if (STp->pos_unknown)
752 if (STp->ready != ST_READY)
754 STps = &(STp->ps[STp->partition]);
755 if (STps->rw == ST_WRITING) /* Writing */
756 return st_flush_write_buffer(STp);
758 if (STp->block_size == 0)
761 backspace = ((STp->buffer)->buffer_bytes +
762 (STp->buffer)->read_pointer) / STp->block_size -
763 ((STp->buffer)->read_pointer + STp->block_size - 1) /
765 (STp->buffer)->buffer_bytes = 0;
766 (STp->buffer)->read_pointer = 0;
769 if (STps->eof == ST_FM_HIT) {
770 result = cross_eof(STp, 0); /* Back over the EOF hit */
772 STps->eof = ST_NOEOF;
774 if (STps->drv_file >= 0)
779 if (!result && backspace > 0)
780 result = st_int_ioctl(STp, MTBSR, backspace);
781 } else if (STps->eof == ST_FM_HIT) {
782 if (STps->drv_file >= 0)
785 STps->eof = ST_NOEOF;
791 /* Set the mode parameters */
792 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
796 char *name = tape_name(STp);
798 if (!STp->density_changed &&
799 STm->default_density >= 0 &&
800 STm->default_density != STp->density) {
801 arg = STm->default_density;
805 arg <<= MT_ST_DENSITY_SHIFT;
806 if (!STp->blksize_changed &&
807 STm->default_blksize >= 0 &&
808 STm->default_blksize != STp->block_size) {
809 arg |= STm->default_blksize;
812 arg |= STp->block_size;
814 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
816 "%s: Can't set default block size to %d bytes and density %x.\n",
817 name, STm->default_blksize, STm->default_density);
825 /* Lock or unlock the drive door. Don't use when st_request allocated. */
826 static int do_door_lock(struct scsi_tape * STp, int do_lock)
829 DEB(char *name = tape_name(STp);)
832 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
833 DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
834 do_lock ? "L" : "Unl"));
835 retval = scsi_ioctl(STp->device, cmd, NULL);
837 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
840 STp->door_locked = ST_LOCK_FAILS;
846 /* Set the internal state after reset */
847 static void reset_state(struct scsi_tape *STp)
850 struct st_partstat *STps;
852 STp->pos_unknown = 0;
853 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
854 STps = &(STp->ps[i]);
856 STps->eof = ST_NOEOF;
858 STps->last_block_valid = 0;
859 STps->drv_block = -1;
862 if (STp->can_partitions) {
863 STp->partition = find_partition(STp);
864 if (STp->partition < 0)
866 STp->new_partition = STp->partition;
870 /* Test if the drive is ready. Returns either one of the codes below or a negative system
872 #define CHKRES_READY 0
873 #define CHKRES_NEW_SESSION 1
874 #define CHKRES_NOT_READY 2
875 #define CHKRES_NO_TAPE 3
877 #define MAX_ATTENTIONS 10
879 static int test_ready(struct scsi_tape *STp, int do_wait)
881 int attentions, waits, max_wait, scode;
882 int retval = CHKRES_READY, new_session = 0;
883 unsigned char cmd[MAX_COMMAND_SIZE];
884 struct st_request *SRpnt;
885 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
887 SRpnt = st_allocate_request(STp);
889 return STp->buffer->syscall_result;
891 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
893 for (attentions=waits=0; ; ) {
894 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
895 cmd[0] = TEST_UNIT_READY;
897 retval = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0,
903 if (cmdstatp->have_sense) {
905 scode = cmdstatp->sense_hdr.sense_key;
907 if (scode == UNIT_ATTENTION) { /* New media? */
909 if (attentions < MAX_ATTENTIONS) {
919 if (scode == NOT_READY) {
920 if (waits < max_wait) {
921 if (msleep_interruptible(1000)) {
929 if ((STp->device)->scsi_level >= SCSI_2 &&
930 cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
931 retval = CHKRES_NO_TAPE;
933 retval = CHKRES_NOT_READY;
939 retval = (STp->buffer)->syscall_result;
941 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
945 st_release_request(SRpnt);
951 /* See if the drive is ready and gather information about the tape. Return values:
952 < 0 negative error code from errno.h
954 1 drive not ready (possibly no tape)
956 static int check_tape(struct scsi_tape *STp, struct file *filp)
958 int i, retval, new_session = 0, do_wait;
959 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
960 unsigned short st_flags = filp->f_flags;
961 struct st_request *SRpnt = NULL;
962 struct st_modedef *STm;
963 struct st_partstat *STps;
964 char *name = tape_name(STp);
965 struct inode *inode = filp->f_path.dentry->d_inode;
966 int mode = TAPE_MODE(inode);
968 STp->ready = ST_READY;
970 if (mode != STp->current_mode) {
971 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
972 name, STp->current_mode, mode));
974 STp->current_mode = mode;
976 STm = &(STp->modes[STp->current_mode]);
978 saved_cleaning = STp->cleaning_req;
979 STp->cleaning_req = 0;
981 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
982 retval = test_ready(STp, do_wait);
987 if (retval == CHKRES_NEW_SESSION) {
988 STp->pos_unknown = 0;
989 STp->partition = STp->new_partition = 0;
990 if (STp->can_partitions)
991 STp->nbr_partitions = 1; /* This guess will be updated later
993 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
994 STps = &(STp->ps[i]);
996 STps->eof = ST_NOEOF;
998 STps->last_block_valid = 0;
1005 STp->cleaning_req |= saved_cleaning;
1007 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
1008 if (retval == CHKRES_NO_TAPE)
1009 STp->ready = ST_NO_TAPE;
1011 STp->ready = ST_NOT_READY;
1013 STp->density = 0; /* Clear the erroneous "residue" */
1014 STp->write_prot = 0;
1015 STp->block_size = 0;
1016 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
1017 STp->partition = STp->new_partition = 0;
1018 STp->door_locked = ST_UNLOCKED;
1019 return CHKRES_NOT_READY;
1023 SRpnt = st_allocate_request(STp);
1025 retval = STp->buffer->syscall_result;
1029 if (STp->omit_blklims)
1030 STp->min_block = STp->max_block = (-1);
1032 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1033 cmd[0] = READ_BLOCK_LIMITS;
1035 retval = st_scsi_kern_execute(SRpnt, cmd, DMA_FROM_DEVICE,
1036 STp->buffer->b_data, 6,
1037 STp->device->request_queue->rq_timeout,
1040 st_release_request(SRpnt);
1044 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
1045 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1046 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1047 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1048 (STp->buffer)->b_data[5];
1049 if ( DEB( debugging || ) !STp->inited)
1051 "%s: Block limits %d - %d bytes.\n", name,
1052 STp->min_block, STp->max_block);
1054 STp->min_block = STp->max_block = (-1);
1055 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1060 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1061 cmd[0] = MODE_SENSE;
1064 retval = st_scsi_kern_execute(SRpnt, cmd, DMA_FROM_DEVICE,
1065 STp->buffer->b_data, 12,
1066 STp->device->request_queue->rq_timeout,
1069 st_release_request(SRpnt);
1073 if ((STp->buffer)->syscall_result != 0) {
1074 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1075 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
1076 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */
1077 STp->drv_write_prot = 0;
1079 DEBC(printk(ST_DEB_MSG
1080 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1082 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1083 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1085 if ((STp->buffer)->b_data[3] >= 8) {
1086 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1087 STp->density = (STp->buffer)->b_data[4];
1088 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1089 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1090 DEBC(printk(ST_DEB_MSG
1091 "%s: Density %x, tape length: %x, drv buffer: %d\n",
1092 name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1093 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1096 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1098 st_release_request(SRpnt);
1102 if (STp->block_size > 0)
1103 (STp->buffer)->buffer_blocks =
1104 (STp->buffer)->buffer_size / STp->block_size;
1106 (STp->buffer)->buffer_blocks = 1;
1107 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1109 DEBC(printk(ST_DEB_MSG
1110 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1111 STp->block_size, (STp->buffer)->buffer_size,
1112 (STp->buffer)->buffer_blocks));
1114 if (STp->drv_write_prot) {
1115 STp->write_prot = 1;
1117 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1120 ((st_flags & O_ACCMODE) == O_WRONLY ||
1121 (st_flags & O_ACCMODE) == O_RDWR)) {
1127 if (STp->can_partitions && STp->nbr_partitions < 1) {
1128 /* This code is reached when the device is opened for the first time
1129 after the driver has been initialized with tape in the drive and the
1130 partition support has been enabled. */
1131 DEBC(printk(ST_DEB_MSG
1132 "%s: Updating partition number in status.\n", name));
1133 if ((STp->partition = find_partition(STp)) < 0) {
1134 retval = STp->partition;
1137 STp->new_partition = STp->partition;
1138 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1141 if (new_session) { /* Change the drive parameters for the new mode */
1142 STp->density_changed = STp->blksize_changed = 0;
1143 STp->compression_changed = 0;
1144 if (!(STm->defaults_for_writes) &&
1145 (retval = set_mode_densblk(STp, STm)) < 0)
1148 if (STp->default_drvbuffer != 0xff) {
1149 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1151 "%s: Can't set default drive buffering to %d.\n",
1152 name, STp->default_drvbuffer);
1156 return CHKRES_READY;
1163 \f/* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1165 static int st_open(struct inode *inode, struct file *filp)
1167 int i, retval = (-EIO);
1168 struct scsi_tape *STp;
1169 struct st_partstat *STps;
1170 int dev = TAPE_NR(inode);
1175 * We really want to do nonseekable_open(inode, filp); here, but some
1176 * versions of tar incorrectly call lseek on tapes and bail out if that
1177 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1179 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1181 if (!(STp = scsi_tape_get(dev))) {
1186 write_lock(&st_dev_arr_lock);
1187 filp->private_data = STp;
1188 name = tape_name(STp);
1191 write_unlock(&st_dev_arr_lock);
1194 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1199 write_unlock(&st_dev_arr_lock);
1200 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1202 if (!scsi_block_when_processing_errors(STp->device)) {
1207 /* See that we have at least a one page buffer available */
1208 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1209 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1211 retval = (-EOVERFLOW);
1215 (STp->buffer)->cleared = 0;
1216 (STp->buffer)->writing = 0;
1217 (STp->buffer)->syscall_result = 0;
1219 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1222 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1223 STps = &(STp->ps[i]);
1226 STp->try_dio_now = STp->try_dio;
1227 STp->recover_count = 0;
1228 DEB( STp->nbr_waits = STp->nbr_finished = 0;
1229 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
1231 retval = check_tape(STp, filp);
1234 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1235 retval != CHKRES_READY) {
1236 if (STp->ready == NO_TAPE)
1237 retval = (-ENOMEDIUM);
1246 normalize_buffer(STp->buffer);
1255 /* Flush the tape buffer before close */
1256 static int st_flush(struct file *filp, fl_owner_t id)
1258 int result = 0, result2;
1259 unsigned char cmd[MAX_COMMAND_SIZE];
1260 struct st_request *SRpnt;
1261 struct scsi_tape *STp = filp->private_data;
1262 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1263 struct st_partstat *STps = &(STp->ps[STp->partition]);
1264 char *name = tape_name(STp);
1266 if (file_count(filp) > 1)
1269 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1270 result = st_flush_write_buffer(STp);
1271 if (result != 0 && result != (-ENOSPC))
1275 if (STp->can_partitions &&
1276 (result2 = switch_partition(STp)) < 0) {
1277 DEBC(printk(ST_DEB_MSG
1278 "%s: switch_partition at close failed.\n", name));
1284 DEBC( if (STp->nbr_requests)
1285 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n",
1286 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages));
1288 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1289 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1291 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1292 name, STp->nbr_waits, STp->nbr_finished);
1295 memset(cmd, 0, MAX_COMMAND_SIZE);
1296 cmd[0] = WRITE_FILEMARKS;
1297 cmd[4] = 1 + STp->two_fm;
1299 SRpnt = st_allocate_request(STp);
1301 result = STp->buffer->syscall_result;
1305 result = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0,
1306 STp->device->request_queue->rq_timeout,
1309 st_release_request(SRpnt);
1313 if (STp->buffer->syscall_result == 0 ||
1314 (cmdstatp->have_sense && !cmdstatp->deferred &&
1315 (cmdstatp->flags & SENSE_EOM) &&
1316 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1317 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1318 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1319 /* Write successful at EOM */
1320 st_release_request(SRpnt);
1322 if (STps->drv_file >= 0)
1324 STps->drv_block = 0;
1329 else { /* Write error */
1330 st_release_request(SRpnt);
1332 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1337 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1339 } else if (!STp->rew_at_close) {
1340 STps = &(STp->ps[STp->partition]);
1341 if (!STm->sysv || STps->rw != ST_READING) {
1343 result = flush_buffer(STp, 0);
1344 else if (STps->eof == ST_FM_HIT) {
1345 result = cross_eof(STp, 0);
1347 if (STps->drv_file >= 0)
1349 STps->drv_block = 0;
1352 STps->eof = ST_NOEOF;
1354 } else if ((STps->eof == ST_NOEOF &&
1355 !(result = cross_eof(STp, 1))) ||
1356 STps->eof == ST_FM_HIT) {
1357 if (STps->drv_file >= 0)
1359 STps->drv_block = 0;
1365 if (STp->rew_at_close) {
1366 result2 = st_int_ioctl(STp, MTREW, 1);
1374 /* Close the device and release it. BKL is not needed: this is the only thread
1375 accessing this tape. */
1376 static int st_release(struct inode *inode, struct file *filp)
1379 struct scsi_tape *STp = filp->private_data;
1381 if (STp->door_locked == ST_LOCKED_AUTO)
1382 do_door_lock(STp, 0);
1384 normalize_buffer(STp->buffer);
1385 write_lock(&st_dev_arr_lock);
1387 write_unlock(&st_dev_arr_lock);
1393 /* The checks common to both reading and writing */
1394 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1399 * If we are in the middle of error recovery, don't let anyone
1400 * else try and use this device. Also, if error recovery fails, it
1401 * may try and take the device offline, in which case all further
1402 * access to the device is prohibited.
1404 if (!scsi_block_when_processing_errors(STp->device)) {
1409 if (STp->ready != ST_READY) {
1410 if (STp->ready == ST_NO_TAPE)
1411 retval = (-ENOMEDIUM);
1417 if (! STp->modes[STp->current_mode].defined) {
1424 * If there was a bus reset, block further access
1427 if (STp->pos_unknown) {
1437 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1442 if (STp->can_partitions &&
1443 (retval = switch_partition(STp)) < 0)
1446 if (STp->block_size == 0 && STp->max_block > 0 &&
1447 (count < STp->min_block || count > STp->max_block)) {
1452 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1453 !do_door_lock(STp, 1))
1454 STp->door_locked = ST_LOCKED_AUTO;
1461 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1462 size_t count, int is_read)
1464 int i, bufsize, retval = 0;
1465 struct st_buffer *STbp = STp->buffer;
1468 i = STp->try_dio_now && try_rdio;
1470 i = STp->try_dio_now && try_wdio;
1472 if (i && ((unsigned long)buf & queue_dma_alignment(
1473 STp->device->request_queue)) == 0) {
1474 i = sgl_map_user_pages(&(STbp->sg[0]), STbp->use_sg,
1475 (unsigned long)buf, count, (is_read ? READ : WRITE));
1478 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1481 STbp->do_dio = 0; /* fall back to buffering with any error */
1482 STbp->sg_segs = STbp->do_dio;
1483 STbp->frp_sg_current = 0;
1487 STp->nbr_pages += STbp->do_dio;
1492 DEB( STp->nbr_requests++; )
1494 if (!STbp->do_dio) {
1495 if (STp->block_size)
1496 bufsize = STp->block_size > st_fixed_buffer_size ?
1497 STp->block_size : st_fixed_buffer_size;
1500 /* Make sure that data from previous user is not leaked even if
1501 HBA does not return correct residual */
1502 if (is_read && STp->sili && !STbp->cleared)
1506 if (bufsize > STbp->buffer_size &&
1507 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1508 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1509 tape_name(STp), bufsize);
1510 retval = (-EOVERFLOW);
1513 if (STp->block_size)
1514 STbp->buffer_blocks = bufsize / STp->block_size;
1522 /* Can be called more than once after each setup_buffer() */
1523 static void release_buffering(struct scsi_tape *STp, int is_read)
1525 struct st_buffer *STbp;
1529 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, is_read);
1538 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1541 ssize_t i, do_count, blks, transfer;
1543 int undone, retry_eot = 0, scode;
1545 unsigned char cmd[MAX_COMMAND_SIZE];
1546 const char __user *b_point;
1547 struct st_request *SRpnt = NULL;
1548 struct scsi_tape *STp = filp->private_data;
1549 struct st_modedef *STm;
1550 struct st_partstat *STps;
1551 struct st_buffer *STbp;
1552 char *name = tape_name(STp);
1554 if (mutex_lock_interruptible(&STp->lock))
1555 return -ERESTARTSYS;
1557 retval = rw_checks(STp, filp, count);
1558 if (retval || count == 0)
1561 /* Write must be integral number of blocks */
1562 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1563 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1569 STm = &(STp->modes[STp->current_mode]);
1570 STps = &(STp->ps[STp->partition]);
1572 if (STp->write_prot) {
1578 if (STps->rw == ST_READING) {
1579 retval = flush_buffer(STp, 0);
1582 STps->rw = ST_WRITING;
1583 } else if (STps->rw != ST_WRITING &&
1584 STps->drv_file == 0 && STps->drv_block == 0) {
1585 if ((retval = set_mode_densblk(STp, STm)) < 0)
1587 if (STm->default_compression != ST_DONT_TOUCH &&
1588 !(STp->compression_changed)) {
1589 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1590 printk(KERN_WARNING "%s: Can't set default compression.\n",
1592 if (modes_defined) {
1601 i = write_behind_check(STp);
1604 STps->eof = ST_EOM_OK;
1606 STps->eof = ST_EOM_ERROR;
1609 if (STps->eof == ST_EOM_OK) {
1610 STps->eof = ST_EOD_1; /* allow next write */
1614 else if (STps->eof == ST_EOM_ERROR) {
1619 /* Check the buffer readability in cases where copy_user might catch
1620 the problems after some tape movement. */
1621 if (STp->block_size != 0 &&
1623 (copy_from_user(&i, buf, 1) != 0 ||
1624 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1629 retval = setup_buffering(STp, buf, count, 0);
1635 memset(cmd, 0, MAX_COMMAND_SIZE);
1637 cmd[1] = (STp->block_size != 0);
1639 STps->rw = ST_WRITING;
1642 while (count > 0 && !retry_eot) {
1648 if (STp->block_size == 0)
1651 do_count = STbp->buffer_blocks * STp->block_size -
1653 if (do_count > count)
1657 i = append_to_buffer(b_point, STbp, do_count);
1664 b_point += do_count;
1666 async_write = STp->block_size == 0 && !STbp->do_dio &&
1667 STm->do_async_writes && STps->eof < ST_EOM_OK;
1669 if (STp->block_size != 0 && STm->do_buffer_writes &&
1670 !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1671 STbp->buffer_bytes < STbp->buffer_size) {
1673 /* Don't write a buffer that is not full enough. */
1674 if (!async_write && count == 0)
1679 if (STp->block_size == 0)
1680 blks = transfer = do_count;
1683 blks = STbp->buffer_bytes;
1686 blks /= STp->block_size;
1687 transfer = blks * STp->block_size;
1689 cmd[2] = blks >> 16;
1693 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1694 STp->device->request_queue->rq_timeout,
1695 MAX_WRITE_RETRIES, !async_write);
1697 retval = STbp->syscall_result;
1700 if (async_write && !STbp->syscall_result) {
1701 STbp->writing = transfer;
1702 STp->dirty = !(STbp->writing ==
1703 STbp->buffer_bytes);
1704 SRpnt = NULL; /* Prevent releasing this request! */
1705 DEB( STp->write_pending = 1; )
1709 if (STbp->syscall_result != 0) {
1710 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1712 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1713 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1714 scode = cmdstatp->sense_hdr.sense_key;
1715 if (cmdstatp->remainder_valid)
1716 undone = (int)cmdstatp->uremainder64;
1717 else if (STp->block_size == 0 &&
1718 scode == VOLUME_OVERFLOW)
1722 if (STp->block_size != 0)
1723 undone *= STp->block_size;
1724 if (undone <= do_count) {
1725 /* Only data from this write is not written */
1729 if (STp->block_size)
1730 blks = (transfer - undone) / STp->block_size;
1731 STps->eof = ST_EOM_OK;
1732 /* Continue in fixed block mode if all written
1733 in this request but still something left to write
1734 (retval left to zero)
1736 if (STp->block_size == 0 ||
1737 undone > 0 || count == 0)
1738 retval = (-ENOSPC); /* EOM within current request */
1739 DEBC(printk(ST_DEB_MSG
1740 "%s: EOM with %d bytes unwritten.\n",
1743 /* EOT within data buffered earlier (possible only
1744 in fixed block mode without direct i/o) */
1745 if (!retry_eot && !cmdstatp->deferred &&
1746 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1747 move_buffer_data(STp->buffer, transfer - undone);
1749 if (STps->drv_block >= 0) {
1750 STps->drv_block += (transfer - undone) /
1753 STps->eof = ST_EOM_OK;
1754 DEBC(printk(ST_DEB_MSG
1755 "%s: Retry write of %d bytes at EOM.\n",
1756 name, STp->buffer->buffer_bytes));
1760 /* Either error within data buffered by driver or
1763 blks = do_count = 0;
1764 STps->eof = ST_EOM_ERROR;
1765 STps->drv_block = (-1); /* Too cautious? */
1766 retval = (-EIO); /* EOM for old data */
1767 DEBC(printk(ST_DEB_MSG
1768 "%s: EOM with lost data.\n",
1774 STps->drv_block = (-1); /* Too cautious? */
1775 retval = STbp->syscall_result;
1780 if (STps->drv_block >= 0) {
1781 if (STp->block_size == 0)
1782 STps->drv_block += (do_count > 0);
1784 STps->drv_block += blks;
1787 STbp->buffer_bytes = 0;
1790 if (retval || retry_eot) {
1792 retval = total - count;
1797 if (STps->eof == ST_EOD_1)
1798 STps->eof = ST_EOM_OK;
1799 else if (STps->eof != ST_EOM_OK)
1800 STps->eof = ST_NOEOF;
1801 retval = total - count;
1805 st_release_request(SRpnt);
1806 release_buffering(STp, 0);
1807 mutex_unlock(&STp->lock);
1812 /* Read data from the tape. Returns zero in the normal case, one if the
1813 eof status has changed, and the negative error code in case of a
1814 fatal error. Otherwise updates the buffer and the eof state.
1816 Does release user buffer mapping if it is set.
1818 static long read_tape(struct scsi_tape *STp, long count,
1819 struct st_request ** aSRpnt)
1821 int transfer, blks, bytes;
1822 unsigned char cmd[MAX_COMMAND_SIZE];
1823 struct st_request *SRpnt;
1824 struct st_modedef *STm;
1825 struct st_partstat *STps;
1826 struct st_buffer *STbp;
1828 char *name = tape_name(STp);
1833 STm = &(STp->modes[STp->current_mode]);
1834 STps = &(STp->ps[STp->partition]);
1835 if (STps->eof == ST_FM_HIT)
1839 if (STp->block_size == 0)
1840 blks = bytes = count;
1842 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1843 blks = (STp->buffer)->buffer_blocks;
1844 bytes = blks * STp->block_size;
1847 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1848 bytes = (STp->buffer)->buffer_size;
1849 blks = bytes / STp->block_size;
1850 bytes = blks * STp->block_size;
1854 memset(cmd, 0, MAX_COMMAND_SIZE);
1856 cmd[1] = (STp->block_size != 0);
1857 if (!cmd[1] && STp->sili)
1859 cmd[2] = blks >> 16;
1864 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1865 STp->device->request_queue->rq_timeout,
1867 release_buffering(STp, 1);
1870 return STbp->syscall_result;
1872 STbp->read_pointer = 0;
1875 /* Something to check */
1876 if (STbp->syscall_result) {
1877 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1880 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1882 SRpnt->sense[0], SRpnt->sense[1],
1883 SRpnt->sense[2], SRpnt->sense[3],
1884 SRpnt->sense[4], SRpnt->sense[5],
1885 SRpnt->sense[6], SRpnt->sense[7]));
1886 if (cmdstatp->have_sense) {
1888 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1889 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1891 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1892 /* Compute the residual count */
1893 if (cmdstatp->remainder_valid)
1894 transfer = (int)cmdstatp->uremainder64;
1897 if (STp->block_size == 0 &&
1898 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1901 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
1902 if (STp->block_size == 0) {
1903 if (transfer <= 0) {
1906 "%s: Failed to read %d byte block with %d byte transfer.\n",
1907 name, bytes - transfer, bytes);
1908 if (STps->drv_block >= 0)
1909 STps->drv_block += 1;
1910 STbp->buffer_bytes = 0;
1913 STbp->buffer_bytes = bytes - transfer;
1915 st_release_request(SRpnt);
1916 SRpnt = *aSRpnt = NULL;
1917 if (transfer == blks) { /* We did not get anything, error */
1918 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1919 if (STps->drv_block >= 0)
1920 STps->drv_block += blks - transfer + 1;
1921 st_int_ioctl(STp, MTBSR, 1);
1924 /* We have some data, deliver it */
1925 STbp->buffer_bytes = (blks - transfer) *
1927 DEBC(printk(ST_DEB_MSG
1928 "%s: ILI but enough data received %ld %d.\n",
1929 name, count, STbp->buffer_bytes));
1930 if (STps->drv_block >= 0)
1931 STps->drv_block += 1;
1932 if (st_int_ioctl(STp, MTBSR, 1))
1935 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
1936 if (STps->eof != ST_FM_HIT)
1937 STps->eof = ST_FM_HIT;
1939 STps->eof = ST_EOD_2;
1940 if (STp->block_size == 0)
1941 STbp->buffer_bytes = 0;
1943 STbp->buffer_bytes =
1944 bytes - transfer * STp->block_size;
1945 DEBC(printk(ST_DEB_MSG
1946 "%s: EOF detected (%d bytes read).\n",
1947 name, STbp->buffer_bytes));
1948 } else if (cmdstatp->flags & SENSE_EOM) {
1949 if (STps->eof == ST_FM)
1950 STps->eof = ST_EOD_1;
1952 STps->eof = ST_EOM_OK;
1953 if (STp->block_size == 0)
1954 STbp->buffer_bytes = bytes - transfer;
1956 STbp->buffer_bytes =
1957 bytes - transfer * STp->block_size;
1959 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1960 name, STbp->buffer_bytes));
1963 /* end of EOF, EOM, ILI test */
1964 else { /* nonzero sense key */
1965 DEBC(printk(ST_DEB_MSG
1966 "%s: Tape error while reading.\n", name));
1967 STps->drv_block = (-1);
1968 if (STps->eof == ST_FM &&
1969 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1970 DEBC(printk(ST_DEB_MSG
1971 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1973 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1974 } else /* Some other extended sense code */
1978 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
1979 STbp->buffer_bytes = 0;
1981 /* End of extended sense test */
1982 else { /* Non-extended sense */
1983 retval = STbp->syscall_result;
1987 /* End of error handling */
1988 else { /* Read successful */
1989 STbp->buffer_bytes = bytes;
1990 if (STp->sili) /* In fixed block mode residual is always zero here */
1991 STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
1994 if (STps->drv_block >= 0) {
1995 if (STp->block_size == 0)
1998 STps->drv_block += STbp->buffer_bytes / STp->block_size;
2006 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
2010 ssize_t i, transfer;
2011 int special, do_dio = 0;
2012 struct st_request *SRpnt = NULL;
2013 struct scsi_tape *STp = filp->private_data;
2014 struct st_modedef *STm;
2015 struct st_partstat *STps;
2016 struct st_buffer *STbp = STp->buffer;
2017 DEB( char *name = tape_name(STp); )
2019 if (mutex_lock_interruptible(&STp->lock))
2020 return -ERESTARTSYS;
2022 retval = rw_checks(STp, filp, count);
2023 if (retval || count == 0)
2026 STm = &(STp->modes[STp->current_mode]);
2027 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
2028 if (!STm->do_read_ahead) {
2029 retval = (-EINVAL); /* Read must be integral number of blocks */
2032 STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */
2035 STps = &(STp->ps[STp->partition]);
2036 if (STps->rw == ST_WRITING) {
2037 retval = flush_buffer(STp, 0);
2040 STps->rw = ST_READING;
2043 if (debugging && STps->eof != ST_NOEOF)
2044 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
2045 STps->eof, STbp->buffer_bytes);
2048 retval = setup_buffering(STp, buf, count, 1);
2051 do_dio = STbp->do_dio;
2053 if (STbp->buffer_bytes == 0 &&
2054 STps->eof >= ST_EOD_1) {
2055 if (STps->eof < ST_EOD) {
2060 retval = (-EIO); /* EOM or Blank Check */
2065 /* Check the buffer writability before any tape movement. Don't alter
2067 if (copy_from_user(&i, buf, 1) != 0 ||
2068 copy_to_user(buf, &i, 1) != 0 ||
2069 copy_from_user(&i, buf + count - 1, 1) != 0 ||
2070 copy_to_user(buf + count - 1, &i, 1) != 0) {
2076 STps->rw = ST_READING;
2079 /* Loop until enough data in buffer or a special condition found */
2080 for (total = 0, special = 0; total < count && !special;) {
2082 /* Get new data if the buffer is empty */
2083 if (STbp->buffer_bytes == 0) {
2084 special = read_tape(STp, count - total, &SRpnt);
2085 if (special < 0) { /* No need to continue read */
2091 /* Move the data from driver buffer to user buffer */
2092 if (STbp->buffer_bytes > 0) {
2094 if (debugging && STps->eof != ST_NOEOF)
2096 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2097 STps->eof, STbp->buffer_bytes,
2098 (int)(count - total));
2100 transfer = STbp->buffer_bytes < count - total ?
2101 STbp->buffer_bytes : count - total;
2103 i = from_buffer(STbp, buf, transfer);
2113 if (STp->block_size == 0)
2114 break; /* Read only one variable length block */
2116 } /* for (total = 0, special = 0;
2117 total < count && !special; ) */
2119 /* Change the eof state if no data from tape or buffer */
2121 if (STps->eof == ST_FM_HIT) {
2123 STps->drv_block = 0;
2124 if (STps->drv_file >= 0)
2126 } else if (STps->eof == ST_EOD_1) {
2127 STps->eof = ST_EOD_2;
2128 STps->drv_block = 0;
2129 if (STps->drv_file >= 0)
2131 } else if (STps->eof == ST_EOD_2)
2133 } else if (STps->eof == ST_FM)
2134 STps->eof = ST_NOEOF;
2138 if (SRpnt != NULL) {
2139 st_release_request(SRpnt);
2143 release_buffering(STp, 1);
2144 STbp->buffer_bytes = 0;
2146 mutex_unlock(&STp->lock);
2154 /* Set the driver options */
2155 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2159 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2160 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2161 STm->do_read_ahead);
2163 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2164 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2166 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2167 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2168 STp->scsi2_logical);
2170 "%s: sysv: %d nowait: %d sili: %d\n", name, STm->sysv, STp->immediate,
2172 printk(KERN_INFO "%s: debugging: %d\n",
2179 static int st_set_options(struct scsi_tape *STp, long options)
2183 struct st_modedef *STm;
2184 char *name = tape_name(STp);
2185 struct cdev *cd0, *cd1;
2187 STm = &(STp->modes[STp->current_mode]);
2188 if (!STm->defined) {
2189 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2190 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2191 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2193 DEBC(printk(ST_DEB_MSG
2194 "%s: Initialized mode %d definition from mode 0\n",
2195 name, STp->current_mode));
2198 code = options & MT_ST_OPTIONS;
2199 if (code == MT_ST_BOOLEANS) {
2200 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2201 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2202 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2203 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2204 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2205 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2206 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2207 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2208 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2209 if ((STp->device)->scsi_level >= SCSI_2)
2210 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2211 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2212 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2213 STm->sysv = (options & MT_ST_SYSV) != 0;
2214 STp->sili = (options & MT_ST_SILI) != 0;
2215 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2216 st_log_options(STp, STm, name); )
2217 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2218 value = (code == MT_ST_SETBOOLEANS);
2219 if ((options & MT_ST_BUFFER_WRITES) != 0)
2220 STm->do_buffer_writes = value;
2221 if ((options & MT_ST_ASYNC_WRITES) != 0)
2222 STm->do_async_writes = value;
2223 if ((options & MT_ST_DEF_WRITES) != 0)
2224 STm->defaults_for_writes = value;
2225 if ((options & MT_ST_READ_AHEAD) != 0)
2226 STm->do_read_ahead = value;
2227 if ((options & MT_ST_TWO_FM) != 0)
2228 STp->two_fm = value;
2229 if ((options & MT_ST_FAST_MTEOM) != 0)
2230 STp->fast_mteom = value;
2231 if ((options & MT_ST_AUTO_LOCK) != 0)
2232 STp->do_auto_lock = value;
2233 if ((options & MT_ST_CAN_BSR) != 0)
2234 STp->can_bsr = value;
2235 if ((options & MT_ST_NO_BLKLIMS) != 0)
2236 STp->omit_blklims = value;
2237 if ((STp->device)->scsi_level >= SCSI_2 &&
2238 (options & MT_ST_CAN_PARTITIONS) != 0)
2239 STp->can_partitions = value;
2240 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2241 STp->scsi2_logical = value;
2242 if ((options & MT_ST_NOWAIT) != 0)
2243 STp->immediate = value;
2244 if ((options & MT_ST_SYSV) != 0)
2246 if ((options & MT_ST_SILI) != 0)
2249 if ((options & MT_ST_DEBUGGING) != 0)
2251 st_log_options(STp, STm, name); )
2252 } else if (code == MT_ST_WRITE_THRESHOLD) {
2253 /* Retained for compatibility */
2254 } else if (code == MT_ST_DEF_BLKSIZE) {
2255 value = (options & ~MT_ST_OPTIONS);
2256 if (value == ~MT_ST_OPTIONS) {
2257 STm->default_blksize = (-1);
2258 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2260 STm->default_blksize = value;
2261 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2262 name, STm->default_blksize));
2263 if (STp->ready == ST_READY) {
2264 STp->blksize_changed = 0;
2265 set_mode_densblk(STp, STm);
2268 } else if (code == MT_ST_TIMEOUTS) {
2269 value = (options & ~MT_ST_OPTIONS);
2270 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2271 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2272 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2273 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2275 blk_queue_rq_timeout(STp->device->request_queue,
2277 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2280 } else if (code == MT_ST_SET_CLN) {
2281 value = (options & ~MT_ST_OPTIONS) & 0xff;
2283 value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2285 STp->cln_mode = value;
2286 STp->cln_sense_mask = (options >> 8) & 0xff;
2287 STp->cln_sense_value = (options >> 16) & 0xff;
2289 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2290 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2291 } else if (code == MT_ST_DEF_OPTIONS) {
2292 code = (options & ~MT_ST_CLEAR_DEFAULT);
2293 value = (options & MT_ST_CLEAR_DEFAULT);
2294 if (code == MT_ST_DEF_DENSITY) {
2295 if (value == MT_ST_CLEAR_DEFAULT) {
2296 STm->default_density = (-1);
2297 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2300 STm->default_density = value & 0xff;
2301 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2302 name, STm->default_density));
2303 if (STp->ready == ST_READY) {
2304 STp->density_changed = 0;
2305 set_mode_densblk(STp, STm);
2308 } else if (code == MT_ST_DEF_DRVBUFFER) {
2309 if (value == MT_ST_CLEAR_DEFAULT) {
2310 STp->default_drvbuffer = 0xff;
2311 DEBC( printk(KERN_INFO
2312 "%s: Drive buffer default disabled.\n", name));
2314 STp->default_drvbuffer = value & 7;
2315 DEBC( printk(KERN_INFO
2316 "%s: Drive buffer default set to %x\n",
2317 name, STp->default_drvbuffer));
2318 if (STp->ready == ST_READY)
2319 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2321 } else if (code == MT_ST_DEF_COMPRESSION) {
2322 if (value == MT_ST_CLEAR_DEFAULT) {
2323 STm->default_compression = ST_DONT_TOUCH;
2324 DEBC( printk(KERN_INFO
2325 "%s: Compression default disabled.\n", name));
2327 if ((value & 0xff00) != 0) {
2328 STp->c_algo = (value & 0xff00) >> 8;
2329 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2330 name, STp->c_algo));
2332 if ((value & 0xff) != 0xff) {
2333 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2334 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2335 name, (value & 1)));
2336 if (STp->ready == ST_READY) {
2337 STp->compression_changed = 0;
2338 st_compression(STp, (STm->default_compression == ST_YES));
2349 #define MODE_HEADER_LENGTH 4
2351 /* Mode header and page byte offsets */
2352 #define MH_OFF_DATA_LENGTH 0
2353 #define MH_OFF_MEDIUM_TYPE 1
2354 #define MH_OFF_DEV_SPECIFIC 2
2355 #define MH_OFF_BDESCS_LENGTH 3
2356 #define MP_OFF_PAGE_NBR 0
2357 #define MP_OFF_PAGE_LENGTH 1
2359 /* Mode header and page bit masks */
2360 #define MH_BIT_WP 0x80
2361 #define MP_MSK_PAGE_NBR 0x3f
2363 /* Don't return block descriptors */
2364 #define MODE_SENSE_OMIT_BDESCS 0x08
2366 #define MODE_SELECT_PAGE_FORMAT 0x10
2368 /* Read a mode page into the tape buffer. The block descriptors are included
2369 if incl_block_descs is true. The page control is ored to the page number
2370 parameter, if necessary. */
2371 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2373 unsigned char cmd[MAX_COMMAND_SIZE];
2374 struct st_request *SRpnt;
2377 memset(cmd, 0, MAX_COMMAND_SIZE);
2378 cmd[0] = MODE_SENSE;
2379 if (omit_block_descs)
2380 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2384 SRpnt = st_allocate_request(STp);
2386 return STp->buffer->syscall_result;
2388 ret = st_scsi_kern_execute(SRpnt, cmd, DMA_FROM_DEVICE,
2389 STp->buffer->b_data, cmd[4],
2390 STp->device->request_queue->rq_timeout,
2392 st_release_request(SRpnt);
2394 return ret ? : STp->buffer->syscall_result;
2398 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2399 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2400 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2402 int pgo, timeout, ret = 0;
2403 unsigned char cmd[MAX_COMMAND_SIZE];
2404 struct st_request *SRpnt;
2406 memset(cmd, 0, MAX_COMMAND_SIZE);
2407 cmd[0] = MODE_SELECT;
2408 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2409 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2410 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2412 /* Clear reserved fields */
2413 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2414 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2415 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2416 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2418 SRpnt = st_allocate_request(STp);
2422 timeout = slow ? STp->long_timeout :
2423 STp->device->request_queue->rq_timeout;
2425 ret = st_scsi_kern_execute(SRpnt, cmd, DMA_TO_DEVICE,
2426 STp->buffer->b_data, cmd[4], timeout, 0);
2428 ret = STp->buffer->syscall_result;
2430 st_release_request(SRpnt);
2436 #define COMPRESSION_PAGE 0x0f
2437 #define COMPRESSION_PAGE_LENGTH 16
2439 #define CP_OFF_DCE_DCC 2
2440 #define CP_OFF_C_ALGO 7
2442 #define DCE_MASK 0x80
2443 #define DCC_MASK 0x40
2444 #define RED_MASK 0x60
2447 /* Control the compression with mode page 15. Algorithm not changed if zero.
2449 The block descriptors are read and written because Sony SDT-7000 does not
2450 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2451 Including block descriptors should not cause any harm to other drives. */
2453 static int st_compression(struct scsi_tape * STp, int state)
2456 int mpoffs; /* Offset to mode page start */
2457 unsigned char *b_data = (STp->buffer)->b_data;
2458 DEB( char *name = tape_name(STp); )
2460 if (STp->ready != ST_READY)
2463 /* Read the current page contents */
2464 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2466 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2471 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2472 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2473 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2475 /* Check if compression can be changed */
2476 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2477 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2483 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2484 if (STp->c_algo != 0)
2485 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2488 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2489 if (STp->c_algo != 0)
2490 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2493 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2495 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2498 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2501 STp->compression_changed = 1;
2506 /* Process the load and unload commands (does unload if the load code is zero) */
2507 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2509 int retval = (-EIO), timeout;
2510 DEB( char *name = tape_name(STp); )
2511 unsigned char cmd[MAX_COMMAND_SIZE];
2512 struct st_partstat *STps;
2513 struct st_request *SRpnt;
2515 if (STp->ready != ST_READY && !load_code) {
2516 if (STp->ready == ST_NO_TAPE)
2517 return (-ENOMEDIUM);
2522 memset(cmd, 0, MAX_COMMAND_SIZE);
2523 cmd[0] = START_STOP;
2527 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2529 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2530 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2531 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2532 name, (cmd[4]) ? "" : "un",
2533 load_code - MT_ST_HPLOADER_OFFSET));
2534 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2536 if (STp->immediate) {
2537 cmd[1] = 1; /* Don't wait for completion */
2538 timeout = STp->device->request_queue->rq_timeout;
2541 timeout = STp->long_timeout;
2545 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2547 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2550 SRpnt = st_allocate_request(STp);
2552 return STp->buffer->syscall_result;
2554 retval = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0, timeout,
2559 retval = (STp->buffer)->syscall_result;
2561 if (!retval) { /* SCSI command successful */
2564 STp->rew_at_close = 0;
2565 STp->ready = ST_NO_TAPE;
2568 STp->rew_at_close = STp->autorew_dev;
2569 retval = check_tape(STp, filp);
2575 STps = &(STp->ps[STp->partition]);
2576 STps->drv_file = STps->drv_block = (-1);
2579 st_release_request(SRpnt);
2585 #define ST_DEB_FORWARD 0
2586 #define ST_DEB_BACKWARD 1
2587 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2591 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2592 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2595 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2596 direction ? "backward" : "forward", sc, units);
2601 /* Internal ioctl function */
2602 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2608 unsigned char cmd[MAX_COMMAND_SIZE];
2609 struct st_request *SRpnt;
2610 struct st_partstat *STps;
2611 int fileno, blkno, at_sm, undone;
2612 int datalen = 0, direction = DMA_NONE;
2613 char *name = tape_name(STp);
2615 WARN_ON(STp->buffer->do_dio != 0);
2616 if (STp->ready != ST_READY) {
2617 if (STp->ready == ST_NO_TAPE)
2618 return (-ENOMEDIUM);
2622 timeout = STp->long_timeout;
2623 STps = &(STp->ps[STp->partition]);
2624 fileno = STps->drv_file;
2625 blkno = STps->drv_block;
2626 at_sm = STps->at_sm;
2628 memset(cmd, 0, MAX_COMMAND_SIZE);
2631 chg_eof = 0; /* Changed from the FSF after this */
2634 cmd[1] = 0x01; /* Space FileMarks */
2635 cmd[2] = (arg >> 16);
2636 cmd[3] = (arg >> 8);
2638 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2642 at_sm &= (arg == 0);
2645 chg_eof = 0; /* Changed from the FSF after this */
2648 cmd[1] = 0x01; /* Space FileMarks */
2650 cmd[2] = (ltmp >> 16);
2651 cmd[3] = (ltmp >> 8);
2653 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2656 blkno = (-1); /* We can't know the block number */
2657 at_sm &= (arg == 0);
2661 cmd[1] = 0x00; /* Space Blocks */
2662 cmd[2] = (arg >> 16);
2663 cmd[3] = (arg >> 8);
2665 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2668 at_sm &= (arg == 0);
2672 cmd[1] = 0x00; /* Space Blocks */
2674 cmd[2] = (ltmp >> 16);
2675 cmd[3] = (ltmp >> 8);
2677 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2680 at_sm &= (arg == 0);
2684 cmd[1] = 0x04; /* Space Setmarks */
2685 cmd[2] = (arg >> 16);
2686 cmd[3] = (arg >> 8);
2688 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2690 blkno = fileno = (-1);
2696 cmd[1] = 0x04; /* Space Setmarks */
2698 cmd[2] = (ltmp >> 16);
2699 cmd[3] = (ltmp >> 8);
2701 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2703 blkno = fileno = (-1);
2709 if (STp->write_prot)
2711 cmd[0] = WRITE_FILEMARKS;
2712 if (cmd_in == MTWSM)
2714 cmd[2] = (arg >> 16);
2715 cmd[3] = (arg >> 8);
2717 timeout = STp->device->request_queue->rq_timeout;
2719 if (cmd_in == MTWEOF)
2720 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2721 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2723 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2724 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2729 at_sm = (cmd_in == MTWSM);
2732 cmd[0] = REZERO_UNIT;
2733 if (STp->immediate) {
2734 cmd[1] = 1; /* Don't wait for completion */
2735 timeout = STp->device->request_queue->rq_timeout;
2737 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2738 fileno = blkno = at_sm = 0;
2741 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2742 return 0; /* Should do something ? */
2745 cmd[0] = START_STOP;
2746 if (STp->immediate) {
2747 cmd[1] = 1; /* Don't wait for completion */
2748 timeout = STp->device->request_queue->rq_timeout;
2751 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2752 fileno = blkno = at_sm = 0;
2755 if (!STp->fast_mteom) {
2756 /* space to the end of tape */
2757 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2758 fileno = STps->drv_file;
2759 if (STps->eof >= ST_EOD_1)
2761 /* The next lines would hide the number of spaced FileMarks
2762 That's why I inserted the previous lines. I had no luck
2763 with detecting EOM with FSF, so we go now to EOM.
2769 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2775 if (STp->write_prot)
2778 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2779 if (STp->immediate) {
2780 cmd[1] |= 2; /* Don't wait for completion */
2781 timeout = STp->device->request_queue->rq_timeout;
2784 timeout = STp->long_timeout * 8;
2786 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2787 fileno = blkno = at_sm = 0;
2789 case MTSETBLK: /* Set block length */
2790 case MTSETDENSITY: /* Set tape density */
2791 case MTSETDRVBUFFER: /* Set drive buffering */
2792 case SET_DENS_AND_BLK: /* Set density and block size */
2794 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2795 return (-EIO); /* Not allowed if data in buffer */
2796 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2797 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2798 STp->max_block > 0 &&
2799 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2800 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2801 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2804 cmd[0] = MODE_SELECT;
2805 if ((STp->use_pf & USE_PF))
2806 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2807 cmd[4] = datalen = 12;
2808 direction = DMA_TO_DEVICE;
2810 memset((STp->buffer)->b_data, 0, 12);
2811 if (cmd_in == MTSETDRVBUFFER)
2812 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2814 (STp->buffer)->b_data[2] =
2815 STp->drv_buffer << 4;
2816 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2817 if (cmd_in == MTSETDENSITY) {
2818 (STp->buffer)->b_data[4] = arg;
2819 STp->density_changed = 1; /* At least we tried ;-) */
2820 } else if (cmd_in == SET_DENS_AND_BLK)
2821 (STp->buffer)->b_data[4] = arg >> 24;
2823 (STp->buffer)->b_data[4] = STp->density;
2824 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2825 ltmp = arg & MT_ST_BLKSIZE_MASK;
2826 if (cmd_in == MTSETBLK)
2827 STp->blksize_changed = 1; /* At least we tried ;-) */
2829 ltmp = STp->block_size;
2830 (STp->buffer)->b_data[9] = (ltmp >> 16);
2831 (STp->buffer)->b_data[10] = (ltmp >> 8);
2832 (STp->buffer)->b_data[11] = ltmp;
2833 timeout = STp->device->request_queue->rq_timeout;
2835 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2837 "%s: Setting block size to %d bytes.\n", name,
2838 (STp->buffer)->b_data[9] * 65536 +
2839 (STp->buffer)->b_data[10] * 256 +
2840 (STp->buffer)->b_data[11]);
2841 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2843 "%s: Setting density code to %x.\n", name,
2844 (STp->buffer)->b_data[4]);
2845 if (cmd_in == MTSETDRVBUFFER)
2847 "%s: Setting drive buffer code to %d.\n", name,
2848 ((STp->buffer)->b_data[2] >> 4) & 7);
2855 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2856 timeout, MAX_RETRIES, 1);
2858 return (STp->buffer)->syscall_result;
2860 ioctl_result = (STp->buffer)->syscall_result;
2862 if (!ioctl_result) { /* SCSI command successful */
2863 st_release_request(SRpnt);
2865 STps->drv_block = blkno;
2866 STps->drv_file = fileno;
2867 STps->at_sm = at_sm;
2869 if (cmd_in == MTBSFM)
2870 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2871 else if (cmd_in == MTFSFM)
2872 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2874 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2875 int old_block_size = STp->block_size;
2876 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2877 if (STp->block_size != 0) {
2878 if (old_block_size == 0)
2879 normalize_buffer(STp->buffer);
2880 (STp->buffer)->buffer_blocks =
2881 (STp->buffer)->buffer_size / STp->block_size;
2883 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2884 if (cmd_in == SET_DENS_AND_BLK)
2885 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2886 } else if (cmd_in == MTSETDRVBUFFER)
2887 STp->drv_buffer = (arg & 7);
2888 else if (cmd_in == MTSETDENSITY)
2891 if (cmd_in == MTEOM)
2893 else if (cmd_in == MTFSF)
2896 STps->eof = ST_NOEOF;
2898 if (cmd_in == MTWEOF)
2900 } else { /* SCSI command was not completely successful. Don't return
2901 from this block without releasing the SCSI command block! */
2902 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2904 if (cmdstatp->flags & SENSE_EOM) {
2905 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2906 cmd_in != MTBSR && cmd_in != MTBSS)
2907 STps->eof = ST_EOM_OK;
2908 STps->drv_block = 0;
2911 if (cmdstatp->remainder_valid)
2912 undone = (int)cmdstatp->uremainder64;
2916 if (cmd_in == MTWEOF &&
2917 cmdstatp->have_sense &&
2918 (cmdstatp->flags & SENSE_EOM)) {
2919 if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2920 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2921 ioctl_result = 0; /* EOF(s) written successfully at EOM */
2922 STps->eof = ST_NOEOF;
2923 } else { /* Writing EOF(s) failed */
2927 STps->eof = ST_NOEOF;
2929 STps->drv_file = fileno;
2930 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2932 STps->drv_file = fileno - undone;
2934 STps->drv_file = fileno;
2935 STps->drv_block = -1;
2936 STps->eof = ST_NOEOF;
2937 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2938 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2940 if (STps->drv_file >= 0)
2941 STps->drv_file = fileno + undone;
2942 STps->drv_block = 0;
2943 STps->eof = ST_NOEOF;
2944 } else if (cmd_in == MTFSR) {
2945 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2946 if (STps->drv_file >= 0)
2948 STps->drv_block = 0;
2951 if (blkno >= undone)
2952 STps->drv_block = blkno - undone;
2954 STps->drv_block = (-1);
2955 STps->eof = ST_NOEOF;
2957 } else if (cmd_in == MTBSR) {
2958 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2960 STps->drv_block = (-1);
2962 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2964 if (STps->drv_block >= 0)
2965 STps->drv_block = blkno + undone;
2967 STps->eof = ST_NOEOF;
2968 } else if (cmd_in == MTEOM) {
2969 STps->drv_file = (-1);
2970 STps->drv_block = (-1);
2972 } else if (cmd_in == MTSETBLK ||
2973 cmd_in == MTSETDENSITY ||
2974 cmd_in == MTSETDRVBUFFER ||
2975 cmd_in == SET_DENS_AND_BLK) {
2976 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2977 !(STp->use_pf & PF_TESTED)) {
2978 /* Try the other possible state of Page Format if not
2980 STp->use_pf = !STp->use_pf | PF_TESTED;
2981 st_release_request(SRpnt);
2983 return st_int_ioctl(STp, cmd_in, arg);
2986 STps->eof = ST_NOEOF;
2988 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2991 st_release_request(SRpnt);
2995 return ioctl_result;
2999 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
3002 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
3006 unsigned char scmd[MAX_COMMAND_SIZE];
3007 struct st_request *SRpnt;
3008 DEB( char *name = tape_name(STp); )
3010 if (STp->ready != ST_READY)
3013 memset(scmd, 0, MAX_COMMAND_SIZE);
3014 if ((STp->device)->scsi_level < SCSI_2) {
3015 scmd[0] = QFA_REQUEST_BLOCK;
3018 scmd[0] = READ_POSITION;
3019 if (!logical && !STp->scsi2_logical)
3022 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
3023 STp->device->request_queue->rq_timeout,
3024 MAX_READY_RETRIES, 1);
3026 return (STp->buffer)->syscall_result;
3028 if ((STp->buffer)->syscall_result != 0 ||
3029 (STp->device->scsi_level >= SCSI_2 &&
3030 ((STp->buffer)->b_data[0] & 4) != 0)) {
3031 *block = *partition = 0;
3032 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
3036 if ((STp->device)->scsi_level < SCSI_2) {
3037 *block = ((STp->buffer)->b_data[0] << 16)
3038 + ((STp->buffer)->b_data[1] << 8)
3039 + (STp->buffer)->b_data[2];
3042 *block = ((STp->buffer)->b_data[4] << 24)
3043 + ((STp->buffer)->b_data[5] << 16)
3044 + ((STp->buffer)->b_data[6] << 8)
3045 + (STp->buffer)->b_data[7];
3046 *partition = (STp->buffer)->b_data[1];
3047 if (((STp->buffer)->b_data[0] & 0x80) &&
3048 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
3049 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3051 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
3052 *block, *partition));
3054 st_release_request(SRpnt);
3061 /* Set the tape block and partition. Negative partition means that only the
3062 block should be set in vendor specific way. */
3063 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3066 struct st_partstat *STps;
3070 unsigned char scmd[MAX_COMMAND_SIZE];
3071 struct st_request *SRpnt;
3072 DEB( char *name = tape_name(STp); )
3074 if (STp->ready != ST_READY)
3076 timeout = STp->long_timeout;
3077 STps = &(STp->ps[STp->partition]);
3079 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3080 name, block, partition));
3081 DEB(if (partition < 0)
3084 /* Update the location at the partition we are leaving */
3085 if ((!STp->can_partitions && partition != 0) ||
3086 partition >= ST_NBR_PARTITIONS)
3088 if (partition != STp->partition) {
3089 if (get_location(STp, &blk, &p, 1))
3090 STps->last_block_valid = 0;
3092 STps->last_block_valid = 1;
3093 STps->last_block_visited = blk;
3094 DEBC(printk(ST_DEB_MSG
3095 "%s: Visited block %d for partition %d saved.\n",
3096 name, blk, STp->partition));
3100 memset(scmd, 0, MAX_COMMAND_SIZE);
3101 if ((STp->device)->scsi_level < SCSI_2) {
3102 scmd[0] = QFA_SEEK_BLOCK;
3103 scmd[2] = (block >> 16);
3104 scmd[3] = (block >> 8);
3109 scmd[3] = (block >> 24);
3110 scmd[4] = (block >> 16);
3111 scmd[5] = (block >> 8);
3113 if (!logical && !STp->scsi2_logical)
3115 if (STp->partition != partition) {
3117 scmd[8] = partition;
3118 DEBC(printk(ST_DEB_MSG
3119 "%s: Trying to change partition from %d to %d\n",
3120 name, STp->partition, partition));
3123 if (STp->immediate) {
3124 scmd[1] |= 1; /* Don't wait for completion */
3125 timeout = STp->device->request_queue->rq_timeout;
3128 SRpnt = st_allocate_request(STp);
3130 return STp->buffer->syscall_result;
3132 result = st_scsi_kern_execute(SRpnt, scmd, DMA_NONE, NULL, 0,
3133 timeout, MAX_READY_RETRIES);
3137 STps->drv_block = STps->drv_file = (-1);
3138 STps->eof = ST_NOEOF;
3139 if ((STp->buffer)->syscall_result != 0) {
3141 if (STp->can_partitions &&
3142 (STp->device)->scsi_level >= SCSI_2 &&
3143 (p = find_partition(STp)) >= 0)
3146 if (STp->can_partitions) {
3147 STp->partition = partition;
3148 STps = &(STp->ps[partition]);
3149 if (!STps->last_block_valid ||
3150 STps->last_block_visited != block) {
3157 STps->drv_block = STps->drv_file = 0;
3161 st_release_request(SRpnt);
3168 /* Find the current partition number for the drive status. Called from open and
3169 returns either partition number of negative error code. */
3170 static int find_partition(struct scsi_tape *STp)
3175 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3177 if (partition >= ST_NBR_PARTITIONS)
3183 /* Change the partition if necessary */
3184 static int switch_partition(struct scsi_tape *STp)
3186 struct st_partstat *STps;
3188 if (STp->partition == STp->new_partition)
3190 STps = &(STp->ps[STp->new_partition]);
3191 if (!STps->last_block_valid)
3192 STps->last_block_visited = 0;
3193 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3196 /* Functions for reading and writing the medium partition mode page. */
3198 #define PART_PAGE 0x11
3199 #define PART_PAGE_FIXED_LENGTH 8
3201 #define PP_OFF_MAX_ADD_PARTS 2
3202 #define PP_OFF_NBR_ADD_PARTS 3
3203 #define PP_OFF_FLAGS 4
3204 #define PP_OFF_PART_UNITS 6
3205 #define PP_OFF_RESERVED 7
3207 #define PP_BIT_IDP 0x20
3208 #define PP_MSK_PSUM_MB 0x10
3210 /* Get the number of partitions on the tape. As a side effect reads the
3211 mode page into the tape buffer. */
3212 static int nbr_partitions(struct scsi_tape *STp)
3215 DEB( char *name = tape_name(STp); )
3217 if (STp->ready != ST_READY)
3220 result = read_mode_page(STp, PART_PAGE, 1);
3223 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3227 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3228 PP_OFF_NBR_ADD_PARTS] + 1;
3229 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3236 /* Partition the tape into two partitions if size > 0 or one partition if
3239 The block descriptors are read and written because Sony SDT-7000 does not
3240 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3242 My HP C1533A drive returns only one partition size field. This is used to
3243 set the size of partition 1. There is no size field for the default partition.
3244 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3245 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3246 The following algorithm is used to accommodate both drives: if the number of
3247 partition size fields is greater than the maximum number of additional partitions
3248 in the mode page, the second field is used. Otherwise the first field is used.
3250 For Seagate DDS drives the page length must be 8 when no partitions is defined
3251 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3252 is acceptable also to some other old drives and enforced if the first partition
3253 size field is used for the first additional partition size.
3255 static int partition_tape(struct scsi_tape *STp, int size)
3257 char *name = tape_name(STp);
3259 int pgo, psd_cnt, psdo;
3262 result = read_mode_page(STp, PART_PAGE, 0);
3264 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3267 /* The mode page is in the buffer. Let's modify it and write it. */
3268 bp = (STp->buffer)->b_data;
3269 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3270 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3271 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3273 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3274 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3275 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3276 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3279 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3281 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3282 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3283 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3286 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3287 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3288 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3289 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3292 bp[psdo] = (size >> 8) & 0xff;
3293 bp[psdo + 1] = size & 0xff;
3295 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3296 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3297 DEBC(printk(ST_DEB_MSG
3298 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3301 bp[pgo + PP_OFF_PART_UNITS] = 0;
3302 bp[pgo + PP_OFF_RESERVED] = 0;
3303 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3305 result = write_mode_page(STp, PART_PAGE, 1);
3307 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3316 /* The ioctl command */
3317 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3319 int i, cmd_nr, cmd_type, bt;
3322 struct scsi_tape *STp = file->private_data;
3323 struct st_modedef *STm;
3324 struct st_partstat *STps;
3325 char *name = tape_name(STp);
3326 void __user *p = (void __user *)arg;
3328 if (mutex_lock_interruptible(&STp->lock))
3329 return -ERESTARTSYS;
3332 if (debugging && !STp->in_use) {
3333 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3338 STm = &(STp->modes[STp->current_mode]);
3339 STps = &(STp->ps[STp->partition]);
3342 * If we are in the middle of error recovery, don't let anyone
3343 * else try and use this device. Also, if error recovery fails, it
3344 * may try and take the device offline, in which case all further
3345 * access to the device is prohibited.
3347 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
3348 file->f_flags & O_NDELAY);
3349 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3353 cmd_type = _IOC_TYPE(cmd_in);
3354 cmd_nr = _IOC_NR(cmd_in);
3356 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3359 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3364 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3370 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3372 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3376 if (!STm->defined &&
3377 (mtc.mt_op != MTSETDRVBUFFER &&
3378 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3383 if (!STp->pos_unknown) {
3385 if (STps->eof == ST_FM_HIT) {
3386 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3387 mtc.mt_op == MTEOM) {
3389 if (STps->drv_file >= 0)
3390 STps->drv_file += 1;
3391 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3393 if (STps->drv_file >= 0)
3394 STps->drv_file += 1;
3398 if (mtc.mt_op == MTSEEK) {
3399 /* Old position must be restored if partition will be
3401 i = !STp->can_partitions ||
3402 (STp->new_partition != STp->partition);
3404 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3405 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3406 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3407 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3408 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3409 mtc.mt_op == MTCOMPRESSION;
3411 i = flush_buffer(STp, i);
3416 if (STps->rw == ST_WRITING &&
3417 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3418 mtc.mt_op == MTSEEK ||
3419 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3420 i = st_int_ioctl(STp, MTWEOF, 1);
3425 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3432 * If there was a bus reset, block further access
3433 * to this device. If the user wants to rewind the tape,
3434 * then reset the flag and allow access again.
3436 if (mtc.mt_op != MTREW &&
3437 mtc.mt_op != MTOFFL &&
3438 mtc.mt_op != MTRETEN &&
3439 mtc.mt_op != MTERASE &&
3440 mtc.mt_op != MTSEEK &&
3441 mtc.mt_op != MTEOM) {
3446 /* remove this when the midlevel properly clears was_reset */
3447 STp->device->was_reset = 0;
3450 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3451 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3452 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3453 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3455 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3456 do_door_lock(STp, 0); /* Ignore result! */
3458 if (mtc.mt_op == MTSETDRVBUFFER &&
3459 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3460 retval = st_set_options(STp, mtc.mt_count);
3464 if (mtc.mt_op == MTSETPART) {
3465 if (!STp->can_partitions ||
3466 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3470 if (mtc.mt_count >= STp->nbr_partitions &&
3471 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3475 if (mtc.mt_count >= STp->nbr_partitions) {
3479 STp->new_partition = mtc.mt_count;
3484 if (mtc.mt_op == MTMKPART) {
3485 if (!STp->can_partitions) {
3489 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3490 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3494 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3495 STp->ps[i].rw = ST_IDLE;
3496 STp->ps[i].at_sm = 0;
3497 STp->ps[i].last_block_valid = 0;
3499 STp->partition = STp->new_partition = 0;
3500 STp->nbr_partitions = 1; /* Bad guess ?-) */
3501 STps->drv_block = STps->drv_file = 0;
3506 if (mtc.mt_op == MTSEEK) {
3507 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3508 if (!STp->can_partitions)
3509 STp->ps[0].rw = ST_IDLE;
3514 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3515 retval = do_load_unload(STp, file, 0);
3519 if (mtc.mt_op == MTLOAD) {
3520 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3524 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3525 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3529 if (STp->can_partitions && STp->ready == ST_READY &&
3530 (i = switch_partition(STp)) < 0) {
3535 if (mtc.mt_op == MTCOMPRESSION)
3536 retval = st_compression(STp, (mtc.mt_count & 1));
3538 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3541 if (!STm->defined) {
3546 if ((i = flush_buffer(STp, 0)) < 0) {
3550 if (STp->can_partitions &&
3551 (i = switch_partition(STp)) < 0) {
3556 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3557 struct mtget mt_status;
3559 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3564 mt_status.mt_type = STp->tape_type;
3565 mt_status.mt_dsreg =
3566 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3567 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3568 mt_status.mt_blkno = STps->drv_block;
3569 mt_status.mt_fileno = STps->drv_file;
3570 if (STp->block_size != 0) {
3571 if (STps->rw == ST_WRITING)
3572 mt_status.mt_blkno +=
3573 (STp->buffer)->buffer_bytes / STp->block_size;
3574 else if (STps->rw == ST_READING)
3575 mt_status.mt_blkno -=
3576 ((STp->buffer)->buffer_bytes +
3577 STp->block_size - 1) / STp->block_size;
3580 mt_status.mt_gstat = 0;
3581 if (STp->drv_write_prot)
3582 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3583 if (mt_status.mt_blkno == 0) {
3584 if (mt_status.mt_fileno == 0)
3585 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3587 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3589 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3590 mt_status.mt_resid = STp->partition;
3591 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3592 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3593 else if (STps->eof >= ST_EOM_OK)
3594 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3595 if (STp->density == 1)
3596 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3597 else if (STp->density == 2)
3598 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3599 else if (STp->density == 3)
3600 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3601 if (STp->ready == ST_READY)
3602 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3603 if (STp->ready == ST_NO_TAPE)
3604 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3606 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3607 if (STm->do_async_writes ||
3608 (STm->do_buffer_writes && STp->block_size != 0) ||
3609 STp->drv_buffer != 0)
3610 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3611 if (STp->cleaning_req)
3612 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3614 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3620 STp->recover_reg = 0; /* Clear after read */
3623 } /* End of MTIOCGET */
3624 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3625 struct mtpos mt_pos;
3626 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3630 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3634 mt_pos.mt_blkno = blk;
3635 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3640 mutex_unlock(&STp->lock);
3642 case SCSI_IOCTL_GET_IDLUN:
3643 case SCSI_IOCTL_GET_BUS_NUMBER:
3646 if ((cmd_in == SG_IO ||
3647 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3648 cmd_in == CDROM_SEND_PACKET) &&
3649 !capable(CAP_SYS_RAWIO))
3652 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3653 file->f_mode, cmd_in, p);
3658 retval = scsi_ioctl(STp->device, cmd_in, p);
3659 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3660 STp->rew_at_close = 0;
3661 STp->ready = ST_NO_TAPE;
3666 mutex_unlock(&STp->lock);
3670 #ifdef CONFIG_COMPAT
3671 static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3673 struct scsi_tape *STp = file->private_data;
3674 struct scsi_device *sdev = STp->device;
3675 int ret = -ENOIOCTLCMD;
3676 if (sdev->host->hostt->compat_ioctl) {
3678 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3687 /* Try to allocate a new tape buffer. Calling function must not hold
3689 static struct st_buffer *
3690 new_tape_buffer(int from_initialization, int need_dma, int max_sg)
3694 struct st_buffer *tb;
3696 if (from_initialization)
3697 priority = GFP_ATOMIC;
3699 priority = GFP_KERNEL;
3701 i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3702 max_sg * sizeof(struct st_buf_fragment);
3703 tb = kzalloc(i, priority);
3705 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3708 tb->frp_segs = tb->orig_frp_segs = 0;
3709 tb->use_sg = max_sg;
3710 tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
3713 tb->buffer_size = got;
3714 sg_init_table(tb->sg, max_sg);
3720 /* Try to allocate enough space in the tape buffer */
3721 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3723 int segs, nbr, max_segs, b_size, order, got;
3726 if (new_size <= STbuffer->buffer_size)
3729 if (STbuffer->buffer_size <= PAGE_SIZE)
3730 normalize_buffer(STbuffer); /* Avoid extra segment */
3732 max_segs = STbuffer->use_sg;
3733 nbr = max_segs - STbuffer->frp_segs;
3737 priority = GFP_KERNEL | __GFP_NOWARN;
3739 priority |= GFP_DMA;
3740 for (b_size = PAGE_SIZE, order=0; order <= 6 &&
3741 b_size < new_size - STbuffer->buffer_size;
3742 order++, b_size *= 2)
3745 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3746 segs < max_segs && got < new_size;) {
3747 STbuffer->frp[segs].page = alloc_pages(priority, order);
3748 if (STbuffer->frp[segs].page == NULL) {
3749 if (new_size - got <= (max_segs - segs) * b_size / 2) {
3750 b_size /= 2; /* Large enough for the rest of the buffers */
3754 DEB(STbuffer->buffer_size = got);
3755 normalize_buffer(STbuffer);
3758 STbuffer->frp[segs].length = b_size;
3759 STbuffer->frp_segs += 1;
3761 STbuffer->buffer_size = got;
3762 if (STbuffer->cleared)
3763 memset(page_address(STbuffer->frp[segs].page), 0, b_size);
3766 STbuffer->b_data = page_address(STbuffer->frp[0].page);
3772 /* Make sure that no data from previous user is in the internal buffer */
3773 static void clear_buffer(struct st_buffer * st_bp)
3777 for (i=0; i < st_bp->frp_segs; i++)
3778 memset(page_address(st_bp->frp[i].page), 0, st_bp->frp[i].length);
3783 /* Release the extra buffer */
3784 static void normalize_buffer(struct st_buffer * STbuffer)
3788 for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3789 order = get_order(STbuffer->frp[i].length);
3790 __free_pages(STbuffer->frp[i].page, order);
3791 STbuffer->buffer_size -= STbuffer->frp[i].length;
3793 STbuffer->frp_segs = STbuffer->orig_frp_segs;
3794 STbuffer->frp_sg_current = 0;
3795 STbuffer->sg_segs = 0;
3799 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3800 negative error code. */
3801 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3803 int i, cnt, res, offset;
3805 for (i = 0, offset = st_bp->buffer_bytes;
3806 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3807 offset -= st_bp->frp[i].length;
3808 if (i == st_bp->frp_segs) { /* Should never happen */
3809 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3812 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3813 cnt = st_bp->frp[i].length - offset < do_count ?
3814 st_bp->frp[i].length - offset : do_count;
3815 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3819 st_bp->buffer_bytes += cnt;
3823 if (do_count) /* Should never happen */
3830 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3831 negative error code. */
3832 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3834 int i, cnt, res, offset;
3836 for (i = 0, offset = st_bp->read_pointer;
3837 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3838 offset -= st_bp->frp[i].length;
3839 if (i == st_bp->frp_segs) { /* Should never happen */
3840 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3843 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3844 cnt = st_bp->frp[i].length - offset < do_count ?
3845 st_bp->frp[i].length - offset : do_count;
3846 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3850 st_bp->buffer_bytes -= cnt;
3851 st_bp->read_pointer += cnt;
3855 if (do_count) /* Should never happen */
3862 /* Move data towards start of buffer */
3863 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3865 int src_seg, dst_seg, src_offset = 0, dst_offset;
3871 total=st_bp->buffer_bytes - offset;
3872 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3873 src_offset = offset;
3874 if (src_offset < st_bp->frp[src_seg].length)
3876 offset -= st_bp->frp[src_seg].length;
3879 st_bp->buffer_bytes = st_bp->read_pointer = total;
3880 for (dst_seg=dst_offset=0; total > 0; ) {
3881 count = min(st_bp->frp[dst_seg].length - dst_offset,
3882 st_bp->frp[src_seg].length - src_offset);
3883 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3884 page_address(st_bp->frp[src_seg].page) + src_offset, count);
3885 src_offset += count;
3886 if (src_offset >= st_bp->frp[src_seg].length) {
3890 dst_offset += count;
3891 if (dst_offset >= st_bp->frp[dst_seg].length) {
3900 /* Fill the s/g list up to the length required for this transfer */
3901 static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
3905 struct scatterlist *sg;
3906 struct st_buf_fragment *frp;
3908 if (length == STbp->frp_sg_current)
3909 return; /* work already done */
3911 sg = &(STbp->sg[0]);
3913 for (i=count=0; count < length; i++) {
3914 if (length - count > frp[i].length)
3915 sg_set_page(&sg[i], frp[i].page, frp[i].length, 0);
3917 sg_set_page(&sg[i], frp[i].page, length - count, 0);
3918 count += sg[i].length;
3921 STbp->frp_sg_current = length;
3925 /* Validate the options from command line or module parameters */
3926 static void validate_options(void)
3929 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3930 if (max_sg_segs >= ST_FIRST_SG)
3931 st_max_sg_segs = max_sg_segs;
3935 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3937 static int __init st_setup(char *str)
3939 int i, len, ints[5];
3942 stp = get_options(str, ARRAY_SIZE(ints), ints);
3945 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3947 *parms[i].val = ints[i + 1];
3949 while (stp != NULL) {
3950 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3951 len = strlen(parms[i].name);
3952 if (!strncmp(stp, parms[i].name, len) &&
3953 (*(stp + len) == ':' || *(stp + len) == '=')) {
3956 simple_strtoul(stp + len + 1, NULL, 0);
3958 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3963 if (i >= ARRAY_SIZE(parms))
3964 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3966 stp = strchr(stp, ',');
3977 __setup("st=", st_setup);
3981 static const struct file_operations st_fops =
3983 .owner = THIS_MODULE,
3986 .unlocked_ioctl = st_ioctl,
3987 #ifdef CONFIG_COMPAT
3988 .compat_ioctl = st_compat_ioctl,
3992 .release = st_release,
3995 static int st_probe(struct device *dev)
3997 struct scsi_device *SDp = to_scsi_device(dev);
3998 struct gendisk *disk = NULL;
3999 struct cdev *cdev = NULL;
4000 struct scsi_tape *tpnt = NULL;
4001 struct st_modedef *STm;
4002 struct st_partstat *STps;
4003 struct st_buffer *buffer;
4004 int i, j, mode, dev_num, error;
4007 if (SDp->type != TYPE_TAPE)
4009 if ((stp = st_incompatible(SDp))) {
4010 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
4011 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
4015 i = min(SDp->request_queue->max_hw_segments,
4016 SDp->request_queue->max_phys_segments);
4017 if (st_max_sg_segs < i)
4019 buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i);
4020 if (buffer == NULL) {
4022 "st: Can't allocate new tape buffer. Device not attached.\n");
4026 disk = alloc_disk(1);
4028 printk(KERN_ERR "st: out of memory. Device not attached.\n");
4029 goto out_buffer_free;
4032 write_lock(&st_dev_arr_lock);
4033 if (st_nr_dev >= st_dev_max) {
4034 struct scsi_tape **tmp_da;
4037 tmp_dev_max = max(st_nr_dev * 2, 8);
4038 if (tmp_dev_max > ST_MAX_TAPES)
4039 tmp_dev_max = ST_MAX_TAPES;
4040 if (tmp_dev_max <= st_nr_dev) {
4041 write_unlock(&st_dev_arr_lock);
4042 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
4047 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
4048 if (tmp_da == NULL) {
4049 write_unlock(&st_dev_arr_lock);
4050 printk(KERN_ERR "st: Can't extend device array.\n");
4054 if (scsi_tapes != NULL) {
4055 memcpy(tmp_da, scsi_tapes,
4056 st_dev_max * sizeof(struct scsi_tape *));
4059 scsi_tapes = tmp_da;
4061 st_dev_max = tmp_dev_max;
4064 for (i = 0; i < st_dev_max; i++)
4065 if (scsi_tapes[i] == NULL)
4067 if (i >= st_dev_max)
4068 panic("scsi_devices corrupt (st)");
4070 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
4072 write_unlock(&st_dev_arr_lock);
4073 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
4076 kref_init(&tpnt->kref);
4078 sprintf(disk->disk_name, "st%d", i);
4079 disk->private_data = &tpnt->driver;
4080 disk->queue = SDp->request_queue;
4081 tpnt->driver = &st_template;
4082 scsi_tapes[i] = tpnt;
4086 if (SDp->scsi_level <= 2)
4087 tpnt->tape_type = MT_ISSCSI1;
4089 tpnt->tape_type = MT_ISSCSI2;
4091 tpnt->buffer = buffer;
4092 tpnt->buffer->last_SRpnt = NULL;
4097 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
4098 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4099 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4101 tpnt->do_auto_lock = ST_AUTO_LOCK;
4102 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4103 tpnt->can_partitions = 0;
4104 tpnt->two_fm = ST_TWO_FM;
4105 tpnt->fast_mteom = ST_FAST_MTEOM;
4106 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4107 tpnt->sili = ST_SILI;
4108 tpnt->immediate = ST_NOWAIT;
4109 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
4110 tpnt->partition = 0;
4111 tpnt->new_partition = 0;
4112 tpnt->nbr_partitions = 0;
4113 blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
4114 tpnt->long_timeout = ST_LONG_TIMEOUT;
4115 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4117 for (i = 0; i < ST_NBR_MODES; i++) {
4118 STm = &(tpnt->modes[i]);
4120 STm->sysv = ST_SYSV;
4121 STm->defaults_for_writes = 0;
4122 STm->do_async_writes = ST_ASYNC_WRITES;
4123 STm->do_buffer_writes = ST_BUFFER_WRITES;
4124 STm->do_read_ahead = ST_READ_AHEAD;
4125 STm->default_compression = ST_DONT_TOUCH;
4126 STm->default_blksize = (-1); /* No forced size */
4127 STm->default_density = (-1); /* No forced density */
4130 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4131 STps = &(tpnt->ps[i]);
4133 STps->eof = ST_NOEOF;
4135 STps->last_block_valid = 0;
4136 STps->drv_block = (-1);
4137 STps->drv_file = (-1);
4140 tpnt->current_mode = 0;
4141 tpnt->modes[0].defined = 1;
4143 tpnt->density_changed = tpnt->compression_changed =
4144 tpnt->blksize_changed = 0;
4145 mutex_init(&tpnt->lock);
4148 write_unlock(&st_dev_arr_lock);
4150 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4151 STm = &(tpnt->modes[mode]);
4152 for (j=0; j < 2; j++) {
4153 cdev = cdev_alloc();
4156 "st%d: out of memory. Device not attached.\n",
4160 cdev->owner = THIS_MODULE;
4161 cdev->ops = &st_fops;
4163 error = cdev_add(cdev,
4164 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4167 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4168 dev_num, j ? "non" : "auto", mode);
4169 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4172 STm->cdevs[j] = cdev;
4175 error = do_create_class_files(tpnt, dev_num, mode);
4180 sdev_printk(KERN_NOTICE, SDp,
4181 "Attached scsi tape %s\n", tape_name(tpnt));
4182 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4183 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4184 queue_dma_alignment(SDp->request_queue) + 1);
4189 for (mode=0; mode < ST_NBR_MODES; mode++) {
4190 STm = &(tpnt->modes[mode]);
4191 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4193 for (j=0; j < 2; j++) {
4194 if (STm->cdevs[j]) {
4195 if (cdev == STm->cdevs[j])
4197 device_destroy(st_sysfs_class,
4198 MKDEV(SCSI_TAPE_MAJOR,
4199 TAPE_MINOR(i, mode, j)));
4200 cdev_del(STm->cdevs[j]);
4206 write_lock(&st_dev_arr_lock);
4207 scsi_tapes[dev_num] = NULL;
4209 write_unlock(&st_dev_arr_lock);
4220 static int st_remove(struct device *dev)
4222 struct scsi_device *SDp = to_scsi_device(dev);
4223 struct scsi_tape *tpnt;
4226 write_lock(&st_dev_arr_lock);
4227 for (i = 0; i < st_dev_max; i++) {
4228 tpnt = scsi_tapes[i];
4229 if (tpnt != NULL && tpnt->device == SDp) {
4230 scsi_tapes[i] = NULL;
4232 write_unlock(&st_dev_arr_lock);
4233 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4235 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4236 for (j=0; j < 2; j++) {
4237 device_destroy(st_sysfs_class,
4238 MKDEV(SCSI_TAPE_MAJOR,
4239 TAPE_MINOR(i, mode, j)));
4240 cdev_del(tpnt->modes[mode].cdevs[j]);
4241 tpnt->modes[mode].cdevs[j] = NULL;
4245 mutex_lock(&st_ref_mutex);
4246 kref_put(&tpnt->kref, scsi_tape_release);
4247 mutex_unlock(&st_ref_mutex);
4252 write_unlock(&st_dev_arr_lock);
4257 * scsi_tape_release - Called to free the Scsi_Tape structure
4258 * @kref: pointer to embedded kref
4260 * st_ref_mutex must be held entering this routine. Because it is
4261 * called on last put, you should always use the scsi_tape_get()
4262 * scsi_tape_put() helpers which manipulate the semaphore directly
4263 * and never do a direct kref_put().
4265 static void scsi_tape_release(struct kref *kref)
4267 struct scsi_tape *tpnt = to_scsi_tape(kref);
4268 struct gendisk *disk = tpnt->disk;
4270 tpnt->device = NULL;
4273 tpnt->buffer->orig_frp_segs = 0;
4274 normalize_buffer(tpnt->buffer);
4275 kfree(tpnt->buffer);
4278 disk->private_data = NULL;
4284 static int __init init_st(void)
4290 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4291 verstr, st_fixed_buffer_size, st_max_sg_segs);
4293 st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
4294 if (IS_ERR(st_sysfs_class)) {
4295 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4296 return PTR_ERR(st_sysfs_class);
4299 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4300 ST_MAX_TAPE_ENTRIES, "st");
4302 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4307 err = scsi_register_driver(&st_template.gendrv);
4311 err = do_create_sysfs_files();
4318 scsi_unregister_driver(&st_template.gendrv);
4320 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4321 ST_MAX_TAPE_ENTRIES);
4323 class_destroy(st_sysfs_class);
4327 static void __exit exit_st(void)
4329 do_remove_sysfs_files();
4330 scsi_unregister_driver(&st_template.gendrv);
4331 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4332 ST_MAX_TAPE_ENTRIES);
4333 class_destroy(st_sysfs_class);
4335 printk(KERN_INFO "st: Unloaded.\n");
4338 module_init(init_st);
4339 module_exit(exit_st);
4342 /* The sysfs driver interface. Read-only at the moment */
4343 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4345 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4347 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4349 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4351 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4353 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4355 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4357 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4359 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4361 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4363 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4365 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4367 static int do_create_sysfs_files(void)
4369 struct device_driver *sysfs = &st_template.gendrv;
4372 err = driver_create_file(sysfs, &driver_attr_try_direct_io);
4375 err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
4377 goto err_try_direct_io;
4378 err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
4380 goto err_attr_fixed_buf;
4381 err = driver_create_file(sysfs, &driver_attr_version);
4383 goto err_attr_max_sg;
4388 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4390 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4392 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4396 static void do_remove_sysfs_files(void)
4398 struct device_driver *sysfs = &st_template.gendrv;
4400 driver_remove_file(sysfs, &driver_attr_version);
4401 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4402 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4403 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4407 /* The sysfs simple class interface */
4409 st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4411 struct st_modedef *STm = dev_get_drvdata(dev);
4414 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4418 DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4421 st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
4423 struct st_modedef *STm = dev_get_drvdata(dev);
4426 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4430 DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4433 st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
4435 struct st_modedef *STm = dev_get_drvdata(dev);
4439 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4440 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4444 DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4447 st_defcompression_show(struct device *dev, struct device_attribute *attr,
4450 struct st_modedef *STm = dev_get_drvdata(dev);
4453 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4457 DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4460 st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
4462 struct st_modedef *STm = dev_get_drvdata(dev);
4463 struct scsi_tape *STp;
4467 for (i=0; i < st_dev_max; i++) {
4468 for (j=0; j < ST_NBR_MODES; j++)
4469 if (&scsi_tapes[i]->modes[j] == STm)
4471 if (j < ST_NBR_MODES)
4474 if (i == st_dev_max)
4475 return 0; /* should never happen */
4477 STp = scsi_tapes[i];
4479 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4480 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4481 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4482 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4483 options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4484 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4485 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4486 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4487 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4488 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4489 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4490 options |= STm->sysv ? MT_ST_SYSV : 0;
4491 options |= STp->immediate ? MT_ST_NOWAIT : 0;
4492 options |= STp->sili ? MT_ST_SILI : 0;
4494 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4498 DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
4500 static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4504 struct device *st_class_member;
4506 for (rew=0; rew < 2; rew++) {
4507 /* Make sure that the minor numbers corresponding to the four
4508 first modes always get the same names */
4509 i = mode << (4 - ST_NBR_MODE_BITS);
4510 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4511 STp->disk->disk_name, st_formats[i]);
4513 device_create(st_sysfs_class, &STp->device->sdev_gendev,
4514 MKDEV(SCSI_TAPE_MAJOR,
4515 TAPE_MINOR(dev_num, mode, rew)),
4516 &STp->modes[mode], "%s", name);
4517 if (IS_ERR(st_class_member)) {
4518 printk(KERN_WARNING "st%d: device_create failed\n",
4520 error = PTR_ERR(st_class_member);
4524 error = device_create_file(st_class_member,
4526 if (error) goto out;
4527 error = device_create_file(st_class_member,
4528 &dev_attr_default_blksize);
4529 if (error) goto out;
4530 error = device_create_file(st_class_member,
4531 &dev_attr_default_density);
4532 if (error) goto out;
4533 error = device_create_file(st_class_member,
4534 &dev_attr_default_compression);
4535 if (error) goto out;
4536 error = device_create_file(st_class_member,
4538 if (error) goto out;
4540 if (mode == 0 && rew == 0) {
4541 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4542 &st_class_member->kobj,
4546 "st%d: Can't create sysfs link from SCSI device.\n",
4559 /* The following functions may be useful for a larger audience. */
4560 static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4561 unsigned long uaddr, size_t count, int rw)
4563 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4564 unsigned long start = uaddr >> PAGE_SHIFT;
4565 const int nr_pages = end - start;
4567 struct page **pages;
4569 /* User attempted Overflow! */
4570 if ((uaddr + count) < uaddr)
4574 if (nr_pages > max_pages)
4581 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4584 /* Try to fault in all of the necessary pages */
4585 down_read(¤t->mm->mmap_sem);
4586 /* rw==READ means read from drive, write into memory area */
4587 res = get_user_pages(
4593 0, /* don't force */
4596 up_read(¤t->mm->mmap_sem);
4598 /* Errors and no page mapped should return here */
4602 for (i=0; i < nr_pages; i++) {
4603 /* FIXME: flush superflous for rw==READ,
4604 * probably wrong function for rw==WRITE
4606 flush_dcache_page(pages[i]);
4609 /* Populate the scatter/gather list */
4610 sg_set_page(&sgl[0], pages[0], 0, uaddr & ~PAGE_MASK);
4612 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4613 count -= sgl[0].length;
4614 for (i=1; i < nr_pages ; i++) {
4615 sg_set_page(&sgl[i], pages[i],
4616 count < PAGE_SIZE ? count : PAGE_SIZE, 0);;
4621 sgl[0].length = count;
4629 for (j=0; j < res; j++)
4630 page_cache_release(pages[j]);
4638 /* And unmap them... */
4639 static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4644 for (i=0; i < nr_pages; i++) {
4645 struct page *page = sg_page(&sgl[i]);
4649 /* FIXME: cache flush missing for rw==READ
4650 * FIXME: call the correct reference counting function
4652 page_cache_release(page);