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];
632 cmd[1] = 0x01; /* Space FileMarks */
637 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
640 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
641 tape_name(STp), forward ? "forward" : "backward"));
643 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
644 STp->device->request_queue->rq_timeout,
647 return (STp->buffer)->syscall_result;
649 st_release_request(SRpnt);
652 if ((STp->buffer)->cmdstat.midlevel_result != 0)
653 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
654 tape_name(STp), forward ? "forward" : "backward");
656 return (STp->buffer)->syscall_result;
660 /* Flush the write buffer (never need to write if variable blocksize). */
661 static int st_flush_write_buffer(struct scsi_tape * STp)
665 unsigned char cmd[MAX_COMMAND_SIZE];
666 struct st_request *SRpnt;
667 struct st_partstat *STps;
669 result = write_behind_check(STp);
674 if (STp->dirty == 1) {
676 transfer = STp->buffer->buffer_bytes;
677 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
678 tape_name(STp), transfer));
680 memset(cmd, 0, MAX_COMMAND_SIZE);
683 blks = transfer / STp->block_size;
688 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
689 STp->device->request_queue->rq_timeout,
690 MAX_WRITE_RETRIES, 1);
692 return (STp->buffer)->syscall_result;
694 STps = &(STp->ps[STp->partition]);
695 if ((STp->buffer)->syscall_result != 0) {
696 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
698 if (cmdstatp->have_sense && !cmdstatp->deferred &&
699 (cmdstatp->flags & SENSE_EOM) &&
700 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
701 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
702 (!cmdstatp->remainder_valid ||
703 cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
705 (STp->buffer)->buffer_bytes = 0;
706 if (STps->drv_block >= 0)
707 STps->drv_block += blks;
710 printk(KERN_ERR "%s: Error on flush.\n",
712 STps->drv_block = (-1);
716 if (STps->drv_block >= 0)
717 STps->drv_block += blks;
719 (STp->buffer)->buffer_bytes = 0;
721 st_release_request(SRpnt);
728 /* Flush the tape buffer. The tape will be positioned correctly unless
729 seek_next is true. */
730 static int flush_buffer(struct scsi_tape *STp, int seek_next)
732 int backspace, result;
733 struct st_buffer *STbuffer;
734 struct st_partstat *STps;
736 STbuffer = STp->buffer;
739 * If there was a bus reset, block further access
742 if (STp->pos_unknown)
745 if (STp->ready != ST_READY)
747 STps = &(STp->ps[STp->partition]);
748 if (STps->rw == ST_WRITING) /* Writing */
749 return st_flush_write_buffer(STp);
751 if (STp->block_size == 0)
754 backspace = ((STp->buffer)->buffer_bytes +
755 (STp->buffer)->read_pointer) / STp->block_size -
756 ((STp->buffer)->read_pointer + STp->block_size - 1) /
758 (STp->buffer)->buffer_bytes = 0;
759 (STp->buffer)->read_pointer = 0;
762 if (STps->eof == ST_FM_HIT) {
763 result = cross_eof(STp, 0); /* Back over the EOF hit */
765 STps->eof = ST_NOEOF;
767 if (STps->drv_file >= 0)
772 if (!result && backspace > 0)
773 result = st_int_ioctl(STp, MTBSR, backspace);
774 } else if (STps->eof == ST_FM_HIT) {
775 if (STps->drv_file >= 0)
778 STps->eof = ST_NOEOF;
784 /* Set the mode parameters */
785 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
789 char *name = tape_name(STp);
791 if (!STp->density_changed &&
792 STm->default_density >= 0 &&
793 STm->default_density != STp->density) {
794 arg = STm->default_density;
798 arg <<= MT_ST_DENSITY_SHIFT;
799 if (!STp->blksize_changed &&
800 STm->default_blksize >= 0 &&
801 STm->default_blksize != STp->block_size) {
802 arg |= STm->default_blksize;
805 arg |= STp->block_size;
807 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
809 "%s: Can't set default block size to %d bytes and density %x.\n",
810 name, STm->default_blksize, STm->default_density);
818 /* Lock or unlock the drive door. Don't use when st_request allocated. */
819 static int do_door_lock(struct scsi_tape * STp, int do_lock)
822 DEB(char *name = tape_name(STp);)
825 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
826 DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
827 do_lock ? "L" : "Unl"));
828 retval = scsi_ioctl(STp->device, cmd, NULL);
830 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
833 STp->door_locked = ST_LOCK_FAILS;
839 /* Set the internal state after reset */
840 static void reset_state(struct scsi_tape *STp)
843 struct st_partstat *STps;
845 STp->pos_unknown = 0;
846 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
847 STps = &(STp->ps[i]);
849 STps->eof = ST_NOEOF;
851 STps->last_block_valid = 0;
852 STps->drv_block = -1;
855 if (STp->can_partitions) {
856 STp->partition = find_partition(STp);
857 if (STp->partition < 0)
859 STp->new_partition = STp->partition;
863 /* Test if the drive is ready. Returns either one of the codes below or a negative system
865 #define CHKRES_READY 0
866 #define CHKRES_NEW_SESSION 1
867 #define CHKRES_NOT_READY 2
868 #define CHKRES_NO_TAPE 3
870 #define MAX_ATTENTIONS 10
872 static int test_ready(struct scsi_tape *STp, int do_wait)
874 int attentions, waits, max_wait, scode;
875 int retval = CHKRES_READY, new_session = 0;
876 unsigned char cmd[MAX_COMMAND_SIZE];
877 struct st_request *SRpnt;
878 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
880 SRpnt = st_allocate_request(STp);
882 return STp->buffer->syscall_result;
884 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
886 for (attentions=waits=0; ; ) {
887 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
888 cmd[0] = TEST_UNIT_READY;
890 retval = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0,
896 if (cmdstatp->have_sense) {
898 scode = cmdstatp->sense_hdr.sense_key;
900 if (scode == UNIT_ATTENTION) { /* New media? */
902 if (attentions < MAX_ATTENTIONS) {
912 if (scode == NOT_READY) {
913 if (waits < max_wait) {
914 if (msleep_interruptible(1000)) {
922 if ((STp->device)->scsi_level >= SCSI_2 &&
923 cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
924 retval = CHKRES_NO_TAPE;
926 retval = CHKRES_NOT_READY;
932 retval = (STp->buffer)->syscall_result;
934 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
938 st_release_request(SRpnt);
944 /* See if the drive is ready and gather information about the tape. Return values:
945 < 0 negative error code from errno.h
947 1 drive not ready (possibly no tape)
949 static int check_tape(struct scsi_tape *STp, struct file *filp)
951 int i, retval, new_session = 0, do_wait;
952 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
953 unsigned short st_flags = filp->f_flags;
954 struct st_request *SRpnt = NULL;
955 struct st_modedef *STm;
956 struct st_partstat *STps;
957 char *name = tape_name(STp);
958 struct inode *inode = filp->f_path.dentry->d_inode;
959 int mode = TAPE_MODE(inode);
961 STp->ready = ST_READY;
963 if (mode != STp->current_mode) {
964 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
965 name, STp->current_mode, mode));
967 STp->current_mode = mode;
969 STm = &(STp->modes[STp->current_mode]);
971 saved_cleaning = STp->cleaning_req;
972 STp->cleaning_req = 0;
974 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
975 retval = test_ready(STp, do_wait);
980 if (retval == CHKRES_NEW_SESSION) {
981 STp->pos_unknown = 0;
982 STp->partition = STp->new_partition = 0;
983 if (STp->can_partitions)
984 STp->nbr_partitions = 1; /* This guess will be updated later
986 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
987 STps = &(STp->ps[i]);
989 STps->eof = ST_NOEOF;
991 STps->last_block_valid = 0;
998 STp->cleaning_req |= saved_cleaning;
1000 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
1001 if (retval == CHKRES_NO_TAPE)
1002 STp->ready = ST_NO_TAPE;
1004 STp->ready = ST_NOT_READY;
1006 STp->density = 0; /* Clear the erroneous "residue" */
1007 STp->write_prot = 0;
1008 STp->block_size = 0;
1009 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
1010 STp->partition = STp->new_partition = 0;
1011 STp->door_locked = ST_UNLOCKED;
1012 return CHKRES_NOT_READY;
1016 if (STp->omit_blklims)
1017 STp->min_block = STp->max_block = (-1);
1019 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1020 cmd[0] = READ_BLOCK_LIMITS;
1022 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
1023 STp->device->request_queue->rq_timeout,
1024 MAX_READY_RETRIES, 1);
1026 retval = (STp->buffer)->syscall_result;
1030 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
1031 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1032 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1033 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1034 (STp->buffer)->b_data[5];
1035 if ( DEB( debugging || ) !STp->inited)
1037 "%s: Block limits %d - %d bytes.\n", name,
1038 STp->min_block, STp->max_block);
1040 STp->min_block = STp->max_block = (-1);
1041 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1046 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1047 cmd[0] = MODE_SENSE;
1050 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1051 STp->device->request_queue->rq_timeout,
1052 MAX_READY_RETRIES, 1);
1054 retval = (STp->buffer)->syscall_result;
1058 if ((STp->buffer)->syscall_result != 0) {
1059 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1060 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
1061 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */
1062 STp->drv_write_prot = 0;
1064 DEBC(printk(ST_DEB_MSG
1065 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1067 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1068 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1070 if ((STp->buffer)->b_data[3] >= 8) {
1071 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1072 STp->density = (STp->buffer)->b_data[4];
1073 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1074 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1075 DEBC(printk(ST_DEB_MSG
1076 "%s: Density %x, tape length: %x, drv buffer: %d\n",
1077 name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1078 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1081 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1083 st_release_request(SRpnt);
1087 if (STp->block_size > 0)
1088 (STp->buffer)->buffer_blocks =
1089 (STp->buffer)->buffer_size / STp->block_size;
1091 (STp->buffer)->buffer_blocks = 1;
1092 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1094 DEBC(printk(ST_DEB_MSG
1095 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1096 STp->block_size, (STp->buffer)->buffer_size,
1097 (STp->buffer)->buffer_blocks));
1099 if (STp->drv_write_prot) {
1100 STp->write_prot = 1;
1102 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1105 ((st_flags & O_ACCMODE) == O_WRONLY ||
1106 (st_flags & O_ACCMODE) == O_RDWR)) {
1112 if (STp->can_partitions && STp->nbr_partitions < 1) {
1113 /* This code is reached when the device is opened for the first time
1114 after the driver has been initialized with tape in the drive and the
1115 partition support has been enabled. */
1116 DEBC(printk(ST_DEB_MSG
1117 "%s: Updating partition number in status.\n", name));
1118 if ((STp->partition = find_partition(STp)) < 0) {
1119 retval = STp->partition;
1122 STp->new_partition = STp->partition;
1123 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1126 if (new_session) { /* Change the drive parameters for the new mode */
1127 STp->density_changed = STp->blksize_changed = 0;
1128 STp->compression_changed = 0;
1129 if (!(STm->defaults_for_writes) &&
1130 (retval = set_mode_densblk(STp, STm)) < 0)
1133 if (STp->default_drvbuffer != 0xff) {
1134 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1136 "%s: Can't set default drive buffering to %d.\n",
1137 name, STp->default_drvbuffer);
1141 return CHKRES_READY;
1148 \f/* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1150 static int st_open(struct inode *inode, struct file *filp)
1152 int i, retval = (-EIO);
1153 struct scsi_tape *STp;
1154 struct st_partstat *STps;
1155 int dev = TAPE_NR(inode);
1160 * We really want to do nonseekable_open(inode, filp); here, but some
1161 * versions of tar incorrectly call lseek on tapes and bail out if that
1162 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1164 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1166 if (!(STp = scsi_tape_get(dev))) {
1171 write_lock(&st_dev_arr_lock);
1172 filp->private_data = STp;
1173 name = tape_name(STp);
1176 write_unlock(&st_dev_arr_lock);
1179 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1184 write_unlock(&st_dev_arr_lock);
1185 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1187 if (!scsi_block_when_processing_errors(STp->device)) {
1192 /* See that we have at least a one page buffer available */
1193 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1194 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1196 retval = (-EOVERFLOW);
1200 (STp->buffer)->cleared = 0;
1201 (STp->buffer)->writing = 0;
1202 (STp->buffer)->syscall_result = 0;
1204 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1207 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1208 STps = &(STp->ps[i]);
1211 STp->try_dio_now = STp->try_dio;
1212 STp->recover_count = 0;
1213 DEB( STp->nbr_waits = STp->nbr_finished = 0;
1214 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
1216 retval = check_tape(STp, filp);
1219 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1220 retval != CHKRES_READY) {
1221 if (STp->ready == NO_TAPE)
1222 retval = (-ENOMEDIUM);
1231 normalize_buffer(STp->buffer);
1240 /* Flush the tape buffer before close */
1241 static int st_flush(struct file *filp, fl_owner_t id)
1243 int result = 0, result2;
1244 unsigned char cmd[MAX_COMMAND_SIZE];
1245 struct st_request *SRpnt;
1246 struct scsi_tape *STp = filp->private_data;
1247 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1248 struct st_partstat *STps = &(STp->ps[STp->partition]);
1249 char *name = tape_name(STp);
1251 if (file_count(filp) > 1)
1254 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1255 result = st_flush_write_buffer(STp);
1256 if (result != 0 && result != (-ENOSPC))
1260 if (STp->can_partitions &&
1261 (result2 = switch_partition(STp)) < 0) {
1262 DEBC(printk(ST_DEB_MSG
1263 "%s: switch_partition at close failed.\n", name));
1269 DEBC( if (STp->nbr_requests)
1270 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n",
1271 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages));
1273 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1274 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1276 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1277 name, STp->nbr_waits, STp->nbr_finished);
1280 memset(cmd, 0, MAX_COMMAND_SIZE);
1281 cmd[0] = WRITE_FILEMARKS;
1282 cmd[4] = 1 + STp->two_fm;
1284 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1285 STp->device->request_queue->rq_timeout,
1286 MAX_WRITE_RETRIES, 1);
1288 result = (STp->buffer)->syscall_result;
1292 if (STp->buffer->syscall_result == 0 ||
1293 (cmdstatp->have_sense && !cmdstatp->deferred &&
1294 (cmdstatp->flags & SENSE_EOM) &&
1295 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1296 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1297 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1298 /* Write successful at EOM */
1299 st_release_request(SRpnt);
1301 if (STps->drv_file >= 0)
1303 STps->drv_block = 0;
1308 else { /* Write error */
1309 st_release_request(SRpnt);
1311 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1316 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1318 } else if (!STp->rew_at_close) {
1319 STps = &(STp->ps[STp->partition]);
1320 if (!STm->sysv || STps->rw != ST_READING) {
1322 result = flush_buffer(STp, 0);
1323 else if (STps->eof == ST_FM_HIT) {
1324 result = cross_eof(STp, 0);
1326 if (STps->drv_file >= 0)
1328 STps->drv_block = 0;
1331 STps->eof = ST_NOEOF;
1333 } else if ((STps->eof == ST_NOEOF &&
1334 !(result = cross_eof(STp, 1))) ||
1335 STps->eof == ST_FM_HIT) {
1336 if (STps->drv_file >= 0)
1338 STps->drv_block = 0;
1344 if (STp->rew_at_close) {
1345 result2 = st_int_ioctl(STp, MTREW, 1);
1353 /* Close the device and release it. BKL is not needed: this is the only thread
1354 accessing this tape. */
1355 static int st_release(struct inode *inode, struct file *filp)
1358 struct scsi_tape *STp = filp->private_data;
1360 if (STp->door_locked == ST_LOCKED_AUTO)
1361 do_door_lock(STp, 0);
1363 normalize_buffer(STp->buffer);
1364 write_lock(&st_dev_arr_lock);
1366 write_unlock(&st_dev_arr_lock);
1372 /* The checks common to both reading and writing */
1373 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1378 * If we are in the middle of error recovery, don't let anyone
1379 * else try and use this device. Also, if error recovery fails, it
1380 * may try and take the device offline, in which case all further
1381 * access to the device is prohibited.
1383 if (!scsi_block_when_processing_errors(STp->device)) {
1388 if (STp->ready != ST_READY) {
1389 if (STp->ready == ST_NO_TAPE)
1390 retval = (-ENOMEDIUM);
1396 if (! STp->modes[STp->current_mode].defined) {
1403 * If there was a bus reset, block further access
1406 if (STp->pos_unknown) {
1416 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1421 if (STp->can_partitions &&
1422 (retval = switch_partition(STp)) < 0)
1425 if (STp->block_size == 0 && STp->max_block > 0 &&
1426 (count < STp->min_block || count > STp->max_block)) {
1431 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1432 !do_door_lock(STp, 1))
1433 STp->door_locked = ST_LOCKED_AUTO;
1440 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1441 size_t count, int is_read)
1443 int i, bufsize, retval = 0;
1444 struct st_buffer *STbp = STp->buffer;
1447 i = STp->try_dio_now && try_rdio;
1449 i = STp->try_dio_now && try_wdio;
1451 if (i && ((unsigned long)buf & queue_dma_alignment(
1452 STp->device->request_queue)) == 0) {
1453 i = sgl_map_user_pages(&(STbp->sg[0]), STbp->use_sg,
1454 (unsigned long)buf, count, (is_read ? READ : WRITE));
1457 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1460 STbp->do_dio = 0; /* fall back to buffering with any error */
1461 STbp->sg_segs = STbp->do_dio;
1462 STbp->frp_sg_current = 0;
1466 STp->nbr_pages += STbp->do_dio;
1471 DEB( STp->nbr_requests++; )
1473 if (!STbp->do_dio) {
1474 if (STp->block_size)
1475 bufsize = STp->block_size > st_fixed_buffer_size ?
1476 STp->block_size : st_fixed_buffer_size;
1479 /* Make sure that data from previous user is not leaked even if
1480 HBA does not return correct residual */
1481 if (is_read && STp->sili && !STbp->cleared)
1485 if (bufsize > STbp->buffer_size &&
1486 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1487 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1488 tape_name(STp), bufsize);
1489 retval = (-EOVERFLOW);
1492 if (STp->block_size)
1493 STbp->buffer_blocks = bufsize / STp->block_size;
1501 /* Can be called more than once after each setup_buffer() */
1502 static void release_buffering(struct scsi_tape *STp, int is_read)
1504 struct st_buffer *STbp;
1508 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, is_read);
1517 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1520 ssize_t i, do_count, blks, transfer;
1522 int undone, retry_eot = 0, scode;
1524 unsigned char cmd[MAX_COMMAND_SIZE];
1525 const char __user *b_point;
1526 struct st_request *SRpnt = NULL;
1527 struct scsi_tape *STp = filp->private_data;
1528 struct st_modedef *STm;
1529 struct st_partstat *STps;
1530 struct st_buffer *STbp;
1531 char *name = tape_name(STp);
1533 if (mutex_lock_interruptible(&STp->lock))
1534 return -ERESTARTSYS;
1536 retval = rw_checks(STp, filp, count);
1537 if (retval || count == 0)
1540 /* Write must be integral number of blocks */
1541 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1542 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1548 STm = &(STp->modes[STp->current_mode]);
1549 STps = &(STp->ps[STp->partition]);
1551 if (STp->write_prot) {
1557 if (STps->rw == ST_READING) {
1558 retval = flush_buffer(STp, 0);
1561 STps->rw = ST_WRITING;
1562 } else if (STps->rw != ST_WRITING &&
1563 STps->drv_file == 0 && STps->drv_block == 0) {
1564 if ((retval = set_mode_densblk(STp, STm)) < 0)
1566 if (STm->default_compression != ST_DONT_TOUCH &&
1567 !(STp->compression_changed)) {
1568 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1569 printk(KERN_WARNING "%s: Can't set default compression.\n",
1571 if (modes_defined) {
1580 i = write_behind_check(STp);
1583 STps->eof = ST_EOM_OK;
1585 STps->eof = ST_EOM_ERROR;
1588 if (STps->eof == ST_EOM_OK) {
1589 STps->eof = ST_EOD_1; /* allow next write */
1593 else if (STps->eof == ST_EOM_ERROR) {
1598 /* Check the buffer readability in cases where copy_user might catch
1599 the problems after some tape movement. */
1600 if (STp->block_size != 0 &&
1602 (copy_from_user(&i, buf, 1) != 0 ||
1603 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1608 retval = setup_buffering(STp, buf, count, 0);
1614 memset(cmd, 0, MAX_COMMAND_SIZE);
1616 cmd[1] = (STp->block_size != 0);
1618 STps->rw = ST_WRITING;
1621 while (count > 0 && !retry_eot) {
1627 if (STp->block_size == 0)
1630 do_count = STbp->buffer_blocks * STp->block_size -
1632 if (do_count > count)
1636 i = append_to_buffer(b_point, STbp, do_count);
1643 b_point += do_count;
1645 async_write = STp->block_size == 0 && !STbp->do_dio &&
1646 STm->do_async_writes && STps->eof < ST_EOM_OK;
1648 if (STp->block_size != 0 && STm->do_buffer_writes &&
1649 !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1650 STbp->buffer_bytes < STbp->buffer_size) {
1652 /* Don't write a buffer that is not full enough. */
1653 if (!async_write && count == 0)
1658 if (STp->block_size == 0)
1659 blks = transfer = do_count;
1662 blks = STbp->buffer_bytes;
1665 blks /= STp->block_size;
1666 transfer = blks * STp->block_size;
1668 cmd[2] = blks >> 16;
1672 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1673 STp->device->request_queue->rq_timeout,
1674 MAX_WRITE_RETRIES, !async_write);
1676 retval = STbp->syscall_result;
1679 if (async_write && !STbp->syscall_result) {
1680 STbp->writing = transfer;
1681 STp->dirty = !(STbp->writing ==
1682 STbp->buffer_bytes);
1683 SRpnt = NULL; /* Prevent releasing this request! */
1684 DEB( STp->write_pending = 1; )
1688 if (STbp->syscall_result != 0) {
1689 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1691 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1692 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1693 scode = cmdstatp->sense_hdr.sense_key;
1694 if (cmdstatp->remainder_valid)
1695 undone = (int)cmdstatp->uremainder64;
1696 else if (STp->block_size == 0 &&
1697 scode == VOLUME_OVERFLOW)
1701 if (STp->block_size != 0)
1702 undone *= STp->block_size;
1703 if (undone <= do_count) {
1704 /* Only data from this write is not written */
1708 if (STp->block_size)
1709 blks = (transfer - undone) / STp->block_size;
1710 STps->eof = ST_EOM_OK;
1711 /* Continue in fixed block mode if all written
1712 in this request but still something left to write
1713 (retval left to zero)
1715 if (STp->block_size == 0 ||
1716 undone > 0 || count == 0)
1717 retval = (-ENOSPC); /* EOM within current request */
1718 DEBC(printk(ST_DEB_MSG
1719 "%s: EOM with %d bytes unwritten.\n",
1722 /* EOT within data buffered earlier (possible only
1723 in fixed block mode without direct i/o) */
1724 if (!retry_eot && !cmdstatp->deferred &&
1725 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1726 move_buffer_data(STp->buffer, transfer - undone);
1728 if (STps->drv_block >= 0) {
1729 STps->drv_block += (transfer - undone) /
1732 STps->eof = ST_EOM_OK;
1733 DEBC(printk(ST_DEB_MSG
1734 "%s: Retry write of %d bytes at EOM.\n",
1735 name, STp->buffer->buffer_bytes));
1739 /* Either error within data buffered by driver or
1742 blks = do_count = 0;
1743 STps->eof = ST_EOM_ERROR;
1744 STps->drv_block = (-1); /* Too cautious? */
1745 retval = (-EIO); /* EOM for old data */
1746 DEBC(printk(ST_DEB_MSG
1747 "%s: EOM with lost data.\n",
1753 STps->drv_block = (-1); /* Too cautious? */
1754 retval = STbp->syscall_result;
1759 if (STps->drv_block >= 0) {
1760 if (STp->block_size == 0)
1761 STps->drv_block += (do_count > 0);
1763 STps->drv_block += blks;
1766 STbp->buffer_bytes = 0;
1769 if (retval || retry_eot) {
1771 retval = total - count;
1776 if (STps->eof == ST_EOD_1)
1777 STps->eof = ST_EOM_OK;
1778 else if (STps->eof != ST_EOM_OK)
1779 STps->eof = ST_NOEOF;
1780 retval = total - count;
1784 st_release_request(SRpnt);
1785 release_buffering(STp, 0);
1786 mutex_unlock(&STp->lock);
1791 /* Read data from the tape. Returns zero in the normal case, one if the
1792 eof status has changed, and the negative error code in case of a
1793 fatal error. Otherwise updates the buffer and the eof state.
1795 Does release user buffer mapping if it is set.
1797 static long read_tape(struct scsi_tape *STp, long count,
1798 struct st_request ** aSRpnt)
1800 int transfer, blks, bytes;
1801 unsigned char cmd[MAX_COMMAND_SIZE];
1802 struct st_request *SRpnt;
1803 struct st_modedef *STm;
1804 struct st_partstat *STps;
1805 struct st_buffer *STbp;
1807 char *name = tape_name(STp);
1812 STm = &(STp->modes[STp->current_mode]);
1813 STps = &(STp->ps[STp->partition]);
1814 if (STps->eof == ST_FM_HIT)
1818 if (STp->block_size == 0)
1819 blks = bytes = count;
1821 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1822 blks = (STp->buffer)->buffer_blocks;
1823 bytes = blks * STp->block_size;
1826 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1827 bytes = (STp->buffer)->buffer_size;
1828 blks = bytes / STp->block_size;
1829 bytes = blks * STp->block_size;
1833 memset(cmd, 0, MAX_COMMAND_SIZE);
1835 cmd[1] = (STp->block_size != 0);
1836 if (!cmd[1] && STp->sili)
1838 cmd[2] = blks >> 16;
1843 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1844 STp->device->request_queue->rq_timeout,
1846 release_buffering(STp, 1);
1849 return STbp->syscall_result;
1851 STbp->read_pointer = 0;
1854 /* Something to check */
1855 if (STbp->syscall_result) {
1856 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1859 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1861 SRpnt->sense[0], SRpnt->sense[1],
1862 SRpnt->sense[2], SRpnt->sense[3],
1863 SRpnt->sense[4], SRpnt->sense[5],
1864 SRpnt->sense[6], SRpnt->sense[7]));
1865 if (cmdstatp->have_sense) {
1867 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1868 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1870 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1871 /* Compute the residual count */
1872 if (cmdstatp->remainder_valid)
1873 transfer = (int)cmdstatp->uremainder64;
1876 if (STp->block_size == 0 &&
1877 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1880 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
1881 if (STp->block_size == 0) {
1882 if (transfer <= 0) {
1885 "%s: Failed to read %d byte block with %d byte transfer.\n",
1886 name, bytes - transfer, bytes);
1887 if (STps->drv_block >= 0)
1888 STps->drv_block += 1;
1889 STbp->buffer_bytes = 0;
1892 STbp->buffer_bytes = bytes - transfer;
1894 st_release_request(SRpnt);
1895 SRpnt = *aSRpnt = NULL;
1896 if (transfer == blks) { /* We did not get anything, error */
1897 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1898 if (STps->drv_block >= 0)
1899 STps->drv_block += blks - transfer + 1;
1900 st_int_ioctl(STp, MTBSR, 1);
1903 /* We have some data, deliver it */
1904 STbp->buffer_bytes = (blks - transfer) *
1906 DEBC(printk(ST_DEB_MSG
1907 "%s: ILI but enough data received %ld %d.\n",
1908 name, count, STbp->buffer_bytes));
1909 if (STps->drv_block >= 0)
1910 STps->drv_block += 1;
1911 if (st_int_ioctl(STp, MTBSR, 1))
1914 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
1915 if (STps->eof != ST_FM_HIT)
1916 STps->eof = ST_FM_HIT;
1918 STps->eof = ST_EOD_2;
1919 if (STp->block_size == 0)
1920 STbp->buffer_bytes = 0;
1922 STbp->buffer_bytes =
1923 bytes - transfer * STp->block_size;
1924 DEBC(printk(ST_DEB_MSG
1925 "%s: EOF detected (%d bytes read).\n",
1926 name, STbp->buffer_bytes));
1927 } else if (cmdstatp->flags & SENSE_EOM) {
1928 if (STps->eof == ST_FM)
1929 STps->eof = ST_EOD_1;
1931 STps->eof = ST_EOM_OK;
1932 if (STp->block_size == 0)
1933 STbp->buffer_bytes = bytes - transfer;
1935 STbp->buffer_bytes =
1936 bytes - transfer * STp->block_size;
1938 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1939 name, STbp->buffer_bytes));
1942 /* end of EOF, EOM, ILI test */
1943 else { /* nonzero sense key */
1944 DEBC(printk(ST_DEB_MSG
1945 "%s: Tape error while reading.\n", name));
1946 STps->drv_block = (-1);
1947 if (STps->eof == ST_FM &&
1948 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1949 DEBC(printk(ST_DEB_MSG
1950 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1952 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1953 } else /* Some other extended sense code */
1957 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
1958 STbp->buffer_bytes = 0;
1960 /* End of extended sense test */
1961 else { /* Non-extended sense */
1962 retval = STbp->syscall_result;
1966 /* End of error handling */
1967 else { /* Read successful */
1968 STbp->buffer_bytes = bytes;
1969 if (STp->sili) /* In fixed block mode residual is always zero here */
1970 STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
1973 if (STps->drv_block >= 0) {
1974 if (STp->block_size == 0)
1977 STps->drv_block += STbp->buffer_bytes / STp->block_size;
1985 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
1989 ssize_t i, transfer;
1990 int special, do_dio = 0;
1991 struct st_request *SRpnt = NULL;
1992 struct scsi_tape *STp = filp->private_data;
1993 struct st_modedef *STm;
1994 struct st_partstat *STps;
1995 struct st_buffer *STbp = STp->buffer;
1996 DEB( char *name = tape_name(STp); )
1998 if (mutex_lock_interruptible(&STp->lock))
1999 return -ERESTARTSYS;
2001 retval = rw_checks(STp, filp, count);
2002 if (retval || count == 0)
2005 STm = &(STp->modes[STp->current_mode]);
2006 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
2007 if (!STm->do_read_ahead) {
2008 retval = (-EINVAL); /* Read must be integral number of blocks */
2011 STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */
2014 STps = &(STp->ps[STp->partition]);
2015 if (STps->rw == ST_WRITING) {
2016 retval = flush_buffer(STp, 0);
2019 STps->rw = ST_READING;
2022 if (debugging && STps->eof != ST_NOEOF)
2023 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
2024 STps->eof, STbp->buffer_bytes);
2027 retval = setup_buffering(STp, buf, count, 1);
2030 do_dio = STbp->do_dio;
2032 if (STbp->buffer_bytes == 0 &&
2033 STps->eof >= ST_EOD_1) {
2034 if (STps->eof < ST_EOD) {
2039 retval = (-EIO); /* EOM or Blank Check */
2044 /* Check the buffer writability before any tape movement. Don't alter
2046 if (copy_from_user(&i, buf, 1) != 0 ||
2047 copy_to_user(buf, &i, 1) != 0 ||
2048 copy_from_user(&i, buf + count - 1, 1) != 0 ||
2049 copy_to_user(buf + count - 1, &i, 1) != 0) {
2055 STps->rw = ST_READING;
2058 /* Loop until enough data in buffer or a special condition found */
2059 for (total = 0, special = 0; total < count && !special;) {
2061 /* Get new data if the buffer is empty */
2062 if (STbp->buffer_bytes == 0) {
2063 special = read_tape(STp, count - total, &SRpnt);
2064 if (special < 0) { /* No need to continue read */
2070 /* Move the data from driver buffer to user buffer */
2071 if (STbp->buffer_bytes > 0) {
2073 if (debugging && STps->eof != ST_NOEOF)
2075 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2076 STps->eof, STbp->buffer_bytes,
2077 (int)(count - total));
2079 transfer = STbp->buffer_bytes < count - total ?
2080 STbp->buffer_bytes : count - total;
2082 i = from_buffer(STbp, buf, transfer);
2092 if (STp->block_size == 0)
2093 break; /* Read only one variable length block */
2095 } /* for (total = 0, special = 0;
2096 total < count && !special; ) */
2098 /* Change the eof state if no data from tape or buffer */
2100 if (STps->eof == ST_FM_HIT) {
2102 STps->drv_block = 0;
2103 if (STps->drv_file >= 0)
2105 } else if (STps->eof == ST_EOD_1) {
2106 STps->eof = ST_EOD_2;
2107 STps->drv_block = 0;
2108 if (STps->drv_file >= 0)
2110 } else if (STps->eof == ST_EOD_2)
2112 } else if (STps->eof == ST_FM)
2113 STps->eof = ST_NOEOF;
2117 if (SRpnt != NULL) {
2118 st_release_request(SRpnt);
2122 release_buffering(STp, 1);
2123 STbp->buffer_bytes = 0;
2125 mutex_unlock(&STp->lock);
2133 /* Set the driver options */
2134 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2138 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2139 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2140 STm->do_read_ahead);
2142 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2143 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2145 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2146 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2147 STp->scsi2_logical);
2149 "%s: sysv: %d nowait: %d sili: %d\n", name, STm->sysv, STp->immediate,
2151 printk(KERN_INFO "%s: debugging: %d\n",
2158 static int st_set_options(struct scsi_tape *STp, long options)
2162 struct st_modedef *STm;
2163 char *name = tape_name(STp);
2164 struct cdev *cd0, *cd1;
2166 STm = &(STp->modes[STp->current_mode]);
2167 if (!STm->defined) {
2168 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2169 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2170 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2172 DEBC(printk(ST_DEB_MSG
2173 "%s: Initialized mode %d definition from mode 0\n",
2174 name, STp->current_mode));
2177 code = options & MT_ST_OPTIONS;
2178 if (code == MT_ST_BOOLEANS) {
2179 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2180 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2181 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2182 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2183 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2184 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2185 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2186 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2187 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2188 if ((STp->device)->scsi_level >= SCSI_2)
2189 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2190 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2191 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2192 STm->sysv = (options & MT_ST_SYSV) != 0;
2193 STp->sili = (options & MT_ST_SILI) != 0;
2194 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2195 st_log_options(STp, STm, name); )
2196 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2197 value = (code == MT_ST_SETBOOLEANS);
2198 if ((options & MT_ST_BUFFER_WRITES) != 0)
2199 STm->do_buffer_writes = value;
2200 if ((options & MT_ST_ASYNC_WRITES) != 0)
2201 STm->do_async_writes = value;
2202 if ((options & MT_ST_DEF_WRITES) != 0)
2203 STm->defaults_for_writes = value;
2204 if ((options & MT_ST_READ_AHEAD) != 0)
2205 STm->do_read_ahead = value;
2206 if ((options & MT_ST_TWO_FM) != 0)
2207 STp->two_fm = value;
2208 if ((options & MT_ST_FAST_MTEOM) != 0)
2209 STp->fast_mteom = value;
2210 if ((options & MT_ST_AUTO_LOCK) != 0)
2211 STp->do_auto_lock = value;
2212 if ((options & MT_ST_CAN_BSR) != 0)
2213 STp->can_bsr = value;
2214 if ((options & MT_ST_NO_BLKLIMS) != 0)
2215 STp->omit_blklims = value;
2216 if ((STp->device)->scsi_level >= SCSI_2 &&
2217 (options & MT_ST_CAN_PARTITIONS) != 0)
2218 STp->can_partitions = value;
2219 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2220 STp->scsi2_logical = value;
2221 if ((options & MT_ST_NOWAIT) != 0)
2222 STp->immediate = value;
2223 if ((options & MT_ST_SYSV) != 0)
2225 if ((options & MT_ST_SILI) != 0)
2228 if ((options & MT_ST_DEBUGGING) != 0)
2230 st_log_options(STp, STm, name); )
2231 } else if (code == MT_ST_WRITE_THRESHOLD) {
2232 /* Retained for compatibility */
2233 } else if (code == MT_ST_DEF_BLKSIZE) {
2234 value = (options & ~MT_ST_OPTIONS);
2235 if (value == ~MT_ST_OPTIONS) {
2236 STm->default_blksize = (-1);
2237 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2239 STm->default_blksize = value;
2240 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2241 name, STm->default_blksize));
2242 if (STp->ready == ST_READY) {
2243 STp->blksize_changed = 0;
2244 set_mode_densblk(STp, STm);
2247 } else if (code == MT_ST_TIMEOUTS) {
2248 value = (options & ~MT_ST_OPTIONS);
2249 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2250 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2251 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2252 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2254 blk_queue_rq_timeout(STp->device->request_queue,
2256 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2259 } else if (code == MT_ST_SET_CLN) {
2260 value = (options & ~MT_ST_OPTIONS) & 0xff;
2262 value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2264 STp->cln_mode = value;
2265 STp->cln_sense_mask = (options >> 8) & 0xff;
2266 STp->cln_sense_value = (options >> 16) & 0xff;
2268 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2269 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2270 } else if (code == MT_ST_DEF_OPTIONS) {
2271 code = (options & ~MT_ST_CLEAR_DEFAULT);
2272 value = (options & MT_ST_CLEAR_DEFAULT);
2273 if (code == MT_ST_DEF_DENSITY) {
2274 if (value == MT_ST_CLEAR_DEFAULT) {
2275 STm->default_density = (-1);
2276 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2279 STm->default_density = value & 0xff;
2280 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2281 name, STm->default_density));
2282 if (STp->ready == ST_READY) {
2283 STp->density_changed = 0;
2284 set_mode_densblk(STp, STm);
2287 } else if (code == MT_ST_DEF_DRVBUFFER) {
2288 if (value == MT_ST_CLEAR_DEFAULT) {
2289 STp->default_drvbuffer = 0xff;
2290 DEBC( printk(KERN_INFO
2291 "%s: Drive buffer default disabled.\n", name));
2293 STp->default_drvbuffer = value & 7;
2294 DEBC( printk(KERN_INFO
2295 "%s: Drive buffer default set to %x\n",
2296 name, STp->default_drvbuffer));
2297 if (STp->ready == ST_READY)
2298 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2300 } else if (code == MT_ST_DEF_COMPRESSION) {
2301 if (value == MT_ST_CLEAR_DEFAULT) {
2302 STm->default_compression = ST_DONT_TOUCH;
2303 DEBC( printk(KERN_INFO
2304 "%s: Compression default disabled.\n", name));
2306 if ((value & 0xff00) != 0) {
2307 STp->c_algo = (value & 0xff00) >> 8;
2308 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2309 name, STp->c_algo));
2311 if ((value & 0xff) != 0xff) {
2312 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2313 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2314 name, (value & 1)));
2315 if (STp->ready == ST_READY) {
2316 STp->compression_changed = 0;
2317 st_compression(STp, (STm->default_compression == ST_YES));
2328 #define MODE_HEADER_LENGTH 4
2330 /* Mode header and page byte offsets */
2331 #define MH_OFF_DATA_LENGTH 0
2332 #define MH_OFF_MEDIUM_TYPE 1
2333 #define MH_OFF_DEV_SPECIFIC 2
2334 #define MH_OFF_BDESCS_LENGTH 3
2335 #define MP_OFF_PAGE_NBR 0
2336 #define MP_OFF_PAGE_LENGTH 1
2338 /* Mode header and page bit masks */
2339 #define MH_BIT_WP 0x80
2340 #define MP_MSK_PAGE_NBR 0x3f
2342 /* Don't return block descriptors */
2343 #define MODE_SENSE_OMIT_BDESCS 0x08
2345 #define MODE_SELECT_PAGE_FORMAT 0x10
2347 /* Read a mode page into the tape buffer. The block descriptors are included
2348 if incl_block_descs is true. The page control is ored to the page number
2349 parameter, if necessary. */
2350 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2352 unsigned char cmd[MAX_COMMAND_SIZE];
2353 struct st_request *SRpnt = NULL;
2355 memset(cmd, 0, MAX_COMMAND_SIZE);
2356 cmd[0] = MODE_SENSE;
2357 if (omit_block_descs)
2358 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2362 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2363 STp->device->request_queue->rq_timeout, 0, 1);
2365 return (STp->buffer)->syscall_result;
2367 st_release_request(SRpnt);
2369 return (STp->buffer)->syscall_result;
2373 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2374 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2375 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2378 unsigned char cmd[MAX_COMMAND_SIZE];
2379 struct st_request *SRpnt = NULL;
2381 memset(cmd, 0, MAX_COMMAND_SIZE);
2382 cmd[0] = MODE_SELECT;
2383 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2384 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2385 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2387 /* Clear reserved fields */
2388 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2389 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2390 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2391 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2393 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE,
2394 (slow ? STp->long_timeout : STp->device->request_queue->rq_timeout), 0, 1);
2396 return (STp->buffer)->syscall_result;
2398 st_release_request(SRpnt);
2400 return (STp->buffer)->syscall_result;
2404 #define COMPRESSION_PAGE 0x0f
2405 #define COMPRESSION_PAGE_LENGTH 16
2407 #define CP_OFF_DCE_DCC 2
2408 #define CP_OFF_C_ALGO 7
2410 #define DCE_MASK 0x80
2411 #define DCC_MASK 0x40
2412 #define RED_MASK 0x60
2415 /* Control the compression with mode page 15. Algorithm not changed if zero.
2417 The block descriptors are read and written because Sony SDT-7000 does not
2418 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2419 Including block descriptors should not cause any harm to other drives. */
2421 static int st_compression(struct scsi_tape * STp, int state)
2424 int mpoffs; /* Offset to mode page start */
2425 unsigned char *b_data = (STp->buffer)->b_data;
2426 DEB( char *name = tape_name(STp); )
2428 if (STp->ready != ST_READY)
2431 /* Read the current page contents */
2432 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2434 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2439 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2440 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2441 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2443 /* Check if compression can be changed */
2444 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2445 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2451 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2452 if (STp->c_algo != 0)
2453 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2456 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2457 if (STp->c_algo != 0)
2458 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2461 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2463 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2466 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2469 STp->compression_changed = 1;
2474 /* Process the load and unload commands (does unload if the load code is zero) */
2475 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2477 int retval = (-EIO), timeout;
2478 DEB( char *name = tape_name(STp); )
2479 unsigned char cmd[MAX_COMMAND_SIZE];
2480 struct st_partstat *STps;
2481 struct st_request *SRpnt;
2483 if (STp->ready != ST_READY && !load_code) {
2484 if (STp->ready == ST_NO_TAPE)
2485 return (-ENOMEDIUM);
2490 memset(cmd, 0, MAX_COMMAND_SIZE);
2491 cmd[0] = START_STOP;
2495 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2497 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2498 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2499 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2500 name, (cmd[4]) ? "" : "un",
2501 load_code - MT_ST_HPLOADER_OFFSET));
2502 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2504 if (STp->immediate) {
2505 cmd[1] = 1; /* Don't wait for completion */
2506 timeout = STp->device->request_queue->rq_timeout;
2509 timeout = STp->long_timeout;
2513 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2515 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2518 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2519 timeout, MAX_RETRIES, 1);
2521 return (STp->buffer)->syscall_result;
2523 retval = (STp->buffer)->syscall_result;
2524 st_release_request(SRpnt);
2526 if (!retval) { /* SCSI command successful */
2529 STp->rew_at_close = 0;
2530 STp->ready = ST_NO_TAPE;
2533 STp->rew_at_close = STp->autorew_dev;
2534 retval = check_tape(STp, filp);
2540 STps = &(STp->ps[STp->partition]);
2541 STps->drv_file = STps->drv_block = (-1);
2548 #define ST_DEB_FORWARD 0
2549 #define ST_DEB_BACKWARD 1
2550 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2554 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2555 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2558 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2559 direction ? "backward" : "forward", sc, units);
2564 /* Internal ioctl function */
2565 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2571 unsigned char cmd[MAX_COMMAND_SIZE];
2572 struct st_request *SRpnt;
2573 struct st_partstat *STps;
2574 int fileno, blkno, at_sm, undone;
2575 int datalen = 0, direction = DMA_NONE;
2576 char *name = tape_name(STp);
2578 WARN_ON(STp->buffer->do_dio != 0);
2579 if (STp->ready != ST_READY) {
2580 if (STp->ready == ST_NO_TAPE)
2581 return (-ENOMEDIUM);
2585 timeout = STp->long_timeout;
2586 STps = &(STp->ps[STp->partition]);
2587 fileno = STps->drv_file;
2588 blkno = STps->drv_block;
2589 at_sm = STps->at_sm;
2591 memset(cmd, 0, MAX_COMMAND_SIZE);
2594 chg_eof = 0; /* Changed from the FSF after this */
2597 cmd[1] = 0x01; /* Space FileMarks */
2598 cmd[2] = (arg >> 16);
2599 cmd[3] = (arg >> 8);
2601 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2605 at_sm &= (arg == 0);
2608 chg_eof = 0; /* Changed from the FSF after this */
2611 cmd[1] = 0x01; /* Space FileMarks */
2613 cmd[2] = (ltmp >> 16);
2614 cmd[3] = (ltmp >> 8);
2616 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2619 blkno = (-1); /* We can't know the block number */
2620 at_sm &= (arg == 0);
2624 cmd[1] = 0x00; /* Space Blocks */
2625 cmd[2] = (arg >> 16);
2626 cmd[3] = (arg >> 8);
2628 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2631 at_sm &= (arg == 0);
2635 cmd[1] = 0x00; /* Space Blocks */
2637 cmd[2] = (ltmp >> 16);
2638 cmd[3] = (ltmp >> 8);
2640 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2643 at_sm &= (arg == 0);
2647 cmd[1] = 0x04; /* Space Setmarks */
2648 cmd[2] = (arg >> 16);
2649 cmd[3] = (arg >> 8);
2651 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2653 blkno = fileno = (-1);
2659 cmd[1] = 0x04; /* Space Setmarks */
2661 cmd[2] = (ltmp >> 16);
2662 cmd[3] = (ltmp >> 8);
2664 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2666 blkno = fileno = (-1);
2672 if (STp->write_prot)
2674 cmd[0] = WRITE_FILEMARKS;
2675 if (cmd_in == MTWSM)
2677 cmd[2] = (arg >> 16);
2678 cmd[3] = (arg >> 8);
2680 timeout = STp->device->request_queue->rq_timeout;
2682 if (cmd_in == MTWEOF)
2683 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2684 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2686 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2687 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2692 at_sm = (cmd_in == MTWSM);
2695 cmd[0] = REZERO_UNIT;
2696 if (STp->immediate) {
2697 cmd[1] = 1; /* Don't wait for completion */
2698 timeout = STp->device->request_queue->rq_timeout;
2700 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2701 fileno = blkno = at_sm = 0;
2704 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2705 return 0; /* Should do something ? */
2708 cmd[0] = START_STOP;
2709 if (STp->immediate) {
2710 cmd[1] = 1; /* Don't wait for completion */
2711 timeout = STp->device->request_queue->rq_timeout;
2714 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2715 fileno = blkno = at_sm = 0;
2718 if (!STp->fast_mteom) {
2719 /* space to the end of tape */
2720 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2721 fileno = STps->drv_file;
2722 if (STps->eof >= ST_EOD_1)
2724 /* The next lines would hide the number of spaced FileMarks
2725 That's why I inserted the previous lines. I had no luck
2726 with detecting EOM with FSF, so we go now to EOM.
2732 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2738 if (STp->write_prot)
2741 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2742 if (STp->immediate) {
2743 cmd[1] |= 2; /* Don't wait for completion */
2744 timeout = STp->device->request_queue->rq_timeout;
2747 timeout = STp->long_timeout * 8;
2749 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2750 fileno = blkno = at_sm = 0;
2752 case MTSETBLK: /* Set block length */
2753 case MTSETDENSITY: /* Set tape density */
2754 case MTSETDRVBUFFER: /* Set drive buffering */
2755 case SET_DENS_AND_BLK: /* Set density and block size */
2757 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2758 return (-EIO); /* Not allowed if data in buffer */
2759 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2760 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2761 STp->max_block > 0 &&
2762 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2763 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2764 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2767 cmd[0] = MODE_SELECT;
2768 if ((STp->use_pf & USE_PF))
2769 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2770 cmd[4] = datalen = 12;
2771 direction = DMA_TO_DEVICE;
2773 memset((STp->buffer)->b_data, 0, 12);
2774 if (cmd_in == MTSETDRVBUFFER)
2775 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2777 (STp->buffer)->b_data[2] =
2778 STp->drv_buffer << 4;
2779 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2780 if (cmd_in == MTSETDENSITY) {
2781 (STp->buffer)->b_data[4] = arg;
2782 STp->density_changed = 1; /* At least we tried ;-) */
2783 } else if (cmd_in == SET_DENS_AND_BLK)
2784 (STp->buffer)->b_data[4] = arg >> 24;
2786 (STp->buffer)->b_data[4] = STp->density;
2787 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2788 ltmp = arg & MT_ST_BLKSIZE_MASK;
2789 if (cmd_in == MTSETBLK)
2790 STp->blksize_changed = 1; /* At least we tried ;-) */
2792 ltmp = STp->block_size;
2793 (STp->buffer)->b_data[9] = (ltmp >> 16);
2794 (STp->buffer)->b_data[10] = (ltmp >> 8);
2795 (STp->buffer)->b_data[11] = ltmp;
2796 timeout = STp->device->request_queue->rq_timeout;
2798 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2800 "%s: Setting block size to %d bytes.\n", name,
2801 (STp->buffer)->b_data[9] * 65536 +
2802 (STp->buffer)->b_data[10] * 256 +
2803 (STp->buffer)->b_data[11]);
2804 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2806 "%s: Setting density code to %x.\n", name,
2807 (STp->buffer)->b_data[4]);
2808 if (cmd_in == MTSETDRVBUFFER)
2810 "%s: Setting drive buffer code to %d.\n", name,
2811 ((STp->buffer)->b_data[2] >> 4) & 7);
2818 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2819 timeout, MAX_RETRIES, 1);
2821 return (STp->buffer)->syscall_result;
2823 ioctl_result = (STp->buffer)->syscall_result;
2825 if (!ioctl_result) { /* SCSI command successful */
2826 st_release_request(SRpnt);
2828 STps->drv_block = blkno;
2829 STps->drv_file = fileno;
2830 STps->at_sm = at_sm;
2832 if (cmd_in == MTBSFM)
2833 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2834 else if (cmd_in == MTFSFM)
2835 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2837 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2838 int old_block_size = STp->block_size;
2839 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2840 if (STp->block_size != 0) {
2841 if (old_block_size == 0)
2842 normalize_buffer(STp->buffer);
2843 (STp->buffer)->buffer_blocks =
2844 (STp->buffer)->buffer_size / STp->block_size;
2846 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2847 if (cmd_in == SET_DENS_AND_BLK)
2848 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2849 } else if (cmd_in == MTSETDRVBUFFER)
2850 STp->drv_buffer = (arg & 7);
2851 else if (cmd_in == MTSETDENSITY)
2854 if (cmd_in == MTEOM)
2856 else if (cmd_in == MTFSF)
2859 STps->eof = ST_NOEOF;
2861 if (cmd_in == MTWEOF)
2863 } else { /* SCSI command was not completely successful. Don't return
2864 from this block without releasing the SCSI command block! */
2865 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2867 if (cmdstatp->flags & SENSE_EOM) {
2868 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2869 cmd_in != MTBSR && cmd_in != MTBSS)
2870 STps->eof = ST_EOM_OK;
2871 STps->drv_block = 0;
2874 if (cmdstatp->remainder_valid)
2875 undone = (int)cmdstatp->uremainder64;
2879 if (cmd_in == MTWEOF &&
2880 cmdstatp->have_sense &&
2881 (cmdstatp->flags & SENSE_EOM)) {
2882 if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2883 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2884 ioctl_result = 0; /* EOF(s) written successfully at EOM */
2885 STps->eof = ST_NOEOF;
2886 } else { /* Writing EOF(s) failed */
2890 STps->eof = ST_NOEOF;
2892 STps->drv_file = fileno;
2893 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2895 STps->drv_file = fileno - undone;
2897 STps->drv_file = fileno;
2898 STps->drv_block = -1;
2899 STps->eof = ST_NOEOF;
2900 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2901 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2903 if (STps->drv_file >= 0)
2904 STps->drv_file = fileno + undone;
2905 STps->drv_block = 0;
2906 STps->eof = ST_NOEOF;
2907 } else if (cmd_in == MTFSR) {
2908 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2909 if (STps->drv_file >= 0)
2911 STps->drv_block = 0;
2914 if (blkno >= undone)
2915 STps->drv_block = blkno - undone;
2917 STps->drv_block = (-1);
2918 STps->eof = ST_NOEOF;
2920 } else if (cmd_in == MTBSR) {
2921 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2923 STps->drv_block = (-1);
2925 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2927 if (STps->drv_block >= 0)
2928 STps->drv_block = blkno + undone;
2930 STps->eof = ST_NOEOF;
2931 } else if (cmd_in == MTEOM) {
2932 STps->drv_file = (-1);
2933 STps->drv_block = (-1);
2935 } else if (cmd_in == MTSETBLK ||
2936 cmd_in == MTSETDENSITY ||
2937 cmd_in == MTSETDRVBUFFER ||
2938 cmd_in == SET_DENS_AND_BLK) {
2939 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2940 !(STp->use_pf & PF_TESTED)) {
2941 /* Try the other possible state of Page Format if not
2943 STp->use_pf = !STp->use_pf | PF_TESTED;
2944 st_release_request(SRpnt);
2946 return st_int_ioctl(STp, cmd_in, arg);
2949 STps->eof = ST_NOEOF;
2951 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2954 st_release_request(SRpnt);
2958 return ioctl_result;
2962 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2965 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2969 unsigned char scmd[MAX_COMMAND_SIZE];
2970 struct st_request *SRpnt;
2971 DEB( char *name = tape_name(STp); )
2973 if (STp->ready != ST_READY)
2976 memset(scmd, 0, MAX_COMMAND_SIZE);
2977 if ((STp->device)->scsi_level < SCSI_2) {
2978 scmd[0] = QFA_REQUEST_BLOCK;
2981 scmd[0] = READ_POSITION;
2982 if (!logical && !STp->scsi2_logical)
2985 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
2986 STp->device->request_queue->rq_timeout,
2987 MAX_READY_RETRIES, 1);
2989 return (STp->buffer)->syscall_result;
2991 if ((STp->buffer)->syscall_result != 0 ||
2992 (STp->device->scsi_level >= SCSI_2 &&
2993 ((STp->buffer)->b_data[0] & 4) != 0)) {
2994 *block = *partition = 0;
2995 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
2999 if ((STp->device)->scsi_level < SCSI_2) {
3000 *block = ((STp->buffer)->b_data[0] << 16)
3001 + ((STp->buffer)->b_data[1] << 8)
3002 + (STp->buffer)->b_data[2];
3005 *block = ((STp->buffer)->b_data[4] << 24)
3006 + ((STp->buffer)->b_data[5] << 16)
3007 + ((STp->buffer)->b_data[6] << 8)
3008 + (STp->buffer)->b_data[7];
3009 *partition = (STp->buffer)->b_data[1];
3010 if (((STp->buffer)->b_data[0] & 0x80) &&
3011 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
3012 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3014 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
3015 *block, *partition));
3017 st_release_request(SRpnt);
3024 /* Set the tape block and partition. Negative partition means that only the
3025 block should be set in vendor specific way. */
3026 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3029 struct st_partstat *STps;
3033 unsigned char scmd[MAX_COMMAND_SIZE];
3034 struct st_request *SRpnt;
3035 DEB( char *name = tape_name(STp); )
3037 if (STp->ready != ST_READY)
3039 timeout = STp->long_timeout;
3040 STps = &(STp->ps[STp->partition]);
3042 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3043 name, block, partition));
3044 DEB(if (partition < 0)
3047 /* Update the location at the partition we are leaving */
3048 if ((!STp->can_partitions && partition != 0) ||
3049 partition >= ST_NBR_PARTITIONS)
3051 if (partition != STp->partition) {
3052 if (get_location(STp, &blk, &p, 1))
3053 STps->last_block_valid = 0;
3055 STps->last_block_valid = 1;
3056 STps->last_block_visited = blk;
3057 DEBC(printk(ST_DEB_MSG
3058 "%s: Visited block %d for partition %d saved.\n",
3059 name, blk, STp->partition));
3063 memset(scmd, 0, MAX_COMMAND_SIZE);
3064 if ((STp->device)->scsi_level < SCSI_2) {
3065 scmd[0] = QFA_SEEK_BLOCK;
3066 scmd[2] = (block >> 16);
3067 scmd[3] = (block >> 8);
3072 scmd[3] = (block >> 24);
3073 scmd[4] = (block >> 16);
3074 scmd[5] = (block >> 8);
3076 if (!logical && !STp->scsi2_logical)
3078 if (STp->partition != partition) {
3080 scmd[8] = partition;
3081 DEBC(printk(ST_DEB_MSG
3082 "%s: Trying to change partition from %d to %d\n",
3083 name, STp->partition, partition));
3086 if (STp->immediate) {
3087 scmd[1] |= 1; /* Don't wait for completion */
3088 timeout = STp->device->request_queue->rq_timeout;
3091 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3092 timeout, MAX_READY_RETRIES, 1);
3094 return (STp->buffer)->syscall_result;
3096 STps->drv_block = STps->drv_file = (-1);
3097 STps->eof = ST_NOEOF;
3098 if ((STp->buffer)->syscall_result != 0) {
3100 if (STp->can_partitions &&
3101 (STp->device)->scsi_level >= SCSI_2 &&
3102 (p = find_partition(STp)) >= 0)
3105 if (STp->can_partitions) {
3106 STp->partition = partition;
3107 STps = &(STp->ps[partition]);
3108 if (!STps->last_block_valid ||
3109 STps->last_block_visited != block) {
3116 STps->drv_block = STps->drv_file = 0;
3120 st_release_request(SRpnt);
3127 /* Find the current partition number for the drive status. Called from open and
3128 returns either partition number of negative error code. */
3129 static int find_partition(struct scsi_tape *STp)
3134 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3136 if (partition >= ST_NBR_PARTITIONS)
3142 /* Change the partition if necessary */
3143 static int switch_partition(struct scsi_tape *STp)
3145 struct st_partstat *STps;
3147 if (STp->partition == STp->new_partition)
3149 STps = &(STp->ps[STp->new_partition]);
3150 if (!STps->last_block_valid)
3151 STps->last_block_visited = 0;
3152 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3155 /* Functions for reading and writing the medium partition mode page. */
3157 #define PART_PAGE 0x11
3158 #define PART_PAGE_FIXED_LENGTH 8
3160 #define PP_OFF_MAX_ADD_PARTS 2
3161 #define PP_OFF_NBR_ADD_PARTS 3
3162 #define PP_OFF_FLAGS 4
3163 #define PP_OFF_PART_UNITS 6
3164 #define PP_OFF_RESERVED 7
3166 #define PP_BIT_IDP 0x20
3167 #define PP_MSK_PSUM_MB 0x10
3169 /* Get the number of partitions on the tape. As a side effect reads the
3170 mode page into the tape buffer. */
3171 static int nbr_partitions(struct scsi_tape *STp)
3174 DEB( char *name = tape_name(STp); )
3176 if (STp->ready != ST_READY)
3179 result = read_mode_page(STp, PART_PAGE, 1);
3182 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3186 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3187 PP_OFF_NBR_ADD_PARTS] + 1;
3188 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3195 /* Partition the tape into two partitions if size > 0 or one partition if
3198 The block descriptors are read and written because Sony SDT-7000 does not
3199 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3201 My HP C1533A drive returns only one partition size field. This is used to
3202 set the size of partition 1. There is no size field for the default partition.
3203 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3204 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3205 The following algorithm is used to accommodate both drives: if the number of
3206 partition size fields is greater than the maximum number of additional partitions
3207 in the mode page, the second field is used. Otherwise the first field is used.
3209 For Seagate DDS drives the page length must be 8 when no partitions is defined
3210 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3211 is acceptable also to some other old drives and enforced if the first partition
3212 size field is used for the first additional partition size.
3214 static int partition_tape(struct scsi_tape *STp, int size)
3216 char *name = tape_name(STp);
3218 int pgo, psd_cnt, psdo;
3221 result = read_mode_page(STp, PART_PAGE, 0);
3223 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3226 /* The mode page is in the buffer. Let's modify it and write it. */
3227 bp = (STp->buffer)->b_data;
3228 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3229 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3230 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3232 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3233 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3234 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3235 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3238 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3240 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3241 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3242 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3245 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3246 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3247 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3248 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3251 bp[psdo] = (size >> 8) & 0xff;
3252 bp[psdo + 1] = size & 0xff;
3254 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3255 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3256 DEBC(printk(ST_DEB_MSG
3257 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3260 bp[pgo + PP_OFF_PART_UNITS] = 0;
3261 bp[pgo + PP_OFF_RESERVED] = 0;
3262 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3264 result = write_mode_page(STp, PART_PAGE, 1);
3266 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3275 /* The ioctl command */
3276 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3278 int i, cmd_nr, cmd_type, bt;
3281 struct scsi_tape *STp = file->private_data;
3282 struct st_modedef *STm;
3283 struct st_partstat *STps;
3284 char *name = tape_name(STp);
3285 void __user *p = (void __user *)arg;
3287 if (mutex_lock_interruptible(&STp->lock))
3288 return -ERESTARTSYS;
3291 if (debugging && !STp->in_use) {
3292 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3297 STm = &(STp->modes[STp->current_mode]);
3298 STps = &(STp->ps[STp->partition]);
3301 * If we are in the middle of error recovery, don't let anyone
3302 * else try and use this device. Also, if error recovery fails, it
3303 * may try and take the device offline, in which case all further
3304 * access to the device is prohibited.
3306 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
3307 file->f_flags & O_NDELAY);
3308 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3312 cmd_type = _IOC_TYPE(cmd_in);
3313 cmd_nr = _IOC_NR(cmd_in);
3315 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3318 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3323 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3329 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3331 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3335 if (!STm->defined &&
3336 (mtc.mt_op != MTSETDRVBUFFER &&
3337 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3342 if (!STp->pos_unknown) {
3344 if (STps->eof == ST_FM_HIT) {
3345 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3346 mtc.mt_op == MTEOM) {
3348 if (STps->drv_file >= 0)
3349 STps->drv_file += 1;
3350 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3352 if (STps->drv_file >= 0)
3353 STps->drv_file += 1;
3357 if (mtc.mt_op == MTSEEK) {
3358 /* Old position must be restored if partition will be
3360 i = !STp->can_partitions ||
3361 (STp->new_partition != STp->partition);
3363 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3364 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3365 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3366 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3367 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3368 mtc.mt_op == MTCOMPRESSION;
3370 i = flush_buffer(STp, i);
3375 if (STps->rw == ST_WRITING &&
3376 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3377 mtc.mt_op == MTSEEK ||
3378 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3379 i = st_int_ioctl(STp, MTWEOF, 1);
3384 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3391 * If there was a bus reset, block further access
3392 * to this device. If the user wants to rewind the tape,
3393 * then reset the flag and allow access again.
3395 if (mtc.mt_op != MTREW &&
3396 mtc.mt_op != MTOFFL &&
3397 mtc.mt_op != MTRETEN &&
3398 mtc.mt_op != MTERASE &&
3399 mtc.mt_op != MTSEEK &&
3400 mtc.mt_op != MTEOM) {
3405 /* remove this when the midlevel properly clears was_reset */
3406 STp->device->was_reset = 0;
3409 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3410 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3411 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3412 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3414 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3415 do_door_lock(STp, 0); /* Ignore result! */
3417 if (mtc.mt_op == MTSETDRVBUFFER &&
3418 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3419 retval = st_set_options(STp, mtc.mt_count);
3423 if (mtc.mt_op == MTSETPART) {
3424 if (!STp->can_partitions ||
3425 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3429 if (mtc.mt_count >= STp->nbr_partitions &&
3430 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3434 if (mtc.mt_count >= STp->nbr_partitions) {
3438 STp->new_partition = mtc.mt_count;
3443 if (mtc.mt_op == MTMKPART) {
3444 if (!STp->can_partitions) {
3448 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3449 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3453 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3454 STp->ps[i].rw = ST_IDLE;
3455 STp->ps[i].at_sm = 0;
3456 STp->ps[i].last_block_valid = 0;
3458 STp->partition = STp->new_partition = 0;
3459 STp->nbr_partitions = 1; /* Bad guess ?-) */
3460 STps->drv_block = STps->drv_file = 0;
3465 if (mtc.mt_op == MTSEEK) {
3466 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3467 if (!STp->can_partitions)
3468 STp->ps[0].rw = ST_IDLE;
3473 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3474 retval = do_load_unload(STp, file, 0);
3478 if (mtc.mt_op == MTLOAD) {
3479 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3483 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3484 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3488 if (STp->can_partitions && STp->ready == ST_READY &&
3489 (i = switch_partition(STp)) < 0) {
3494 if (mtc.mt_op == MTCOMPRESSION)
3495 retval = st_compression(STp, (mtc.mt_count & 1));
3497 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3500 if (!STm->defined) {
3505 if ((i = flush_buffer(STp, 0)) < 0) {
3509 if (STp->can_partitions &&
3510 (i = switch_partition(STp)) < 0) {
3515 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3516 struct mtget mt_status;
3518 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3523 mt_status.mt_type = STp->tape_type;
3524 mt_status.mt_dsreg =
3525 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3526 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3527 mt_status.mt_blkno = STps->drv_block;
3528 mt_status.mt_fileno = STps->drv_file;
3529 if (STp->block_size != 0) {
3530 if (STps->rw == ST_WRITING)
3531 mt_status.mt_blkno +=
3532 (STp->buffer)->buffer_bytes / STp->block_size;
3533 else if (STps->rw == ST_READING)
3534 mt_status.mt_blkno -=
3535 ((STp->buffer)->buffer_bytes +
3536 STp->block_size - 1) / STp->block_size;
3539 mt_status.mt_gstat = 0;
3540 if (STp->drv_write_prot)
3541 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3542 if (mt_status.mt_blkno == 0) {
3543 if (mt_status.mt_fileno == 0)
3544 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3546 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3548 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3549 mt_status.mt_resid = STp->partition;
3550 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3551 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3552 else if (STps->eof >= ST_EOM_OK)
3553 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3554 if (STp->density == 1)
3555 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3556 else if (STp->density == 2)
3557 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3558 else if (STp->density == 3)
3559 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3560 if (STp->ready == ST_READY)
3561 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3562 if (STp->ready == ST_NO_TAPE)
3563 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3565 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3566 if (STm->do_async_writes ||
3567 (STm->do_buffer_writes && STp->block_size != 0) ||
3568 STp->drv_buffer != 0)
3569 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3570 if (STp->cleaning_req)
3571 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3573 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3579 STp->recover_reg = 0; /* Clear after read */
3582 } /* End of MTIOCGET */
3583 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3584 struct mtpos mt_pos;
3585 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3589 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3593 mt_pos.mt_blkno = blk;
3594 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3599 mutex_unlock(&STp->lock);
3601 case SCSI_IOCTL_GET_IDLUN:
3602 case SCSI_IOCTL_GET_BUS_NUMBER:
3605 if ((cmd_in == SG_IO ||
3606 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3607 cmd_in == CDROM_SEND_PACKET) &&
3608 !capable(CAP_SYS_RAWIO))
3611 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3612 file->f_mode, cmd_in, p);
3617 retval = scsi_ioctl(STp->device, cmd_in, p);
3618 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3619 STp->rew_at_close = 0;
3620 STp->ready = ST_NO_TAPE;
3625 mutex_unlock(&STp->lock);
3629 #ifdef CONFIG_COMPAT
3630 static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3632 struct scsi_tape *STp = file->private_data;
3633 struct scsi_device *sdev = STp->device;
3634 int ret = -ENOIOCTLCMD;
3635 if (sdev->host->hostt->compat_ioctl) {
3637 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3646 /* Try to allocate a new tape buffer. Calling function must not hold
3648 static struct st_buffer *
3649 new_tape_buffer(int from_initialization, int need_dma, int max_sg)
3653 struct st_buffer *tb;
3655 if (from_initialization)
3656 priority = GFP_ATOMIC;
3658 priority = GFP_KERNEL;
3660 i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3661 max_sg * sizeof(struct st_buf_fragment);
3662 tb = kzalloc(i, priority);
3664 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3667 tb->frp_segs = tb->orig_frp_segs = 0;
3668 tb->use_sg = max_sg;
3669 tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
3672 tb->buffer_size = got;
3673 sg_init_table(tb->sg, max_sg);
3679 /* Try to allocate enough space in the tape buffer */
3680 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3682 int segs, nbr, max_segs, b_size, order, got;
3685 if (new_size <= STbuffer->buffer_size)
3688 if (STbuffer->buffer_size <= PAGE_SIZE)
3689 normalize_buffer(STbuffer); /* Avoid extra segment */
3691 max_segs = STbuffer->use_sg;
3692 nbr = max_segs - STbuffer->frp_segs;
3696 priority = GFP_KERNEL | __GFP_NOWARN;
3698 priority |= GFP_DMA;
3699 for (b_size = PAGE_SIZE, order=0; order <= 6 &&
3700 b_size < new_size - STbuffer->buffer_size;
3701 order++, b_size *= 2)
3704 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3705 segs < max_segs && got < new_size;) {
3706 STbuffer->frp[segs].page = alloc_pages(priority, order);
3707 if (STbuffer->frp[segs].page == NULL) {
3708 if (new_size - got <= (max_segs - segs) * b_size / 2) {
3709 b_size /= 2; /* Large enough for the rest of the buffers */
3713 DEB(STbuffer->buffer_size = got);
3714 normalize_buffer(STbuffer);
3717 STbuffer->frp[segs].length = b_size;
3718 STbuffer->frp_segs += 1;
3720 STbuffer->buffer_size = got;
3721 if (STbuffer->cleared)
3722 memset(page_address(STbuffer->frp[segs].page), 0, b_size);
3725 STbuffer->b_data = page_address(STbuffer->frp[0].page);
3731 /* Make sure that no data from previous user is in the internal buffer */
3732 static void clear_buffer(struct st_buffer * st_bp)
3736 for (i=0; i < st_bp->frp_segs; i++)
3737 memset(page_address(st_bp->frp[i].page), 0, st_bp->frp[i].length);
3742 /* Release the extra buffer */
3743 static void normalize_buffer(struct st_buffer * STbuffer)
3747 for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3748 order = get_order(STbuffer->frp[i].length);
3749 __free_pages(STbuffer->frp[i].page, order);
3750 STbuffer->buffer_size -= STbuffer->frp[i].length;
3752 STbuffer->frp_segs = STbuffer->orig_frp_segs;
3753 STbuffer->frp_sg_current = 0;
3754 STbuffer->sg_segs = 0;
3758 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3759 negative error code. */
3760 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3762 int i, cnt, res, offset;
3764 for (i = 0, offset = st_bp->buffer_bytes;
3765 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3766 offset -= st_bp->frp[i].length;
3767 if (i == st_bp->frp_segs) { /* Should never happen */
3768 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3771 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3772 cnt = st_bp->frp[i].length - offset < do_count ?
3773 st_bp->frp[i].length - offset : do_count;
3774 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3778 st_bp->buffer_bytes += cnt;
3782 if (do_count) /* Should never happen */
3789 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3790 negative error code. */
3791 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3793 int i, cnt, res, offset;
3795 for (i = 0, offset = st_bp->read_pointer;
3796 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3797 offset -= st_bp->frp[i].length;
3798 if (i == st_bp->frp_segs) { /* Should never happen */
3799 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3802 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3803 cnt = st_bp->frp[i].length - offset < do_count ?
3804 st_bp->frp[i].length - offset : do_count;
3805 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3809 st_bp->buffer_bytes -= cnt;
3810 st_bp->read_pointer += cnt;
3814 if (do_count) /* Should never happen */
3821 /* Move data towards start of buffer */
3822 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3824 int src_seg, dst_seg, src_offset = 0, dst_offset;
3830 total=st_bp->buffer_bytes - offset;
3831 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3832 src_offset = offset;
3833 if (src_offset < st_bp->frp[src_seg].length)
3835 offset -= st_bp->frp[src_seg].length;
3838 st_bp->buffer_bytes = st_bp->read_pointer = total;
3839 for (dst_seg=dst_offset=0; total > 0; ) {
3840 count = min(st_bp->frp[dst_seg].length - dst_offset,
3841 st_bp->frp[src_seg].length - src_offset);
3842 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3843 page_address(st_bp->frp[src_seg].page) + src_offset, count);
3844 src_offset += count;
3845 if (src_offset >= st_bp->frp[src_seg].length) {
3849 dst_offset += count;
3850 if (dst_offset >= st_bp->frp[dst_seg].length) {
3859 /* Fill the s/g list up to the length required for this transfer */
3860 static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
3864 struct scatterlist *sg;
3865 struct st_buf_fragment *frp;
3867 if (length == STbp->frp_sg_current)
3868 return; /* work already done */
3870 sg = &(STbp->sg[0]);
3872 for (i=count=0; count < length; i++) {
3873 if (length - count > frp[i].length)
3874 sg_set_page(&sg[i], frp[i].page, frp[i].length, 0);
3876 sg_set_page(&sg[i], frp[i].page, length - count, 0);
3877 count += sg[i].length;
3880 STbp->frp_sg_current = length;
3884 /* Validate the options from command line or module parameters */
3885 static void validate_options(void)
3888 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3889 if (max_sg_segs >= ST_FIRST_SG)
3890 st_max_sg_segs = max_sg_segs;
3894 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3896 static int __init st_setup(char *str)
3898 int i, len, ints[5];
3901 stp = get_options(str, ARRAY_SIZE(ints), ints);
3904 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3906 *parms[i].val = ints[i + 1];
3908 while (stp != NULL) {
3909 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3910 len = strlen(parms[i].name);
3911 if (!strncmp(stp, parms[i].name, len) &&
3912 (*(stp + len) == ':' || *(stp + len) == '=')) {
3915 simple_strtoul(stp + len + 1, NULL, 0);
3917 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3922 if (i >= ARRAY_SIZE(parms))
3923 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3925 stp = strchr(stp, ',');
3936 __setup("st=", st_setup);
3940 static const struct file_operations st_fops =
3942 .owner = THIS_MODULE,
3945 .unlocked_ioctl = st_ioctl,
3946 #ifdef CONFIG_COMPAT
3947 .compat_ioctl = st_compat_ioctl,
3951 .release = st_release,
3954 static int st_probe(struct device *dev)
3956 struct scsi_device *SDp = to_scsi_device(dev);
3957 struct gendisk *disk = NULL;
3958 struct cdev *cdev = NULL;
3959 struct scsi_tape *tpnt = NULL;
3960 struct st_modedef *STm;
3961 struct st_partstat *STps;
3962 struct st_buffer *buffer;
3963 int i, j, mode, dev_num, error;
3966 if (SDp->type != TYPE_TAPE)
3968 if ((stp = st_incompatible(SDp))) {
3969 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
3970 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3974 i = min(SDp->request_queue->max_hw_segments,
3975 SDp->request_queue->max_phys_segments);
3976 if (st_max_sg_segs < i)
3978 buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i);
3979 if (buffer == NULL) {
3981 "st: Can't allocate new tape buffer. Device not attached.\n");
3985 disk = alloc_disk(1);
3987 printk(KERN_ERR "st: out of memory. Device not attached.\n");
3988 goto out_buffer_free;
3991 write_lock(&st_dev_arr_lock);
3992 if (st_nr_dev >= st_dev_max) {
3993 struct scsi_tape **tmp_da;
3996 tmp_dev_max = max(st_nr_dev * 2, 8);
3997 if (tmp_dev_max > ST_MAX_TAPES)
3998 tmp_dev_max = ST_MAX_TAPES;
3999 if (tmp_dev_max <= st_nr_dev) {
4000 write_unlock(&st_dev_arr_lock);
4001 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
4006 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
4007 if (tmp_da == NULL) {
4008 write_unlock(&st_dev_arr_lock);
4009 printk(KERN_ERR "st: Can't extend device array.\n");
4013 if (scsi_tapes != NULL) {
4014 memcpy(tmp_da, scsi_tapes,
4015 st_dev_max * sizeof(struct scsi_tape *));
4018 scsi_tapes = tmp_da;
4020 st_dev_max = tmp_dev_max;
4023 for (i = 0; i < st_dev_max; i++)
4024 if (scsi_tapes[i] == NULL)
4026 if (i >= st_dev_max)
4027 panic("scsi_devices corrupt (st)");
4029 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
4031 write_unlock(&st_dev_arr_lock);
4032 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
4035 kref_init(&tpnt->kref);
4037 sprintf(disk->disk_name, "st%d", i);
4038 disk->private_data = &tpnt->driver;
4039 disk->queue = SDp->request_queue;
4040 tpnt->driver = &st_template;
4041 scsi_tapes[i] = tpnt;
4045 if (SDp->scsi_level <= 2)
4046 tpnt->tape_type = MT_ISSCSI1;
4048 tpnt->tape_type = MT_ISSCSI2;
4050 tpnt->buffer = buffer;
4051 tpnt->buffer->last_SRpnt = NULL;
4056 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
4057 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4058 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4060 tpnt->do_auto_lock = ST_AUTO_LOCK;
4061 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4062 tpnt->can_partitions = 0;
4063 tpnt->two_fm = ST_TWO_FM;
4064 tpnt->fast_mteom = ST_FAST_MTEOM;
4065 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4066 tpnt->sili = ST_SILI;
4067 tpnt->immediate = ST_NOWAIT;
4068 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
4069 tpnt->partition = 0;
4070 tpnt->new_partition = 0;
4071 tpnt->nbr_partitions = 0;
4072 blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
4073 tpnt->long_timeout = ST_LONG_TIMEOUT;
4074 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4076 for (i = 0; i < ST_NBR_MODES; i++) {
4077 STm = &(tpnt->modes[i]);
4079 STm->sysv = ST_SYSV;
4080 STm->defaults_for_writes = 0;
4081 STm->do_async_writes = ST_ASYNC_WRITES;
4082 STm->do_buffer_writes = ST_BUFFER_WRITES;
4083 STm->do_read_ahead = ST_READ_AHEAD;
4084 STm->default_compression = ST_DONT_TOUCH;
4085 STm->default_blksize = (-1); /* No forced size */
4086 STm->default_density = (-1); /* No forced density */
4089 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4090 STps = &(tpnt->ps[i]);
4092 STps->eof = ST_NOEOF;
4094 STps->last_block_valid = 0;
4095 STps->drv_block = (-1);
4096 STps->drv_file = (-1);
4099 tpnt->current_mode = 0;
4100 tpnt->modes[0].defined = 1;
4102 tpnt->density_changed = tpnt->compression_changed =
4103 tpnt->blksize_changed = 0;
4104 mutex_init(&tpnt->lock);
4107 write_unlock(&st_dev_arr_lock);
4109 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4110 STm = &(tpnt->modes[mode]);
4111 for (j=0; j < 2; j++) {
4112 cdev = cdev_alloc();
4115 "st%d: out of memory. Device not attached.\n",
4119 cdev->owner = THIS_MODULE;
4120 cdev->ops = &st_fops;
4122 error = cdev_add(cdev,
4123 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4126 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4127 dev_num, j ? "non" : "auto", mode);
4128 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4131 STm->cdevs[j] = cdev;
4134 error = do_create_class_files(tpnt, dev_num, mode);
4139 sdev_printk(KERN_NOTICE, SDp,
4140 "Attached scsi tape %s\n", tape_name(tpnt));
4141 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4142 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4143 queue_dma_alignment(SDp->request_queue) + 1);
4148 for (mode=0; mode < ST_NBR_MODES; mode++) {
4149 STm = &(tpnt->modes[mode]);
4150 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4152 for (j=0; j < 2; j++) {
4153 if (STm->cdevs[j]) {
4154 if (cdev == STm->cdevs[j])
4156 device_destroy(st_sysfs_class,
4157 MKDEV(SCSI_TAPE_MAJOR,
4158 TAPE_MINOR(i, mode, j)));
4159 cdev_del(STm->cdevs[j]);
4165 write_lock(&st_dev_arr_lock);
4166 scsi_tapes[dev_num] = NULL;
4168 write_unlock(&st_dev_arr_lock);
4179 static int st_remove(struct device *dev)
4181 struct scsi_device *SDp = to_scsi_device(dev);
4182 struct scsi_tape *tpnt;
4185 write_lock(&st_dev_arr_lock);
4186 for (i = 0; i < st_dev_max; i++) {
4187 tpnt = scsi_tapes[i];
4188 if (tpnt != NULL && tpnt->device == SDp) {
4189 scsi_tapes[i] = NULL;
4191 write_unlock(&st_dev_arr_lock);
4192 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4194 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4195 for (j=0; j < 2; j++) {
4196 device_destroy(st_sysfs_class,
4197 MKDEV(SCSI_TAPE_MAJOR,
4198 TAPE_MINOR(i, mode, j)));
4199 cdev_del(tpnt->modes[mode].cdevs[j]);
4200 tpnt->modes[mode].cdevs[j] = NULL;
4204 mutex_lock(&st_ref_mutex);
4205 kref_put(&tpnt->kref, scsi_tape_release);
4206 mutex_unlock(&st_ref_mutex);
4211 write_unlock(&st_dev_arr_lock);
4216 * scsi_tape_release - Called to free the Scsi_Tape structure
4217 * @kref: pointer to embedded kref
4219 * st_ref_mutex must be held entering this routine. Because it is
4220 * called on last put, you should always use the scsi_tape_get()
4221 * scsi_tape_put() helpers which manipulate the semaphore directly
4222 * and never do a direct kref_put().
4224 static void scsi_tape_release(struct kref *kref)
4226 struct scsi_tape *tpnt = to_scsi_tape(kref);
4227 struct gendisk *disk = tpnt->disk;
4229 tpnt->device = NULL;
4232 tpnt->buffer->orig_frp_segs = 0;
4233 normalize_buffer(tpnt->buffer);
4234 kfree(tpnt->buffer);
4237 disk->private_data = NULL;
4243 static int __init init_st(void)
4249 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4250 verstr, st_fixed_buffer_size, st_max_sg_segs);
4252 st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
4253 if (IS_ERR(st_sysfs_class)) {
4254 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4255 return PTR_ERR(st_sysfs_class);
4258 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4259 ST_MAX_TAPE_ENTRIES, "st");
4261 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4266 err = scsi_register_driver(&st_template.gendrv);
4270 err = do_create_sysfs_files();
4277 scsi_unregister_driver(&st_template.gendrv);
4279 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4280 ST_MAX_TAPE_ENTRIES);
4282 class_destroy(st_sysfs_class);
4286 static void __exit exit_st(void)
4288 do_remove_sysfs_files();
4289 scsi_unregister_driver(&st_template.gendrv);
4290 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4291 ST_MAX_TAPE_ENTRIES);
4292 class_destroy(st_sysfs_class);
4294 printk(KERN_INFO "st: Unloaded.\n");
4297 module_init(init_st);
4298 module_exit(exit_st);
4301 /* The sysfs driver interface. Read-only at the moment */
4302 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4304 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4306 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4308 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4310 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4312 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4314 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4316 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4318 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4320 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4322 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4324 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4326 static int do_create_sysfs_files(void)
4328 struct device_driver *sysfs = &st_template.gendrv;
4331 err = driver_create_file(sysfs, &driver_attr_try_direct_io);
4334 err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
4336 goto err_try_direct_io;
4337 err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
4339 goto err_attr_fixed_buf;
4340 err = driver_create_file(sysfs, &driver_attr_version);
4342 goto err_attr_max_sg;
4347 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4349 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4351 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4355 static void do_remove_sysfs_files(void)
4357 struct device_driver *sysfs = &st_template.gendrv;
4359 driver_remove_file(sysfs, &driver_attr_version);
4360 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4361 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4362 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4366 /* The sysfs simple class interface */
4368 st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4370 struct st_modedef *STm = dev_get_drvdata(dev);
4373 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4377 DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4380 st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
4382 struct st_modedef *STm = dev_get_drvdata(dev);
4385 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4389 DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4392 st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
4394 struct st_modedef *STm = dev_get_drvdata(dev);
4398 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4399 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4403 DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4406 st_defcompression_show(struct device *dev, struct device_attribute *attr,
4409 struct st_modedef *STm = dev_get_drvdata(dev);
4412 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4416 DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4419 st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
4421 struct st_modedef *STm = dev_get_drvdata(dev);
4422 struct scsi_tape *STp;
4426 for (i=0; i < st_dev_max; i++) {
4427 for (j=0; j < ST_NBR_MODES; j++)
4428 if (&scsi_tapes[i]->modes[j] == STm)
4430 if (j < ST_NBR_MODES)
4433 if (i == st_dev_max)
4434 return 0; /* should never happen */
4436 STp = scsi_tapes[i];
4438 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4439 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4440 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4441 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4442 options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4443 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4444 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4445 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4446 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4447 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4448 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4449 options |= STm->sysv ? MT_ST_SYSV : 0;
4450 options |= STp->immediate ? MT_ST_NOWAIT : 0;
4451 options |= STp->sili ? MT_ST_SILI : 0;
4453 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4457 DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
4459 static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4463 struct device *st_class_member;
4465 for (rew=0; rew < 2; rew++) {
4466 /* Make sure that the minor numbers corresponding to the four
4467 first modes always get the same names */
4468 i = mode << (4 - ST_NBR_MODE_BITS);
4469 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4470 STp->disk->disk_name, st_formats[i]);
4472 device_create(st_sysfs_class, &STp->device->sdev_gendev,
4473 MKDEV(SCSI_TAPE_MAJOR,
4474 TAPE_MINOR(dev_num, mode, rew)),
4475 &STp->modes[mode], "%s", name);
4476 if (IS_ERR(st_class_member)) {
4477 printk(KERN_WARNING "st%d: device_create failed\n",
4479 error = PTR_ERR(st_class_member);
4483 error = device_create_file(st_class_member,
4485 if (error) goto out;
4486 error = device_create_file(st_class_member,
4487 &dev_attr_default_blksize);
4488 if (error) goto out;
4489 error = device_create_file(st_class_member,
4490 &dev_attr_default_density);
4491 if (error) goto out;
4492 error = device_create_file(st_class_member,
4493 &dev_attr_default_compression);
4494 if (error) goto out;
4495 error = device_create_file(st_class_member,
4497 if (error) goto out;
4499 if (mode == 0 && rew == 0) {
4500 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4501 &st_class_member->kobj,
4505 "st%d: Can't create sysfs link from SCSI device.\n",
4518 /* The following functions may be useful for a larger audience. */
4519 static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4520 unsigned long uaddr, size_t count, int rw)
4522 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4523 unsigned long start = uaddr >> PAGE_SHIFT;
4524 const int nr_pages = end - start;
4526 struct page **pages;
4528 /* User attempted Overflow! */
4529 if ((uaddr + count) < uaddr)
4533 if (nr_pages > max_pages)
4540 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4543 /* Try to fault in all of the necessary pages */
4544 down_read(¤t->mm->mmap_sem);
4545 /* rw==READ means read from drive, write into memory area */
4546 res = get_user_pages(
4552 0, /* don't force */
4555 up_read(¤t->mm->mmap_sem);
4557 /* Errors and no page mapped should return here */
4561 for (i=0; i < nr_pages; i++) {
4562 /* FIXME: flush superflous for rw==READ,
4563 * probably wrong function for rw==WRITE
4565 flush_dcache_page(pages[i]);
4568 /* Populate the scatter/gather list */
4569 sg_set_page(&sgl[0], pages[0], 0, uaddr & ~PAGE_MASK);
4571 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4572 count -= sgl[0].length;
4573 for (i=1; i < nr_pages ; i++) {
4574 sg_set_page(&sgl[i], pages[i],
4575 count < PAGE_SIZE ? count : PAGE_SIZE, 0);;
4580 sgl[0].length = count;
4588 for (j=0; j < res; j++)
4589 page_cache_release(pages[j]);
4597 /* And unmap them... */
4598 static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4603 for (i=0; i < nr_pages; i++) {
4604 struct page *page = sg_page(&sgl[i]);
4608 /* FIXME: cache flush missing for rw==READ
4609 * FIXME: call the correct reference counting function
4611 page_cache_release(page);