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 - 2010 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 = "20101219";
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/slab.h>
31 #include <linux/errno.h>
32 #include <linux/mtio.h>
33 #include <linux/cdrom.h>
34 #include <linux/ioctl.h>
35 #include <linux/fcntl.h>
36 #include <linux/spinlock.h>
37 #include <linux/blkdev.h>
38 #include <linux/moduleparam.h>
39 #include <linux/cdev.h>
40 #include <linux/delay.h>
41 #include <linux/mutex.h>
43 #include <asm/uaccess.h>
46 #include <scsi/scsi.h>
47 #include <scsi/scsi_dbg.h>
48 #include <scsi/scsi_device.h>
49 #include <scsi/scsi_driver.h>
50 #include <scsi/scsi_eh.h>
51 #include <scsi/scsi_host.h>
52 #include <scsi/scsi_ioctl.h>
56 /* The driver prints some debugging information on the console if DEBUG
57 is defined and non-zero. */
61 /* The message level for the debug messages is currently set to KERN_NOTICE
62 so that people can easily see the messages. Later when the debugging messages
63 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
64 #define ST_DEB_MSG KERN_NOTICE
66 #define DEBC(a) if (debugging) { a ; }
72 #define ST_KILOBYTE 1024
74 #include "st_options.h"
77 static DEFINE_MUTEX(st_mutex);
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 int enlarge_buffer(struct st_buffer *, int, int);
186 static void clear_buffer(struct st_buffer *);
187 static void normalize_buffer(struct st_buffer *);
188 static int append_to_buffer(const char __user *, struct st_buffer *, int);
189 static int from_buffer(struct st_buffer *, char __user *, int);
190 static void move_buffer_data(struct st_buffer *, int);
192 static int sgl_map_user_pages(struct st_buffer *, const unsigned int,
193 unsigned long, size_t, int);
194 static int sgl_unmap_user_pages(struct st_buffer *, const unsigned int, int);
196 static int st_probe(struct device *);
197 static int st_remove(struct device *);
199 static int do_create_sysfs_files(void);
200 static void do_remove_sysfs_files(void);
201 static int do_create_class_files(struct scsi_tape *, int, int);
203 static struct scsi_driver st_template = {
204 .owner = THIS_MODULE,
212 static int st_compression(struct scsi_tape *, int);
214 static int find_partition(struct scsi_tape *);
215 static int switch_partition(struct scsi_tape *);
217 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
219 static void scsi_tape_release(struct kref *);
221 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
223 static DEFINE_MUTEX(st_ref_mutex);
226 #include "osst_detect.h"
227 #ifndef SIGS_FROM_OSST
228 #define SIGS_FROM_OSST \
229 {"OnStream", "SC-", "", "osst"}, \
230 {"OnStream", "DI-", "", "osst"}, \
231 {"OnStream", "DP-", "", "osst"}, \
232 {"OnStream", "USB", "", "osst"}, \
233 {"OnStream", "FW-", "", "osst"}
236 static struct scsi_tape *scsi_tape_get(int dev)
238 struct scsi_tape *STp = NULL;
240 mutex_lock(&st_ref_mutex);
241 write_lock(&st_dev_arr_lock);
243 if (dev < st_dev_max && scsi_tapes != NULL)
244 STp = scsi_tapes[dev];
247 kref_get(&STp->kref);
252 if (scsi_device_get(STp->device))
258 kref_put(&STp->kref, scsi_tape_release);
261 write_unlock(&st_dev_arr_lock);
262 mutex_unlock(&st_ref_mutex);
266 static void scsi_tape_put(struct scsi_tape *STp)
268 struct scsi_device *sdev = STp->device;
270 mutex_lock(&st_ref_mutex);
271 kref_put(&STp->kref, scsi_tape_release);
272 scsi_device_put(sdev);
273 mutex_unlock(&st_ref_mutex);
276 struct st_reject_data {
280 char *driver_hint; /* Name of the correct driver, NULL if unknown */
283 static struct st_reject_data reject_list[] = {
284 /* {"XXX", "Yy-", "", NULL}, example */
288 /* If the device signature is on the list of incompatible drives, the
289 function returns a pointer to the name of the correct driver (if known) */
290 static char * st_incompatible(struct scsi_device* SDp)
292 struct st_reject_data *rp;
294 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
295 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
296 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
297 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
299 return rp->driver_hint;
307 static inline char *tape_name(struct scsi_tape *tape)
309 return tape->disk->disk_name;
313 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
316 const u8 *sense = SRpnt->sense;
318 s->have_sense = scsi_normalize_sense(SRpnt->sense,
319 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
325 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
326 switch (sense[0] & 0x7f) {
331 s->flags = sense[2] & 0xe0;
337 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
338 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
345 /* Convert the result to success code */
346 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
348 int result = SRpnt->result;
350 DEB(const char *stp;)
351 char *name = tape_name(STp);
352 struct st_cmdstatus *cmdstatp;
357 cmdstatp = &STp->buffer->cmdstat;
358 st_analyze_sense(SRpnt, cmdstatp);
360 if (cmdstatp->have_sense)
361 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
367 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
369 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
370 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
371 if (cmdstatp->have_sense)
372 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
374 if (!debugging) { /* Abnormal conditions for tape */
375 if (!cmdstatp->have_sense)
377 "%s: Error %x (driver bt 0x%x, host bt 0x%x).\n",
378 name, result, driver_byte(result),
380 else if (cmdstatp->have_sense &&
382 scode != RECOVERED_ERROR &&
383 /* scode != UNIT_ATTENTION && */
384 scode != BLANK_CHECK &&
385 scode != VOLUME_OVERFLOW &&
386 SRpnt->cmd[0] != MODE_SENSE &&
387 SRpnt->cmd[0] != TEST_UNIT_READY) {
389 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
393 if (cmdstatp->fixed_format &&
394 STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */
395 if (STp->cln_sense_value)
396 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
397 STp->cln_sense_mask) == STp->cln_sense_value);
399 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
400 STp->cln_sense_mask) != 0);
402 if (cmdstatp->have_sense &&
403 cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
404 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
406 STp->pos_unknown |= STp->device->was_reset;
408 if (cmdstatp->have_sense &&
409 scode == RECOVERED_ERROR
410 #if ST_RECOVERED_WRITE_FATAL
411 && SRpnt->cmd[0] != WRITE_6
412 && SRpnt->cmd[0] != WRITE_FILEMARKS
415 STp->recover_count++;
420 if (SRpnt->cmd[0] == READ_6)
422 else if (SRpnt->cmd[0] == WRITE_6)
426 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
430 if (cmdstatp->flags == 0)
436 static struct st_request *st_allocate_request(struct scsi_tape *stp)
438 struct st_request *streq;
440 streq = kzalloc(sizeof(*streq), GFP_KERNEL);
444 DEBC(printk(KERN_ERR "%s: Can't get SCSI request.\n",
446 if (signal_pending(current))
447 stp->buffer->syscall_result = -EINTR;
449 stp->buffer->syscall_result = -EBUSY;
455 static void st_release_request(struct st_request *streq)
460 static void st_scsi_execute_end(struct request *req, int uptodate)
462 struct st_request *SRpnt = req->end_io_data;
463 struct scsi_tape *STp = SRpnt->stp;
466 STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors;
467 STp->buffer->cmdstat.residual = req->resid_len;
471 complete(SRpnt->waiting);
473 blk_rq_unmap_user(tmp);
474 __blk_put_request(req->q, req);
477 static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
478 int data_direction, void *buffer, unsigned bufflen,
479 int timeout, int retries)
482 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
484 int write = (data_direction == DMA_TO_DEVICE);
486 req = blk_get_request(SRpnt->stp->device->request_queue, write,
489 return DRIVER_ERROR << 24;
491 req->cmd_type = REQ_TYPE_BLOCK_PC;
492 req->cmd_flags |= REQ_QUIET;
494 mdata->null_mapped = 1;
497 err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen,
500 blk_put_request(req);
501 return DRIVER_ERROR << 24;
505 SRpnt->bio = req->bio;
506 req->cmd_len = COMMAND_SIZE(cmd[0]);
507 memset(req->cmd, 0, BLK_MAX_CDB);
508 memcpy(req->cmd, cmd, req->cmd_len);
509 req->sense = SRpnt->sense;
511 req->timeout = timeout;
512 req->retries = retries;
513 req->end_io_data = SRpnt;
515 blk_execute_rq_nowait(req->q, NULL, req, 1, st_scsi_execute_end);
519 /* Do the scsi command. Waits until command performed if do_wait is true.
520 Otherwise write_behind_check() is used to check that the command
522 static struct st_request *
523 st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
524 int bytes, int direction, int timeout, int retries, int do_wait)
526 struct completion *waiting;
527 struct rq_map_data *mdata = &STp->buffer->map_data;
530 /* if async, make sure there's no command outstanding */
531 if (!do_wait && ((STp->buffer)->last_SRpnt)) {
532 printk(KERN_ERR "%s: Async command already active.\n",
534 if (signal_pending(current))
535 (STp->buffer)->syscall_result = (-EINTR);
537 (STp->buffer)->syscall_result = (-EBUSY);
542 SRpnt = st_allocate_request(STp);
547 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
548 which IO is outstanding. It's nulled out when the IO completes. */
550 (STp->buffer)->last_SRpnt = SRpnt;
552 waiting = &STp->wait;
553 init_completion(waiting);
554 SRpnt->waiting = waiting;
556 if (STp->buffer->do_dio) {
557 mdata->page_order = 0;
558 mdata->nr_entries = STp->buffer->sg_segs;
559 mdata->pages = STp->buffer->mapped_pages;
561 mdata->page_order = STp->buffer->reserved_page_order;
563 DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order);
564 mdata->pages = STp->buffer->reserved_pages;
568 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
569 STp->buffer->cmdstat.have_sense = 0;
570 STp->buffer->syscall_result = 0;
572 ret = st_scsi_execute(SRpnt, cmd, direction, NULL, bytes, timeout,
575 /* could not allocate the buffer or request was too large */
576 (STp->buffer)->syscall_result = (-EBUSY);
577 (STp->buffer)->last_SRpnt = NULL;
578 } else if (do_wait) {
579 wait_for_completion(waiting);
580 SRpnt->waiting = NULL;
581 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
588 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
589 write has been correct but EOM early warning reached, -EIO if write ended in
590 error or zero if write successful. Asynchronous writes are used only in
591 variable block mode. */
592 static int write_behind_check(struct scsi_tape * STp)
595 struct st_buffer *STbuffer;
596 struct st_partstat *STps;
597 struct st_cmdstatus *cmdstatp;
598 struct st_request *SRpnt;
600 STbuffer = STp->buffer;
601 if (!STbuffer->writing)
605 if (STp->write_pending)
611 wait_for_completion(&(STp->wait));
612 SRpnt = STbuffer->last_SRpnt;
613 STbuffer->last_SRpnt = NULL;
614 SRpnt->waiting = NULL;
616 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
617 st_release_request(SRpnt);
619 STbuffer->buffer_bytes -= STbuffer->writing;
620 STps = &(STp->ps[STp->partition]);
621 if (STps->drv_block >= 0) {
622 if (STp->block_size == 0)
625 STps->drv_block += STbuffer->writing / STp->block_size;
628 cmdstatp = &STbuffer->cmdstat;
629 if (STbuffer->syscall_result) {
631 if (cmdstatp->have_sense && !cmdstatp->deferred &&
632 (cmdstatp->flags & SENSE_EOM) &&
633 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
634 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
635 /* EOM at write-behind, has all data been written? */
636 if (!cmdstatp->remainder_valid ||
637 cmdstatp->uremainder64 == 0)
641 STps->drv_block = -1;
643 STbuffer->writing = 0;
645 DEB(if (debugging && retval)
646 printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n",
647 tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
653 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
654 it messes up the block number). */
655 static int cross_eof(struct scsi_tape * STp, int forward)
657 struct st_request *SRpnt;
658 unsigned char cmd[MAX_COMMAND_SIZE];
661 cmd[1] = 0x01; /* Space FileMarks */
666 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
669 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
670 tape_name(STp), forward ? "forward" : "backward"));
672 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
673 STp->device->request_queue->rq_timeout,
676 return (STp->buffer)->syscall_result;
678 st_release_request(SRpnt);
681 if ((STp->buffer)->cmdstat.midlevel_result != 0)
682 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
683 tape_name(STp), forward ? "forward" : "backward");
685 return (STp->buffer)->syscall_result;
689 /* Flush the write buffer (never need to write if variable blocksize). */
690 static int st_flush_write_buffer(struct scsi_tape * STp)
694 unsigned char cmd[MAX_COMMAND_SIZE];
695 struct st_request *SRpnt;
696 struct st_partstat *STps;
698 result = write_behind_check(STp);
703 if (STp->dirty == 1) {
705 transfer = STp->buffer->buffer_bytes;
706 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
707 tape_name(STp), transfer));
709 memset(cmd, 0, MAX_COMMAND_SIZE);
712 blks = transfer / STp->block_size;
717 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
718 STp->device->request_queue->rq_timeout,
719 MAX_WRITE_RETRIES, 1);
721 return (STp->buffer)->syscall_result;
723 STps = &(STp->ps[STp->partition]);
724 if ((STp->buffer)->syscall_result != 0) {
725 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
727 if (cmdstatp->have_sense && !cmdstatp->deferred &&
728 (cmdstatp->flags & SENSE_EOM) &&
729 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
730 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
731 (!cmdstatp->remainder_valid ||
732 cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
734 (STp->buffer)->buffer_bytes = 0;
735 if (STps->drv_block >= 0)
736 STps->drv_block += blks;
739 printk(KERN_ERR "%s: Error on flush.\n",
741 STps->drv_block = (-1);
745 if (STps->drv_block >= 0)
746 STps->drv_block += blks;
748 (STp->buffer)->buffer_bytes = 0;
750 st_release_request(SRpnt);
757 /* Flush the tape buffer. The tape will be positioned correctly unless
758 seek_next is true. */
759 static int flush_buffer(struct scsi_tape *STp, int seek_next)
761 int backspace, result;
762 struct st_buffer *STbuffer;
763 struct st_partstat *STps;
765 STbuffer = STp->buffer;
768 * If there was a bus reset, block further access
771 if (STp->pos_unknown)
774 if (STp->ready != ST_READY)
776 STps = &(STp->ps[STp->partition]);
777 if (STps->rw == ST_WRITING) /* Writing */
778 return st_flush_write_buffer(STp);
780 if (STp->block_size == 0)
783 backspace = ((STp->buffer)->buffer_bytes +
784 (STp->buffer)->read_pointer) / STp->block_size -
785 ((STp->buffer)->read_pointer + STp->block_size - 1) /
787 (STp->buffer)->buffer_bytes = 0;
788 (STp->buffer)->read_pointer = 0;
791 if (STps->eof == ST_FM_HIT) {
792 result = cross_eof(STp, 0); /* Back over the EOF hit */
794 STps->eof = ST_NOEOF;
796 if (STps->drv_file >= 0)
801 if (!result && backspace > 0)
802 result = st_int_ioctl(STp, MTBSR, backspace);
803 } else if (STps->eof == ST_FM_HIT) {
804 if (STps->drv_file >= 0)
807 STps->eof = ST_NOEOF;
813 /* Set the mode parameters */
814 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
818 char *name = tape_name(STp);
820 if (!STp->density_changed &&
821 STm->default_density >= 0 &&
822 STm->default_density != STp->density) {
823 arg = STm->default_density;
827 arg <<= MT_ST_DENSITY_SHIFT;
828 if (!STp->blksize_changed &&
829 STm->default_blksize >= 0 &&
830 STm->default_blksize != STp->block_size) {
831 arg |= STm->default_blksize;
834 arg |= STp->block_size;
836 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
838 "%s: Can't set default block size to %d bytes and density %x.\n",
839 name, STm->default_blksize, STm->default_density);
847 /* Lock or unlock the drive door. Don't use when st_request allocated. */
848 static int do_door_lock(struct scsi_tape * STp, int do_lock)
851 DEB(char *name = tape_name(STp);)
854 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
855 DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
856 do_lock ? "L" : "Unl"));
857 retval = scsi_ioctl(STp->device, cmd, NULL);
859 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
862 STp->door_locked = ST_LOCK_FAILS;
868 /* Set the internal state after reset */
869 static void reset_state(struct scsi_tape *STp)
872 struct st_partstat *STps;
874 STp->pos_unknown = 0;
875 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
876 STps = &(STp->ps[i]);
878 STps->eof = ST_NOEOF;
880 STps->last_block_valid = 0;
881 STps->drv_block = -1;
884 if (STp->can_partitions) {
885 STp->partition = find_partition(STp);
886 if (STp->partition < 0)
888 STp->new_partition = STp->partition;
892 /* Test if the drive is ready. Returns either one of the codes below or a negative system
894 #define CHKRES_READY 0
895 #define CHKRES_NEW_SESSION 1
896 #define CHKRES_NOT_READY 2
897 #define CHKRES_NO_TAPE 3
899 #define MAX_ATTENTIONS 10
901 static int test_ready(struct scsi_tape *STp, int do_wait)
903 int attentions, waits, max_wait, scode;
904 int retval = CHKRES_READY, new_session = 0;
905 unsigned char cmd[MAX_COMMAND_SIZE];
906 struct st_request *SRpnt = NULL;
907 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
909 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
911 for (attentions=waits=0; ; ) {
912 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
913 cmd[0] = TEST_UNIT_READY;
914 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
915 STp->long_timeout, MAX_READY_RETRIES, 1);
918 retval = (STp->buffer)->syscall_result;
922 if (cmdstatp->have_sense) {
924 scode = cmdstatp->sense_hdr.sense_key;
926 if (scode == UNIT_ATTENTION) { /* New media? */
928 if (attentions < MAX_ATTENTIONS) {
938 if (scode == NOT_READY) {
939 if (waits < max_wait) {
940 if (msleep_interruptible(1000)) {
948 if ((STp->device)->scsi_level >= SCSI_2 &&
949 cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
950 retval = CHKRES_NO_TAPE;
952 retval = CHKRES_NOT_READY;
958 retval = (STp->buffer)->syscall_result;
960 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
965 st_release_request(SRpnt);
970 /* See if the drive is ready and gather information about the tape. Return values:
971 < 0 negative error code from errno.h
973 1 drive not ready (possibly no tape)
975 static int check_tape(struct scsi_tape *STp, struct file *filp)
977 int i, retval, new_session = 0, do_wait;
978 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
979 unsigned short st_flags = filp->f_flags;
980 struct st_request *SRpnt = NULL;
981 struct st_modedef *STm;
982 struct st_partstat *STps;
983 char *name = tape_name(STp);
984 struct inode *inode = filp->f_path.dentry->d_inode;
985 int mode = TAPE_MODE(inode);
987 STp->ready = ST_READY;
989 if (mode != STp->current_mode) {
990 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
991 name, STp->current_mode, mode));
993 STp->current_mode = mode;
995 STm = &(STp->modes[STp->current_mode]);
997 saved_cleaning = STp->cleaning_req;
998 STp->cleaning_req = 0;
1000 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
1001 retval = test_ready(STp, do_wait);
1006 if (retval == CHKRES_NEW_SESSION) {
1007 STp->pos_unknown = 0;
1008 STp->partition = STp->new_partition = 0;
1009 if (STp->can_partitions)
1010 STp->nbr_partitions = 1; /* This guess will be updated later
1012 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1013 STps = &(STp->ps[i]);
1015 STps->eof = ST_NOEOF;
1017 STps->last_block_valid = 0;
1018 STps->drv_block = 0;
1024 STp->cleaning_req |= saved_cleaning;
1026 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
1027 if (retval == CHKRES_NO_TAPE)
1028 STp->ready = ST_NO_TAPE;
1030 STp->ready = ST_NOT_READY;
1032 STp->density = 0; /* Clear the erroneous "residue" */
1033 STp->write_prot = 0;
1034 STp->block_size = 0;
1035 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
1036 STp->partition = STp->new_partition = 0;
1037 STp->door_locked = ST_UNLOCKED;
1038 return CHKRES_NOT_READY;
1042 if (STp->omit_blklims)
1043 STp->min_block = STp->max_block = (-1);
1045 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1046 cmd[0] = READ_BLOCK_LIMITS;
1048 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
1049 STp->device->request_queue->rq_timeout,
1050 MAX_READY_RETRIES, 1);
1052 retval = (STp->buffer)->syscall_result;
1056 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
1057 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1058 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1059 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1060 (STp->buffer)->b_data[5];
1061 if ( DEB( debugging || ) !STp->inited)
1063 "%s: Block limits %d - %d bytes.\n", name,
1064 STp->min_block, STp->max_block);
1066 STp->min_block = STp->max_block = (-1);
1067 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1072 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1073 cmd[0] = MODE_SENSE;
1076 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1077 STp->device->request_queue->rq_timeout,
1078 MAX_READY_RETRIES, 1);
1080 retval = (STp->buffer)->syscall_result;
1084 if ((STp->buffer)->syscall_result != 0) {
1085 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1086 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
1087 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */
1088 STp->drv_write_prot = 0;
1090 DEBC(printk(ST_DEB_MSG
1091 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1093 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1094 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1096 if ((STp->buffer)->b_data[3] >= 8) {
1097 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1098 STp->density = (STp->buffer)->b_data[4];
1099 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1100 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1101 DEBC(printk(ST_DEB_MSG
1102 "%s: Density %x, tape length: %x, drv buffer: %d\n",
1103 name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1104 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1107 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1109 st_release_request(SRpnt);
1113 if (STp->block_size > 0)
1114 (STp->buffer)->buffer_blocks =
1115 (STp->buffer)->buffer_size / STp->block_size;
1117 (STp->buffer)->buffer_blocks = 1;
1118 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1120 DEBC(printk(ST_DEB_MSG
1121 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1122 STp->block_size, (STp->buffer)->buffer_size,
1123 (STp->buffer)->buffer_blocks));
1125 if (STp->drv_write_prot) {
1126 STp->write_prot = 1;
1128 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1131 ((st_flags & O_ACCMODE) == O_WRONLY ||
1132 (st_flags & O_ACCMODE) == O_RDWR)) {
1138 if (STp->can_partitions && STp->nbr_partitions < 1) {
1139 /* This code is reached when the device is opened for the first time
1140 after the driver has been initialized with tape in the drive and the
1141 partition support has been enabled. */
1142 DEBC(printk(ST_DEB_MSG
1143 "%s: Updating partition number in status.\n", name));
1144 if ((STp->partition = find_partition(STp)) < 0) {
1145 retval = STp->partition;
1148 STp->new_partition = STp->partition;
1149 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1152 if (new_session) { /* Change the drive parameters for the new mode */
1153 STp->density_changed = STp->blksize_changed = 0;
1154 STp->compression_changed = 0;
1155 if (!(STm->defaults_for_writes) &&
1156 (retval = set_mode_densblk(STp, STm)) < 0)
1159 if (STp->default_drvbuffer != 0xff) {
1160 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1162 "%s: Can't set default drive buffering to %d.\n",
1163 name, STp->default_drvbuffer);
1167 return CHKRES_READY;
1174 \f/* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1176 static int st_open(struct inode *inode, struct file *filp)
1178 int i, retval = (-EIO);
1180 struct scsi_tape *STp;
1181 struct st_partstat *STps;
1182 int dev = TAPE_NR(inode);
1185 mutex_lock(&st_mutex);
1187 * We really want to do nonseekable_open(inode, filp); here, but some
1188 * versions of tar incorrectly call lseek on tapes and bail out if that
1189 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1191 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1193 if (!(STp = scsi_tape_get(dev))) {
1194 mutex_unlock(&st_mutex);
1198 write_lock(&st_dev_arr_lock);
1199 filp->private_data = STp;
1200 name = tape_name(STp);
1203 write_unlock(&st_dev_arr_lock);
1205 mutex_unlock(&st_mutex);
1206 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1211 write_unlock(&st_dev_arr_lock);
1212 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1214 if (scsi_autopm_get_device(STp->device) < 0) {
1219 if (!scsi_block_when_processing_errors(STp->device)) {
1224 /* See that we have at least a one page buffer available */
1225 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1226 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1228 retval = (-EOVERFLOW);
1232 (STp->buffer)->cleared = 0;
1233 (STp->buffer)->writing = 0;
1234 (STp->buffer)->syscall_result = 0;
1236 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1239 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1240 STps = &(STp->ps[i]);
1243 STp->try_dio_now = STp->try_dio;
1244 STp->recover_count = 0;
1245 DEB( STp->nbr_waits = STp->nbr_finished = 0;
1246 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
1248 retval = check_tape(STp, filp);
1251 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1252 retval != CHKRES_READY) {
1253 if (STp->ready == NO_TAPE)
1254 retval = (-ENOMEDIUM);
1259 mutex_unlock(&st_mutex);
1263 normalize_buffer(STp->buffer);
1267 scsi_autopm_put_device(STp->device);
1268 mutex_unlock(&st_mutex);
1274 /* Flush the tape buffer before close */
1275 static int st_flush(struct file *filp, fl_owner_t id)
1277 int result = 0, result2;
1278 unsigned char cmd[MAX_COMMAND_SIZE];
1279 struct st_request *SRpnt;
1280 struct scsi_tape *STp = filp->private_data;
1281 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1282 struct st_partstat *STps = &(STp->ps[STp->partition]);
1283 char *name = tape_name(STp);
1285 if (file_count(filp) > 1)
1288 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1289 result = st_flush_write_buffer(STp);
1290 if (result != 0 && result != (-ENOSPC))
1294 if (STp->can_partitions &&
1295 (result2 = switch_partition(STp)) < 0) {
1296 DEBC(printk(ST_DEB_MSG
1297 "%s: switch_partition at close failed.\n", name));
1303 DEBC( if (STp->nbr_requests)
1304 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n",
1305 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages));
1307 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1308 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1310 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1311 name, STp->nbr_waits, STp->nbr_finished);
1314 memset(cmd, 0, MAX_COMMAND_SIZE);
1315 cmd[0] = WRITE_FILEMARKS;
1316 cmd[4] = 1 + STp->two_fm;
1318 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1319 STp->device->request_queue->rq_timeout,
1320 MAX_WRITE_RETRIES, 1);
1322 result = (STp->buffer)->syscall_result;
1326 if (STp->buffer->syscall_result == 0 ||
1327 (cmdstatp->have_sense && !cmdstatp->deferred &&
1328 (cmdstatp->flags & SENSE_EOM) &&
1329 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1330 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1331 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1332 /* Write successful at EOM */
1333 st_release_request(SRpnt);
1335 if (STps->drv_file >= 0)
1337 STps->drv_block = 0;
1342 else { /* Write error */
1343 st_release_request(SRpnt);
1345 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1350 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1352 } else if (!STp->rew_at_close) {
1353 STps = &(STp->ps[STp->partition]);
1354 if (!STm->sysv || STps->rw != ST_READING) {
1356 result = flush_buffer(STp, 0);
1357 else if (STps->eof == ST_FM_HIT) {
1358 result = cross_eof(STp, 0);
1360 if (STps->drv_file >= 0)
1362 STps->drv_block = 0;
1365 STps->eof = ST_NOEOF;
1367 } else if ((STps->eof == ST_NOEOF &&
1368 !(result = cross_eof(STp, 1))) ||
1369 STps->eof == ST_FM_HIT) {
1370 if (STps->drv_file >= 0)
1372 STps->drv_block = 0;
1378 if (STp->rew_at_close) {
1379 result2 = st_int_ioctl(STp, MTREW, 1);
1387 /* Close the device and release it. BKL is not needed: this is the only thread
1388 accessing this tape. */
1389 static int st_release(struct inode *inode, struct file *filp)
1392 struct scsi_tape *STp = filp->private_data;
1394 if (STp->door_locked == ST_LOCKED_AUTO)
1395 do_door_lock(STp, 0);
1397 normalize_buffer(STp->buffer);
1398 write_lock(&st_dev_arr_lock);
1400 write_unlock(&st_dev_arr_lock);
1401 scsi_autopm_put_device(STp->device);
1407 /* The checks common to both reading and writing */
1408 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1413 * If we are in the middle of error recovery, don't let anyone
1414 * else try and use this device. Also, if error recovery fails, it
1415 * may try and take the device offline, in which case all further
1416 * access to the device is prohibited.
1418 if (!scsi_block_when_processing_errors(STp->device)) {
1423 if (STp->ready != ST_READY) {
1424 if (STp->ready == ST_NO_TAPE)
1425 retval = (-ENOMEDIUM);
1431 if (! STp->modes[STp->current_mode].defined) {
1438 * If there was a bus reset, block further access
1441 if (STp->pos_unknown) {
1451 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1456 if (STp->can_partitions &&
1457 (retval = switch_partition(STp)) < 0)
1460 if (STp->block_size == 0 && STp->max_block > 0 &&
1461 (count < STp->min_block || count > STp->max_block)) {
1466 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1467 !do_door_lock(STp, 1))
1468 STp->door_locked = ST_LOCKED_AUTO;
1475 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1476 size_t count, int is_read)
1478 int i, bufsize, retval = 0;
1479 struct st_buffer *STbp = STp->buffer;
1482 i = STp->try_dio_now && try_rdio;
1484 i = STp->try_dio_now && try_wdio;
1486 if (i && ((unsigned long)buf & queue_dma_alignment(
1487 STp->device->request_queue)) == 0) {
1488 i = sgl_map_user_pages(STbp, STbp->use_sg, (unsigned long)buf,
1489 count, (is_read ? READ : WRITE));
1492 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1495 STbp->do_dio = 0; /* fall back to buffering with any error */
1496 STbp->sg_segs = STbp->do_dio;
1500 STp->nbr_pages += STbp->do_dio;
1505 DEB( STp->nbr_requests++; )
1507 if (!STbp->do_dio) {
1508 if (STp->block_size)
1509 bufsize = STp->block_size > st_fixed_buffer_size ?
1510 STp->block_size : st_fixed_buffer_size;
1513 /* Make sure that data from previous user is not leaked even if
1514 HBA does not return correct residual */
1515 if (is_read && STp->sili && !STbp->cleared)
1519 if (bufsize > STbp->buffer_size &&
1520 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1521 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1522 tape_name(STp), bufsize);
1523 retval = (-EOVERFLOW);
1526 if (STp->block_size)
1527 STbp->buffer_blocks = bufsize / STp->block_size;
1535 /* Can be called more than once after each setup_buffer() */
1536 static void release_buffering(struct scsi_tape *STp, int is_read)
1538 struct st_buffer *STbp;
1542 sgl_unmap_user_pages(STbp, STbp->do_dio, is_read);
1551 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1554 ssize_t i, do_count, blks, transfer;
1556 int undone, retry_eot = 0, scode;
1558 unsigned char cmd[MAX_COMMAND_SIZE];
1559 const char __user *b_point;
1560 struct st_request *SRpnt = NULL;
1561 struct scsi_tape *STp = filp->private_data;
1562 struct st_modedef *STm;
1563 struct st_partstat *STps;
1564 struct st_buffer *STbp;
1565 char *name = tape_name(STp);
1567 if (mutex_lock_interruptible(&STp->lock))
1568 return -ERESTARTSYS;
1570 retval = rw_checks(STp, filp, count);
1571 if (retval || count == 0)
1574 /* Write must be integral number of blocks */
1575 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1576 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1582 STm = &(STp->modes[STp->current_mode]);
1583 STps = &(STp->ps[STp->partition]);
1585 if (STp->write_prot) {
1591 if (STps->rw == ST_READING) {
1592 retval = flush_buffer(STp, 0);
1595 STps->rw = ST_WRITING;
1596 } else if (STps->rw != ST_WRITING &&
1597 STps->drv_file == 0 && STps->drv_block == 0) {
1598 if ((retval = set_mode_densblk(STp, STm)) < 0)
1600 if (STm->default_compression != ST_DONT_TOUCH &&
1601 !(STp->compression_changed)) {
1602 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1603 printk(KERN_WARNING "%s: Can't set default compression.\n",
1605 if (modes_defined) {
1614 i = write_behind_check(STp);
1617 STps->eof = ST_EOM_OK;
1619 STps->eof = ST_EOM_ERROR;
1622 if (STps->eof == ST_EOM_OK) {
1623 STps->eof = ST_EOD_1; /* allow next write */
1627 else if (STps->eof == ST_EOM_ERROR) {
1632 /* Check the buffer readability in cases where copy_user might catch
1633 the problems after some tape movement. */
1634 if (STp->block_size != 0 &&
1636 (copy_from_user(&i, buf, 1) != 0 ||
1637 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1642 retval = setup_buffering(STp, buf, count, 0);
1648 memset(cmd, 0, MAX_COMMAND_SIZE);
1650 cmd[1] = (STp->block_size != 0);
1652 STps->rw = ST_WRITING;
1655 while (count > 0 && !retry_eot) {
1661 if (STp->block_size == 0)
1664 do_count = STbp->buffer_blocks * STp->block_size -
1666 if (do_count > count)
1670 i = append_to_buffer(b_point, STbp, do_count);
1677 b_point += do_count;
1679 async_write = STp->block_size == 0 && !STbp->do_dio &&
1680 STm->do_async_writes && STps->eof < ST_EOM_OK;
1682 if (STp->block_size != 0 && STm->do_buffer_writes &&
1683 !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1684 STbp->buffer_bytes < STbp->buffer_size) {
1686 /* Don't write a buffer that is not full enough. */
1687 if (!async_write && count == 0)
1692 if (STp->block_size == 0)
1693 blks = transfer = do_count;
1696 blks = STbp->buffer_bytes;
1699 blks /= STp->block_size;
1700 transfer = blks * STp->block_size;
1702 cmd[2] = blks >> 16;
1706 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1707 STp->device->request_queue->rq_timeout,
1708 MAX_WRITE_RETRIES, !async_write);
1710 retval = STbp->syscall_result;
1713 if (async_write && !STbp->syscall_result) {
1714 STbp->writing = transfer;
1715 STp->dirty = !(STbp->writing ==
1716 STbp->buffer_bytes);
1717 SRpnt = NULL; /* Prevent releasing this request! */
1718 DEB( STp->write_pending = 1; )
1722 if (STbp->syscall_result != 0) {
1723 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1725 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1726 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1727 scode = cmdstatp->sense_hdr.sense_key;
1728 if (cmdstatp->remainder_valid)
1729 undone = (int)cmdstatp->uremainder64;
1730 else if (STp->block_size == 0 &&
1731 scode == VOLUME_OVERFLOW)
1735 if (STp->block_size != 0)
1736 undone *= STp->block_size;
1737 if (undone <= do_count) {
1738 /* Only data from this write is not written */
1742 if (STp->block_size)
1743 blks = (transfer - undone) / STp->block_size;
1744 STps->eof = ST_EOM_OK;
1745 /* Continue in fixed block mode if all written
1746 in this request but still something left to write
1747 (retval left to zero)
1749 if (STp->block_size == 0 ||
1750 undone > 0 || count == 0)
1751 retval = (-ENOSPC); /* EOM within current request */
1752 DEBC(printk(ST_DEB_MSG
1753 "%s: EOM with %d bytes unwritten.\n",
1756 /* EOT within data buffered earlier (possible only
1757 in fixed block mode without direct i/o) */
1758 if (!retry_eot && !cmdstatp->deferred &&
1759 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1760 move_buffer_data(STp->buffer, transfer - undone);
1762 if (STps->drv_block >= 0) {
1763 STps->drv_block += (transfer - undone) /
1766 STps->eof = ST_EOM_OK;
1767 DEBC(printk(ST_DEB_MSG
1768 "%s: Retry write of %d bytes at EOM.\n",
1769 name, STp->buffer->buffer_bytes));
1773 /* Either error within data buffered by driver or
1776 blks = do_count = 0;
1777 STps->eof = ST_EOM_ERROR;
1778 STps->drv_block = (-1); /* Too cautious? */
1779 retval = (-EIO); /* EOM for old data */
1780 DEBC(printk(ST_DEB_MSG
1781 "%s: EOM with lost data.\n",
1787 STps->drv_block = (-1); /* Too cautious? */
1788 retval = STbp->syscall_result;
1793 if (STps->drv_block >= 0) {
1794 if (STp->block_size == 0)
1795 STps->drv_block += (do_count > 0);
1797 STps->drv_block += blks;
1800 STbp->buffer_bytes = 0;
1803 if (retval || retry_eot) {
1805 retval = total - count;
1810 if (STps->eof == ST_EOD_1)
1811 STps->eof = ST_EOM_OK;
1812 else if (STps->eof != ST_EOM_OK)
1813 STps->eof = ST_NOEOF;
1814 retval = total - count;
1818 st_release_request(SRpnt);
1819 release_buffering(STp, 0);
1820 mutex_unlock(&STp->lock);
1825 /* Read data from the tape. Returns zero in the normal case, one if the
1826 eof status has changed, and the negative error code in case of a
1827 fatal error. Otherwise updates the buffer and the eof state.
1829 Does release user buffer mapping if it is set.
1831 static long read_tape(struct scsi_tape *STp, long count,
1832 struct st_request ** aSRpnt)
1834 int transfer, blks, bytes;
1835 unsigned char cmd[MAX_COMMAND_SIZE];
1836 struct st_request *SRpnt;
1837 struct st_modedef *STm;
1838 struct st_partstat *STps;
1839 struct st_buffer *STbp;
1841 char *name = tape_name(STp);
1846 STm = &(STp->modes[STp->current_mode]);
1847 STps = &(STp->ps[STp->partition]);
1848 if (STps->eof == ST_FM_HIT)
1852 if (STp->block_size == 0)
1853 blks = bytes = count;
1855 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1856 blks = (STp->buffer)->buffer_blocks;
1857 bytes = blks * STp->block_size;
1860 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1861 bytes = (STp->buffer)->buffer_size;
1862 blks = bytes / STp->block_size;
1863 bytes = blks * STp->block_size;
1867 memset(cmd, 0, MAX_COMMAND_SIZE);
1869 cmd[1] = (STp->block_size != 0);
1870 if (!cmd[1] && STp->sili)
1872 cmd[2] = blks >> 16;
1877 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1878 STp->device->request_queue->rq_timeout,
1880 release_buffering(STp, 1);
1883 return STbp->syscall_result;
1885 STbp->read_pointer = 0;
1888 /* Something to check */
1889 if (STbp->syscall_result) {
1890 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1893 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1895 SRpnt->sense[0], SRpnt->sense[1],
1896 SRpnt->sense[2], SRpnt->sense[3],
1897 SRpnt->sense[4], SRpnt->sense[5],
1898 SRpnt->sense[6], SRpnt->sense[7]));
1899 if (cmdstatp->have_sense) {
1901 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1902 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1904 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1905 /* Compute the residual count */
1906 if (cmdstatp->remainder_valid)
1907 transfer = (int)cmdstatp->uremainder64;
1910 if (STp->block_size == 0 &&
1911 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1914 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
1915 if (STp->block_size == 0) {
1916 if (transfer <= 0) {
1919 "%s: Failed to read %d byte block with %d byte transfer.\n",
1920 name, bytes - transfer, bytes);
1921 if (STps->drv_block >= 0)
1922 STps->drv_block += 1;
1923 STbp->buffer_bytes = 0;
1926 STbp->buffer_bytes = bytes - transfer;
1928 st_release_request(SRpnt);
1929 SRpnt = *aSRpnt = NULL;
1930 if (transfer == blks) { /* We did not get anything, error */
1931 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1932 if (STps->drv_block >= 0)
1933 STps->drv_block += blks - transfer + 1;
1934 st_int_ioctl(STp, MTBSR, 1);
1937 /* We have some data, deliver it */
1938 STbp->buffer_bytes = (blks - transfer) *
1940 DEBC(printk(ST_DEB_MSG
1941 "%s: ILI but enough data received %ld %d.\n",
1942 name, count, STbp->buffer_bytes));
1943 if (STps->drv_block >= 0)
1944 STps->drv_block += 1;
1945 if (st_int_ioctl(STp, MTBSR, 1))
1948 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
1949 if (STps->eof != ST_FM_HIT)
1950 STps->eof = ST_FM_HIT;
1952 STps->eof = ST_EOD_2;
1953 if (STp->block_size == 0)
1954 STbp->buffer_bytes = 0;
1956 STbp->buffer_bytes =
1957 bytes - transfer * STp->block_size;
1958 DEBC(printk(ST_DEB_MSG
1959 "%s: EOF detected (%d bytes read).\n",
1960 name, STbp->buffer_bytes));
1961 } else if (cmdstatp->flags & SENSE_EOM) {
1962 if (STps->eof == ST_FM)
1963 STps->eof = ST_EOD_1;
1965 STps->eof = ST_EOM_OK;
1966 if (STp->block_size == 0)
1967 STbp->buffer_bytes = bytes - transfer;
1969 STbp->buffer_bytes =
1970 bytes - transfer * STp->block_size;
1972 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1973 name, STbp->buffer_bytes));
1976 /* end of EOF, EOM, ILI test */
1977 else { /* nonzero sense key */
1978 DEBC(printk(ST_DEB_MSG
1979 "%s: Tape error while reading.\n", name));
1980 STps->drv_block = (-1);
1981 if (STps->eof == ST_FM &&
1982 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1983 DEBC(printk(ST_DEB_MSG
1984 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1986 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1987 } else /* Some other extended sense code */
1991 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
1992 STbp->buffer_bytes = 0;
1994 /* End of extended sense test */
1995 else { /* Non-extended sense */
1996 retval = STbp->syscall_result;
2000 /* End of error handling */
2001 else { /* Read successful */
2002 STbp->buffer_bytes = bytes;
2003 if (STp->sili) /* In fixed block mode residual is always zero here */
2004 STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
2007 if (STps->drv_block >= 0) {
2008 if (STp->block_size == 0)
2011 STps->drv_block += STbp->buffer_bytes / STp->block_size;
2019 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
2023 ssize_t i, transfer;
2024 int special, do_dio = 0;
2025 struct st_request *SRpnt = NULL;
2026 struct scsi_tape *STp = filp->private_data;
2027 struct st_modedef *STm;
2028 struct st_partstat *STps;
2029 struct st_buffer *STbp = STp->buffer;
2030 DEB( char *name = tape_name(STp); )
2032 if (mutex_lock_interruptible(&STp->lock))
2033 return -ERESTARTSYS;
2035 retval = rw_checks(STp, filp, count);
2036 if (retval || count == 0)
2039 STm = &(STp->modes[STp->current_mode]);
2040 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
2041 if (!STm->do_read_ahead) {
2042 retval = (-EINVAL); /* Read must be integral number of blocks */
2045 STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */
2048 STps = &(STp->ps[STp->partition]);
2049 if (STps->rw == ST_WRITING) {
2050 retval = flush_buffer(STp, 0);
2053 STps->rw = ST_READING;
2056 if (debugging && STps->eof != ST_NOEOF)
2057 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
2058 STps->eof, STbp->buffer_bytes);
2061 retval = setup_buffering(STp, buf, count, 1);
2064 do_dio = STbp->do_dio;
2066 if (STbp->buffer_bytes == 0 &&
2067 STps->eof >= ST_EOD_1) {
2068 if (STps->eof < ST_EOD) {
2073 retval = (-EIO); /* EOM or Blank Check */
2078 /* Check the buffer writability before any tape movement. Don't alter
2080 if (copy_from_user(&i, buf, 1) != 0 ||
2081 copy_to_user(buf, &i, 1) != 0 ||
2082 copy_from_user(&i, buf + count - 1, 1) != 0 ||
2083 copy_to_user(buf + count - 1, &i, 1) != 0) {
2089 STps->rw = ST_READING;
2092 /* Loop until enough data in buffer or a special condition found */
2093 for (total = 0, special = 0; total < count && !special;) {
2095 /* Get new data if the buffer is empty */
2096 if (STbp->buffer_bytes == 0) {
2097 special = read_tape(STp, count - total, &SRpnt);
2098 if (special < 0) { /* No need to continue read */
2104 /* Move the data from driver buffer to user buffer */
2105 if (STbp->buffer_bytes > 0) {
2107 if (debugging && STps->eof != ST_NOEOF)
2109 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2110 STps->eof, STbp->buffer_bytes,
2111 (int)(count - total));
2113 transfer = STbp->buffer_bytes < count - total ?
2114 STbp->buffer_bytes : count - total;
2116 i = from_buffer(STbp, buf, transfer);
2126 if (STp->block_size == 0)
2127 break; /* Read only one variable length block */
2129 } /* for (total = 0, special = 0;
2130 total < count && !special; ) */
2132 /* Change the eof state if no data from tape or buffer */
2134 if (STps->eof == ST_FM_HIT) {
2136 STps->drv_block = 0;
2137 if (STps->drv_file >= 0)
2139 } else if (STps->eof == ST_EOD_1) {
2140 STps->eof = ST_EOD_2;
2141 STps->drv_block = 0;
2142 if (STps->drv_file >= 0)
2144 } else if (STps->eof == ST_EOD_2)
2146 } else if (STps->eof == ST_FM)
2147 STps->eof = ST_NOEOF;
2151 if (SRpnt != NULL) {
2152 st_release_request(SRpnt);
2156 release_buffering(STp, 1);
2157 STbp->buffer_bytes = 0;
2159 mutex_unlock(&STp->lock);
2167 /* Set the driver options */
2168 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2172 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2173 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2174 STm->do_read_ahead);
2176 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2177 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2179 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2180 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2181 STp->scsi2_logical);
2183 "%s: sysv: %d nowait: %d sili: %d\n", name, STm->sysv, STp->immediate,
2185 printk(KERN_INFO "%s: debugging: %d\n",
2192 static int st_set_options(struct scsi_tape *STp, long options)
2196 struct st_modedef *STm;
2197 char *name = tape_name(STp);
2198 struct cdev *cd0, *cd1;
2200 STm = &(STp->modes[STp->current_mode]);
2201 if (!STm->defined) {
2202 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2203 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2204 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2206 DEBC(printk(ST_DEB_MSG
2207 "%s: Initialized mode %d definition from mode 0\n",
2208 name, STp->current_mode));
2211 code = options & MT_ST_OPTIONS;
2212 if (code == MT_ST_BOOLEANS) {
2213 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2214 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2215 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2216 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2217 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2218 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2219 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2220 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2221 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2222 if ((STp->device)->scsi_level >= SCSI_2)
2223 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2224 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2225 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2226 STm->sysv = (options & MT_ST_SYSV) != 0;
2227 STp->sili = (options & MT_ST_SILI) != 0;
2228 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2229 st_log_options(STp, STm, name); )
2230 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2231 value = (code == MT_ST_SETBOOLEANS);
2232 if ((options & MT_ST_BUFFER_WRITES) != 0)
2233 STm->do_buffer_writes = value;
2234 if ((options & MT_ST_ASYNC_WRITES) != 0)
2235 STm->do_async_writes = value;
2236 if ((options & MT_ST_DEF_WRITES) != 0)
2237 STm->defaults_for_writes = value;
2238 if ((options & MT_ST_READ_AHEAD) != 0)
2239 STm->do_read_ahead = value;
2240 if ((options & MT_ST_TWO_FM) != 0)
2241 STp->two_fm = value;
2242 if ((options & MT_ST_FAST_MTEOM) != 0)
2243 STp->fast_mteom = value;
2244 if ((options & MT_ST_AUTO_LOCK) != 0)
2245 STp->do_auto_lock = value;
2246 if ((options & MT_ST_CAN_BSR) != 0)
2247 STp->can_bsr = value;
2248 if ((options & MT_ST_NO_BLKLIMS) != 0)
2249 STp->omit_blklims = value;
2250 if ((STp->device)->scsi_level >= SCSI_2 &&
2251 (options & MT_ST_CAN_PARTITIONS) != 0)
2252 STp->can_partitions = value;
2253 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2254 STp->scsi2_logical = value;
2255 if ((options & MT_ST_NOWAIT) != 0)
2256 STp->immediate = value;
2257 if ((options & MT_ST_SYSV) != 0)
2259 if ((options & MT_ST_SILI) != 0)
2262 if ((options & MT_ST_DEBUGGING) != 0)
2264 st_log_options(STp, STm, name); )
2265 } else if (code == MT_ST_WRITE_THRESHOLD) {
2266 /* Retained for compatibility */
2267 } else if (code == MT_ST_DEF_BLKSIZE) {
2268 value = (options & ~MT_ST_OPTIONS);
2269 if (value == ~MT_ST_OPTIONS) {
2270 STm->default_blksize = (-1);
2271 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2273 STm->default_blksize = value;
2274 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2275 name, STm->default_blksize));
2276 if (STp->ready == ST_READY) {
2277 STp->blksize_changed = 0;
2278 set_mode_densblk(STp, STm);
2281 } else if (code == MT_ST_TIMEOUTS) {
2282 value = (options & ~MT_ST_OPTIONS);
2283 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2284 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2285 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2286 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2288 blk_queue_rq_timeout(STp->device->request_queue,
2290 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2293 } else if (code == MT_ST_SET_CLN) {
2294 value = (options & ~MT_ST_OPTIONS) & 0xff;
2296 (value < EXTENDED_SENSE_START ||
2297 value >= SCSI_SENSE_BUFFERSIZE))
2299 STp->cln_mode = value;
2300 STp->cln_sense_mask = (options >> 8) & 0xff;
2301 STp->cln_sense_value = (options >> 16) & 0xff;
2303 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2304 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2305 } else if (code == MT_ST_DEF_OPTIONS) {
2306 code = (options & ~MT_ST_CLEAR_DEFAULT);
2307 value = (options & MT_ST_CLEAR_DEFAULT);
2308 if (code == MT_ST_DEF_DENSITY) {
2309 if (value == MT_ST_CLEAR_DEFAULT) {
2310 STm->default_density = (-1);
2311 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2314 STm->default_density = value & 0xff;
2315 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2316 name, STm->default_density));
2317 if (STp->ready == ST_READY) {
2318 STp->density_changed = 0;
2319 set_mode_densblk(STp, STm);
2322 } else if (code == MT_ST_DEF_DRVBUFFER) {
2323 if (value == MT_ST_CLEAR_DEFAULT) {
2324 STp->default_drvbuffer = 0xff;
2325 DEBC( printk(KERN_INFO
2326 "%s: Drive buffer default disabled.\n", name));
2328 STp->default_drvbuffer = value & 7;
2329 DEBC( printk(KERN_INFO
2330 "%s: Drive buffer default set to %x\n",
2331 name, STp->default_drvbuffer));
2332 if (STp->ready == ST_READY)
2333 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2335 } else if (code == MT_ST_DEF_COMPRESSION) {
2336 if (value == MT_ST_CLEAR_DEFAULT) {
2337 STm->default_compression = ST_DONT_TOUCH;
2338 DEBC( printk(KERN_INFO
2339 "%s: Compression default disabled.\n", name));
2341 if ((value & 0xff00) != 0) {
2342 STp->c_algo = (value & 0xff00) >> 8;
2343 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2344 name, STp->c_algo));
2346 if ((value & 0xff) != 0xff) {
2347 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2348 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2349 name, (value & 1)));
2350 if (STp->ready == ST_READY) {
2351 STp->compression_changed = 0;
2352 st_compression(STp, (STm->default_compression == ST_YES));
2363 #define MODE_HEADER_LENGTH 4
2365 /* Mode header and page byte offsets */
2366 #define MH_OFF_DATA_LENGTH 0
2367 #define MH_OFF_MEDIUM_TYPE 1
2368 #define MH_OFF_DEV_SPECIFIC 2
2369 #define MH_OFF_BDESCS_LENGTH 3
2370 #define MP_OFF_PAGE_NBR 0
2371 #define MP_OFF_PAGE_LENGTH 1
2373 /* Mode header and page bit masks */
2374 #define MH_BIT_WP 0x80
2375 #define MP_MSK_PAGE_NBR 0x3f
2377 /* Don't return block descriptors */
2378 #define MODE_SENSE_OMIT_BDESCS 0x08
2380 #define MODE_SELECT_PAGE_FORMAT 0x10
2382 /* Read a mode page into the tape buffer. The block descriptors are included
2383 if incl_block_descs is true. The page control is ored to the page number
2384 parameter, if necessary. */
2385 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2387 unsigned char cmd[MAX_COMMAND_SIZE];
2388 struct st_request *SRpnt;
2390 memset(cmd, 0, MAX_COMMAND_SIZE);
2391 cmd[0] = MODE_SENSE;
2392 if (omit_block_descs)
2393 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2397 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2398 STp->device->request_queue->rq_timeout, 0, 1);
2400 return (STp->buffer)->syscall_result;
2402 st_release_request(SRpnt);
2404 return STp->buffer->syscall_result;
2408 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2409 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2410 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2413 unsigned char cmd[MAX_COMMAND_SIZE];
2414 struct st_request *SRpnt;
2417 memset(cmd, 0, MAX_COMMAND_SIZE);
2418 cmd[0] = MODE_SELECT;
2419 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2420 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2421 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2423 /* Clear reserved fields */
2424 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2425 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2426 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2427 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2430 STp->long_timeout : STp->device->request_queue->rq_timeout;
2431 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_TO_DEVICE,
2434 return (STp->buffer)->syscall_result;
2436 st_release_request(SRpnt);
2438 return STp->buffer->syscall_result;
2442 #define COMPRESSION_PAGE 0x0f
2443 #define COMPRESSION_PAGE_LENGTH 16
2445 #define CP_OFF_DCE_DCC 2
2446 #define CP_OFF_C_ALGO 7
2448 #define DCE_MASK 0x80
2449 #define DCC_MASK 0x40
2450 #define RED_MASK 0x60
2453 /* Control the compression with mode page 15. Algorithm not changed if zero.
2455 The block descriptors are read and written because Sony SDT-7000 does not
2456 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2457 Including block descriptors should not cause any harm to other drives. */
2459 static int st_compression(struct scsi_tape * STp, int state)
2462 int mpoffs; /* Offset to mode page start */
2463 unsigned char *b_data = (STp->buffer)->b_data;
2464 DEB( char *name = tape_name(STp); )
2466 if (STp->ready != ST_READY)
2469 /* Read the current page contents */
2470 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2472 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2477 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2478 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2479 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2481 /* Check if compression can be changed */
2482 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2483 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2489 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2490 if (STp->c_algo != 0)
2491 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2494 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2495 if (STp->c_algo != 0)
2496 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2499 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2501 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2504 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2507 STp->compression_changed = 1;
2512 /* Process the load and unload commands (does unload if the load code is zero) */
2513 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2515 int retval = (-EIO), timeout;
2516 DEB( char *name = tape_name(STp); )
2517 unsigned char cmd[MAX_COMMAND_SIZE];
2518 struct st_partstat *STps;
2519 struct st_request *SRpnt;
2521 if (STp->ready != ST_READY && !load_code) {
2522 if (STp->ready == ST_NO_TAPE)
2523 return (-ENOMEDIUM);
2528 memset(cmd, 0, MAX_COMMAND_SIZE);
2529 cmd[0] = START_STOP;
2533 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2535 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2536 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2537 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2538 name, (cmd[4]) ? "" : "un",
2539 load_code - MT_ST_HPLOADER_OFFSET));
2540 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2542 if (STp->immediate) {
2543 cmd[1] = 1; /* Don't wait for completion */
2544 timeout = STp->device->request_queue->rq_timeout;
2547 timeout = STp->long_timeout;
2551 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2553 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2556 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2557 timeout, MAX_RETRIES, 1);
2559 return (STp->buffer)->syscall_result;
2561 retval = (STp->buffer)->syscall_result;
2562 st_release_request(SRpnt);
2564 if (!retval) { /* SCSI command successful */
2567 STp->rew_at_close = 0;
2568 STp->ready = ST_NO_TAPE;
2571 STp->rew_at_close = STp->autorew_dev;
2572 retval = check_tape(STp, filp);
2578 STps = &(STp->ps[STp->partition]);
2579 STps->drv_file = STps->drv_block = (-1);
2586 #define ST_DEB_FORWARD 0
2587 #define ST_DEB_BACKWARD 1
2588 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2592 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2593 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2596 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2597 direction ? "backward" : "forward", sc, units);
2602 /* Internal ioctl function */
2603 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2609 unsigned char cmd[MAX_COMMAND_SIZE];
2610 struct st_request *SRpnt;
2611 struct st_partstat *STps;
2612 int fileno, blkno, at_sm, undone;
2613 int datalen = 0, direction = DMA_NONE;
2614 char *name = tape_name(STp);
2616 WARN_ON(STp->buffer->do_dio != 0);
2617 if (STp->ready != ST_READY) {
2618 if (STp->ready == ST_NO_TAPE)
2619 return (-ENOMEDIUM);
2623 timeout = STp->long_timeout;
2624 STps = &(STp->ps[STp->partition]);
2625 fileno = STps->drv_file;
2626 blkno = STps->drv_block;
2627 at_sm = STps->at_sm;
2629 memset(cmd, 0, MAX_COMMAND_SIZE);
2632 chg_eof = 0; /* Changed from the FSF after this */
2635 cmd[1] = 0x01; /* Space FileMarks */
2636 cmd[2] = (arg >> 16);
2637 cmd[3] = (arg >> 8);
2639 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2643 at_sm &= (arg == 0);
2646 chg_eof = 0; /* Changed from the FSF after this */
2649 cmd[1] = 0x01; /* Space FileMarks */
2651 cmd[2] = (ltmp >> 16);
2652 cmd[3] = (ltmp >> 8);
2654 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2657 blkno = (-1); /* We can't know the block number */
2658 at_sm &= (arg == 0);
2662 cmd[1] = 0x00; /* Space Blocks */
2663 cmd[2] = (arg >> 16);
2664 cmd[3] = (arg >> 8);
2666 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2669 at_sm &= (arg == 0);
2673 cmd[1] = 0x00; /* Space Blocks */
2675 cmd[2] = (ltmp >> 16);
2676 cmd[3] = (ltmp >> 8);
2678 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2681 at_sm &= (arg == 0);
2685 cmd[1] = 0x04; /* Space Setmarks */
2686 cmd[2] = (arg >> 16);
2687 cmd[3] = (arg >> 8);
2689 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2691 blkno = fileno = (-1);
2697 cmd[1] = 0x04; /* Space Setmarks */
2699 cmd[2] = (ltmp >> 16);
2700 cmd[3] = (ltmp >> 8);
2702 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2704 blkno = fileno = (-1);
2711 if (STp->write_prot)
2713 cmd[0] = WRITE_FILEMARKS;
2714 if (cmd_in == MTWSM)
2716 if (cmd_in == MTWEOFI)
2718 cmd[2] = (arg >> 16);
2719 cmd[3] = (arg >> 8);
2721 timeout = STp->device->request_queue->rq_timeout;
2723 if (cmd_in != MTWSM)
2724 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2725 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2727 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2728 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2733 at_sm = (cmd_in == MTWSM);
2736 cmd[0] = REZERO_UNIT;
2737 if (STp->immediate) {
2738 cmd[1] = 1; /* Don't wait for completion */
2739 timeout = STp->device->request_queue->rq_timeout;
2741 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2742 fileno = blkno = at_sm = 0;
2745 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2746 return 0; /* Should do something ? */
2749 cmd[0] = START_STOP;
2750 if (STp->immediate) {
2751 cmd[1] = 1; /* Don't wait for completion */
2752 timeout = STp->device->request_queue->rq_timeout;
2755 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2756 fileno = blkno = at_sm = 0;
2759 if (!STp->fast_mteom) {
2760 /* space to the end of tape */
2761 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2762 fileno = STps->drv_file;
2763 if (STps->eof >= ST_EOD_1)
2765 /* The next lines would hide the number of spaced FileMarks
2766 That's why I inserted the previous lines. I had no luck
2767 with detecting EOM with FSF, so we go now to EOM.
2773 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2779 if (STp->write_prot)
2782 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2783 if (STp->immediate) {
2784 cmd[1] |= 2; /* Don't wait for completion */
2785 timeout = STp->device->request_queue->rq_timeout;
2788 timeout = STp->long_timeout * 8;
2790 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2791 fileno = blkno = at_sm = 0;
2793 case MTSETBLK: /* Set block length */
2794 case MTSETDENSITY: /* Set tape density */
2795 case MTSETDRVBUFFER: /* Set drive buffering */
2796 case SET_DENS_AND_BLK: /* Set density and block size */
2798 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2799 return (-EIO); /* Not allowed if data in buffer */
2800 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2801 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2802 STp->max_block > 0 &&
2803 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2804 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2805 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2808 cmd[0] = MODE_SELECT;
2809 if ((STp->use_pf & USE_PF))
2810 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2811 cmd[4] = datalen = 12;
2812 direction = DMA_TO_DEVICE;
2814 memset((STp->buffer)->b_data, 0, 12);
2815 if (cmd_in == MTSETDRVBUFFER)
2816 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2818 (STp->buffer)->b_data[2] =
2819 STp->drv_buffer << 4;
2820 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2821 if (cmd_in == MTSETDENSITY) {
2822 (STp->buffer)->b_data[4] = arg;
2823 STp->density_changed = 1; /* At least we tried ;-) */
2824 } else if (cmd_in == SET_DENS_AND_BLK)
2825 (STp->buffer)->b_data[4] = arg >> 24;
2827 (STp->buffer)->b_data[4] = STp->density;
2828 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2829 ltmp = arg & MT_ST_BLKSIZE_MASK;
2830 if (cmd_in == MTSETBLK)
2831 STp->blksize_changed = 1; /* At least we tried ;-) */
2833 ltmp = STp->block_size;
2834 (STp->buffer)->b_data[9] = (ltmp >> 16);
2835 (STp->buffer)->b_data[10] = (ltmp >> 8);
2836 (STp->buffer)->b_data[11] = ltmp;
2837 timeout = STp->device->request_queue->rq_timeout;
2839 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2841 "%s: Setting block size to %d bytes.\n", name,
2842 (STp->buffer)->b_data[9] * 65536 +
2843 (STp->buffer)->b_data[10] * 256 +
2844 (STp->buffer)->b_data[11]);
2845 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2847 "%s: Setting density code to %x.\n", name,
2848 (STp->buffer)->b_data[4]);
2849 if (cmd_in == MTSETDRVBUFFER)
2851 "%s: Setting drive buffer code to %d.\n", name,
2852 ((STp->buffer)->b_data[2] >> 4) & 7);
2859 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2860 timeout, MAX_RETRIES, 1);
2862 return (STp->buffer)->syscall_result;
2864 ioctl_result = (STp->buffer)->syscall_result;
2866 if (!ioctl_result) { /* SCSI command successful */
2867 st_release_request(SRpnt);
2869 STps->drv_block = blkno;
2870 STps->drv_file = fileno;
2871 STps->at_sm = at_sm;
2873 if (cmd_in == MTBSFM)
2874 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2875 else if (cmd_in == MTFSFM)
2876 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2878 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2879 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2880 if (STp->block_size != 0) {
2881 (STp->buffer)->buffer_blocks =
2882 (STp->buffer)->buffer_size / STp->block_size;
2884 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2885 if (cmd_in == SET_DENS_AND_BLK)
2886 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2887 } else if (cmd_in == MTSETDRVBUFFER)
2888 STp->drv_buffer = (arg & 7);
2889 else if (cmd_in == MTSETDENSITY)
2892 if (cmd_in == MTEOM)
2894 else if (cmd_in == MTFSF)
2897 STps->eof = ST_NOEOF;
2899 if (cmd_in == MTWEOF || cmd_in == MTWEOFI)
2900 STps->rw = ST_IDLE; /* prevent automatic WEOF at close */
2901 } else { /* SCSI command was not completely successful. Don't return
2902 from this block without releasing the SCSI command block! */
2903 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2905 if (cmdstatp->flags & SENSE_EOM) {
2906 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2907 cmd_in != MTBSR && cmd_in != MTBSS)
2908 STps->eof = ST_EOM_OK;
2909 STps->drv_block = 0;
2912 if (cmdstatp->remainder_valid)
2913 undone = (int)cmdstatp->uremainder64;
2917 if ((cmd_in == MTWEOF || cmd_in == MTWEOFI) &&
2918 cmdstatp->have_sense &&
2919 (cmdstatp->flags & SENSE_EOM)) {
2920 if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2921 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2922 ioctl_result = 0; /* EOF(s) written successfully at EOM */
2923 STps->eof = ST_NOEOF;
2924 } else { /* Writing EOF(s) failed */
2928 STps->eof = ST_NOEOF;
2930 STps->drv_file = fileno;
2931 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2933 STps->drv_file = fileno - undone;
2935 STps->drv_file = fileno;
2936 STps->drv_block = -1;
2937 STps->eof = ST_NOEOF;
2938 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2939 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2941 if (STps->drv_file >= 0)
2942 STps->drv_file = fileno + undone;
2943 STps->drv_block = 0;
2944 STps->eof = ST_NOEOF;
2945 } else if (cmd_in == MTFSR) {
2946 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2947 if (STps->drv_file >= 0)
2949 STps->drv_block = 0;
2952 if (blkno >= undone)
2953 STps->drv_block = blkno - undone;
2955 STps->drv_block = (-1);
2956 STps->eof = ST_NOEOF;
2958 } else if (cmd_in == MTBSR) {
2959 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2961 STps->drv_block = (-1);
2963 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2965 if (STps->drv_block >= 0)
2966 STps->drv_block = blkno + undone;
2968 STps->eof = ST_NOEOF;
2969 } else if (cmd_in == MTEOM) {
2970 STps->drv_file = (-1);
2971 STps->drv_block = (-1);
2973 } else if (cmd_in == MTSETBLK ||
2974 cmd_in == MTSETDENSITY ||
2975 cmd_in == MTSETDRVBUFFER ||
2976 cmd_in == SET_DENS_AND_BLK) {
2977 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2978 !(STp->use_pf & PF_TESTED)) {
2979 /* Try the other possible state of Page Format if not
2981 STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED;
2982 st_release_request(SRpnt);
2984 return st_int_ioctl(STp, cmd_in, arg);
2987 STps->eof = ST_NOEOF;
2989 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2992 st_release_request(SRpnt);
2996 return ioctl_result;
3000 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
3003 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
3007 unsigned char scmd[MAX_COMMAND_SIZE];
3008 struct st_request *SRpnt;
3009 DEB( char *name = tape_name(STp); )
3011 if (STp->ready != ST_READY)
3014 memset(scmd, 0, MAX_COMMAND_SIZE);
3015 if ((STp->device)->scsi_level < SCSI_2) {
3016 scmd[0] = QFA_REQUEST_BLOCK;
3019 scmd[0] = READ_POSITION;
3020 if (!logical && !STp->scsi2_logical)
3023 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
3024 STp->device->request_queue->rq_timeout,
3025 MAX_READY_RETRIES, 1);
3027 return (STp->buffer)->syscall_result;
3029 if ((STp->buffer)->syscall_result != 0 ||
3030 (STp->device->scsi_level >= SCSI_2 &&
3031 ((STp->buffer)->b_data[0] & 4) != 0)) {
3032 *block = *partition = 0;
3033 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
3037 if ((STp->device)->scsi_level < SCSI_2) {
3038 *block = ((STp->buffer)->b_data[0] << 16)
3039 + ((STp->buffer)->b_data[1] << 8)
3040 + (STp->buffer)->b_data[2];
3043 *block = ((STp->buffer)->b_data[4] << 24)
3044 + ((STp->buffer)->b_data[5] << 16)
3045 + ((STp->buffer)->b_data[6] << 8)
3046 + (STp->buffer)->b_data[7];
3047 *partition = (STp->buffer)->b_data[1];
3048 if (((STp->buffer)->b_data[0] & 0x80) &&
3049 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
3050 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3052 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
3053 *block, *partition));
3055 st_release_request(SRpnt);
3062 /* Set the tape block and partition. Negative partition means that only the
3063 block should be set in vendor specific way. */
3064 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3067 struct st_partstat *STps;
3071 unsigned char scmd[MAX_COMMAND_SIZE];
3072 struct st_request *SRpnt;
3073 DEB( char *name = tape_name(STp); )
3075 if (STp->ready != ST_READY)
3077 timeout = STp->long_timeout;
3078 STps = &(STp->ps[STp->partition]);
3080 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3081 name, block, partition));
3082 DEB(if (partition < 0)
3085 /* Update the location at the partition we are leaving */
3086 if ((!STp->can_partitions && partition != 0) ||
3087 partition >= ST_NBR_PARTITIONS)
3089 if (partition != STp->partition) {
3090 if (get_location(STp, &blk, &p, 1))
3091 STps->last_block_valid = 0;
3093 STps->last_block_valid = 1;
3094 STps->last_block_visited = blk;
3095 DEBC(printk(ST_DEB_MSG
3096 "%s: Visited block %d for partition %d saved.\n",
3097 name, blk, STp->partition));
3101 memset(scmd, 0, MAX_COMMAND_SIZE);
3102 if ((STp->device)->scsi_level < SCSI_2) {
3103 scmd[0] = QFA_SEEK_BLOCK;
3104 scmd[2] = (block >> 16);
3105 scmd[3] = (block >> 8);
3110 scmd[3] = (block >> 24);
3111 scmd[4] = (block >> 16);
3112 scmd[5] = (block >> 8);
3114 if (!logical && !STp->scsi2_logical)
3116 if (STp->partition != partition) {
3118 scmd[8] = partition;
3119 DEBC(printk(ST_DEB_MSG
3120 "%s: Trying to change partition from %d to %d\n",
3121 name, STp->partition, partition));
3124 if (STp->immediate) {
3125 scmd[1] |= 1; /* Don't wait for completion */
3126 timeout = STp->device->request_queue->rq_timeout;
3129 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3130 timeout, MAX_READY_RETRIES, 1);
3132 return (STp->buffer)->syscall_result;
3134 STps->drv_block = STps->drv_file = (-1);
3135 STps->eof = ST_NOEOF;
3136 if ((STp->buffer)->syscall_result != 0) {
3138 if (STp->can_partitions &&
3139 (STp->device)->scsi_level >= SCSI_2 &&
3140 (p = find_partition(STp)) >= 0)
3143 if (STp->can_partitions) {
3144 STp->partition = partition;
3145 STps = &(STp->ps[partition]);
3146 if (!STps->last_block_valid ||
3147 STps->last_block_visited != block) {
3154 STps->drv_block = STps->drv_file = 0;
3158 st_release_request(SRpnt);
3165 /* Find the current partition number for the drive status. Called from open and
3166 returns either partition number of negative error code. */
3167 static int find_partition(struct scsi_tape *STp)
3172 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3174 if (partition >= ST_NBR_PARTITIONS)
3180 /* Change the partition if necessary */
3181 static int switch_partition(struct scsi_tape *STp)
3183 struct st_partstat *STps;
3185 if (STp->partition == STp->new_partition)
3187 STps = &(STp->ps[STp->new_partition]);
3188 if (!STps->last_block_valid)
3189 STps->last_block_visited = 0;
3190 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3193 /* Functions for reading and writing the medium partition mode page. */
3195 #define PART_PAGE 0x11
3196 #define PART_PAGE_FIXED_LENGTH 8
3198 #define PP_OFF_MAX_ADD_PARTS 2
3199 #define PP_OFF_NBR_ADD_PARTS 3
3200 #define PP_OFF_FLAGS 4
3201 #define PP_OFF_PART_UNITS 6
3202 #define PP_OFF_RESERVED 7
3204 #define PP_BIT_IDP 0x20
3205 #define PP_MSK_PSUM_MB 0x10
3207 /* Get the number of partitions on the tape. As a side effect reads the
3208 mode page into the tape buffer. */
3209 static int nbr_partitions(struct scsi_tape *STp)
3212 DEB( char *name = tape_name(STp); )
3214 if (STp->ready != ST_READY)
3217 result = read_mode_page(STp, PART_PAGE, 1);
3220 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3224 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3225 PP_OFF_NBR_ADD_PARTS] + 1;
3226 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3233 /* Partition the tape into two partitions if size > 0 or one partition if
3236 The block descriptors are read and written because Sony SDT-7000 does not
3237 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3239 My HP C1533A drive returns only one partition size field. This is used to
3240 set the size of partition 1. There is no size field for the default partition.
3241 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3242 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3243 The following algorithm is used to accommodate both drives: if the number of
3244 partition size fields is greater than the maximum number of additional partitions
3245 in the mode page, the second field is used. Otherwise the first field is used.
3247 For Seagate DDS drives the page length must be 8 when no partitions is defined
3248 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3249 is acceptable also to some other old drives and enforced if the first partition
3250 size field is used for the first additional partition size.
3252 static int partition_tape(struct scsi_tape *STp, int size)
3254 char *name = tape_name(STp);
3256 int pgo, psd_cnt, psdo;
3259 result = read_mode_page(STp, PART_PAGE, 0);
3261 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3264 /* The mode page is in the buffer. Let's modify it and write it. */
3265 bp = (STp->buffer)->b_data;
3266 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3267 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3268 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3270 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3271 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3272 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3273 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3276 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3278 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3279 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3280 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3283 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3284 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3285 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3286 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3289 bp[psdo] = (size >> 8) & 0xff;
3290 bp[psdo + 1] = size & 0xff;
3292 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3293 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3294 DEBC(printk(ST_DEB_MSG
3295 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3298 bp[pgo + PP_OFF_PART_UNITS] = 0;
3299 bp[pgo + PP_OFF_RESERVED] = 0;
3300 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3302 result = write_mode_page(STp, PART_PAGE, 1);
3304 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3313 /* The ioctl command */
3314 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3316 int i, cmd_nr, cmd_type, bt;
3319 struct scsi_tape *STp = file->private_data;
3320 struct st_modedef *STm;
3321 struct st_partstat *STps;
3322 char *name = tape_name(STp);
3323 void __user *p = (void __user *)arg;
3325 if (mutex_lock_interruptible(&STp->lock))
3326 return -ERESTARTSYS;
3329 if (debugging && !STp->in_use) {
3330 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3335 STm = &(STp->modes[STp->current_mode]);
3336 STps = &(STp->ps[STp->partition]);
3339 * If we are in the middle of error recovery, don't let anyone
3340 * else try and use this device. Also, if error recovery fails, it
3341 * may try and take the device offline, in which case all further
3342 * access to the device is prohibited.
3344 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
3345 file->f_flags & O_NDELAY);
3346 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3350 cmd_type = _IOC_TYPE(cmd_in);
3351 cmd_nr = _IOC_NR(cmd_in);
3353 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3356 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3361 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3367 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3369 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3373 if (!STm->defined &&
3374 (mtc.mt_op != MTSETDRVBUFFER &&
3375 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3380 if (!STp->pos_unknown) {
3382 if (STps->eof == ST_FM_HIT) {
3383 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3384 mtc.mt_op == MTEOM) {
3386 if (STps->drv_file >= 0)
3387 STps->drv_file += 1;
3388 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3390 if (STps->drv_file >= 0)
3391 STps->drv_file += 1;
3395 if (mtc.mt_op == MTSEEK) {
3396 /* Old position must be restored if partition will be
3398 i = !STp->can_partitions ||
3399 (STp->new_partition != STp->partition);
3401 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3402 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3403 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3404 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3405 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3406 mtc.mt_op == MTCOMPRESSION;
3408 i = flush_buffer(STp, i);
3413 if (STps->rw == ST_WRITING &&
3414 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3415 mtc.mt_op == MTSEEK ||
3416 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3417 i = st_int_ioctl(STp, MTWEOF, 1);
3422 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3429 * If there was a bus reset, block further access
3430 * to this device. If the user wants to rewind the tape,
3431 * then reset the flag and allow access again.
3433 if (mtc.mt_op != MTREW &&
3434 mtc.mt_op != MTOFFL &&
3435 mtc.mt_op != MTRETEN &&
3436 mtc.mt_op != MTERASE &&
3437 mtc.mt_op != MTSEEK &&
3438 mtc.mt_op != MTEOM) {
3443 /* remove this when the midlevel properly clears was_reset */
3444 STp->device->was_reset = 0;
3447 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3448 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3449 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3450 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3452 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3453 do_door_lock(STp, 0); /* Ignore result! */
3455 if (mtc.mt_op == MTSETDRVBUFFER &&
3456 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3457 retval = st_set_options(STp, mtc.mt_count);
3461 if (mtc.mt_op == MTSETPART) {
3462 if (!STp->can_partitions ||
3463 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3467 if (mtc.mt_count >= STp->nbr_partitions &&
3468 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3472 if (mtc.mt_count >= STp->nbr_partitions) {
3476 STp->new_partition = mtc.mt_count;
3481 if (mtc.mt_op == MTMKPART) {
3482 if (!STp->can_partitions) {
3486 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3487 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3491 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3492 STp->ps[i].rw = ST_IDLE;
3493 STp->ps[i].at_sm = 0;
3494 STp->ps[i].last_block_valid = 0;
3496 STp->partition = STp->new_partition = 0;
3497 STp->nbr_partitions = 1; /* Bad guess ?-) */
3498 STps->drv_block = STps->drv_file = 0;
3503 if (mtc.mt_op == MTSEEK) {
3504 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3505 if (!STp->can_partitions)
3506 STp->ps[0].rw = ST_IDLE;
3511 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3512 retval = do_load_unload(STp, file, 0);
3516 if (mtc.mt_op == MTLOAD) {
3517 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3521 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3522 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3526 if (STp->can_partitions && STp->ready == ST_READY &&
3527 (i = switch_partition(STp)) < 0) {
3532 if (mtc.mt_op == MTCOMPRESSION)
3533 retval = st_compression(STp, (mtc.mt_count & 1));
3535 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3538 if (!STm->defined) {
3543 if ((i = flush_buffer(STp, 0)) < 0) {
3547 if (STp->can_partitions &&
3548 (i = switch_partition(STp)) < 0) {
3553 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3554 struct mtget mt_status;
3556 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3561 mt_status.mt_type = STp->tape_type;
3562 mt_status.mt_dsreg =
3563 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3564 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3565 mt_status.mt_blkno = STps->drv_block;
3566 mt_status.mt_fileno = STps->drv_file;
3567 if (STp->block_size != 0) {
3568 if (STps->rw == ST_WRITING)
3569 mt_status.mt_blkno +=
3570 (STp->buffer)->buffer_bytes / STp->block_size;
3571 else if (STps->rw == ST_READING)
3572 mt_status.mt_blkno -=
3573 ((STp->buffer)->buffer_bytes +
3574 STp->block_size - 1) / STp->block_size;
3577 mt_status.mt_gstat = 0;
3578 if (STp->drv_write_prot)
3579 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3580 if (mt_status.mt_blkno == 0) {
3581 if (mt_status.mt_fileno == 0)
3582 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3584 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3586 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3587 mt_status.mt_resid = STp->partition;
3588 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3589 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3590 else if (STps->eof >= ST_EOM_OK)
3591 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3592 if (STp->density == 1)
3593 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3594 else if (STp->density == 2)
3595 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3596 else if (STp->density == 3)
3597 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3598 if (STp->ready == ST_READY)
3599 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3600 if (STp->ready == ST_NO_TAPE)
3601 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3603 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3604 if (STm->do_async_writes ||
3605 (STm->do_buffer_writes && STp->block_size != 0) ||
3606 STp->drv_buffer != 0)
3607 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3608 if (STp->cleaning_req)
3609 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3611 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3617 STp->recover_reg = 0; /* Clear after read */
3620 } /* End of MTIOCGET */
3621 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3622 struct mtpos mt_pos;
3623 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3627 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3631 mt_pos.mt_blkno = blk;
3632 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3637 mutex_unlock(&STp->lock);
3639 case SCSI_IOCTL_GET_IDLUN:
3640 case SCSI_IOCTL_GET_BUS_NUMBER:
3643 if ((cmd_in == SG_IO ||
3644 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3645 cmd_in == CDROM_SEND_PACKET) &&
3646 !capable(CAP_SYS_RAWIO))
3649 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3650 file->f_mode, cmd_in, p);
3655 retval = scsi_ioctl(STp->device, cmd_in, p);
3656 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3657 STp->rew_at_close = 0;
3658 STp->ready = ST_NO_TAPE;
3663 mutex_unlock(&STp->lock);
3667 #ifdef CONFIG_COMPAT
3668 static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3670 struct scsi_tape *STp = file->private_data;
3671 struct scsi_device *sdev = STp->device;
3672 int ret = -ENOIOCTLCMD;
3673 if (sdev->host->hostt->compat_ioctl) {
3675 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3684 /* Try to allocate a new tape buffer. Calling function must not hold
3686 static struct st_buffer *new_tape_buffer(int need_dma, int max_sg)
3688 struct st_buffer *tb;
3690 tb = kzalloc(sizeof(struct st_buffer), GFP_ATOMIC);
3692 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3696 tb->use_sg = max_sg;
3698 tb->buffer_size = 0;
3700 tb->reserved_pages = kzalloc(max_sg * sizeof(struct page *),
3702 if (!tb->reserved_pages) {
3711 /* Try to allocate enough space in the tape buffer */
3712 #define ST_MAX_ORDER 6
3714 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3716 int segs, nbr, max_segs, b_size, order, got;
3719 if (new_size <= STbuffer->buffer_size)
3722 if (STbuffer->buffer_size <= PAGE_SIZE)
3723 normalize_buffer(STbuffer); /* Avoid extra segment */
3725 max_segs = STbuffer->use_sg;
3726 nbr = max_segs - STbuffer->frp_segs;
3730 priority = GFP_KERNEL | __GFP_NOWARN;
3732 priority |= GFP_DMA;
3734 if (STbuffer->cleared)
3735 priority |= __GFP_ZERO;
3737 if (STbuffer->frp_segs) {
3738 order = STbuffer->reserved_page_order;
3739 b_size = PAGE_SIZE << order;
3741 for (b_size = PAGE_SIZE, order = 0;
3742 order < ST_MAX_ORDER &&
3743 max_segs * (PAGE_SIZE << order) < new_size;
3744 order++, b_size *= 2)
3746 STbuffer->reserved_page_order = order;
3748 if (max_segs * (PAGE_SIZE << order) < new_size) {
3749 if (order == ST_MAX_ORDER)
3751 normalize_buffer(STbuffer);
3752 return enlarge_buffer(STbuffer, new_size, need_dma);
3755 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3756 segs < max_segs && got < new_size;) {
3759 page = alloc_pages(priority, order);
3761 DEB(STbuffer->buffer_size = got);
3762 normalize_buffer(STbuffer);
3766 STbuffer->frp_segs += 1;
3768 STbuffer->buffer_size = got;
3769 STbuffer->reserved_pages[segs] = page;
3772 STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
3778 /* Make sure that no data from previous user is in the internal buffer */
3779 static void clear_buffer(struct st_buffer * st_bp)
3783 for (i=0; i < st_bp->frp_segs; i++)
3784 memset(page_address(st_bp->reserved_pages[i]), 0,
3785 PAGE_SIZE << st_bp->reserved_page_order);
3790 /* Release the extra buffer */
3791 static void normalize_buffer(struct st_buffer * STbuffer)
3793 int i, order = STbuffer->reserved_page_order;
3795 for (i = 0; i < STbuffer->frp_segs; i++) {
3796 __free_pages(STbuffer->reserved_pages[i], order);
3797 STbuffer->buffer_size -= (PAGE_SIZE << order);
3799 STbuffer->frp_segs = 0;
3800 STbuffer->sg_segs = 0;
3801 STbuffer->reserved_page_order = 0;
3802 STbuffer->map_data.offset = 0;
3806 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3807 negative error code. */
3808 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3810 int i, cnt, res, offset;
3811 int length = PAGE_SIZE << st_bp->reserved_page_order;
3813 for (i = 0, offset = st_bp->buffer_bytes;
3814 i < st_bp->frp_segs && offset >= length; i++)
3816 if (i == st_bp->frp_segs) { /* Should never happen */
3817 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3820 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3821 struct page *page = st_bp->reserved_pages[i];
3822 cnt = length - offset < do_count ? length - offset : do_count;
3823 res = copy_from_user(page_address(page) + offset, ubp, cnt);
3827 st_bp->buffer_bytes += cnt;
3831 if (do_count) /* Should never happen */
3838 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3839 negative error code. */
3840 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3842 int i, cnt, res, offset;
3843 int length = PAGE_SIZE << st_bp->reserved_page_order;
3845 for (i = 0, offset = st_bp->read_pointer;
3846 i < st_bp->frp_segs && offset >= length; i++)
3848 if (i == st_bp->frp_segs) { /* Should never happen */
3849 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3852 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3853 struct page *page = st_bp->reserved_pages[i];
3854 cnt = length - offset < do_count ? length - offset : do_count;
3855 res = copy_to_user(ubp, page_address(page) + offset, cnt);
3859 st_bp->buffer_bytes -= cnt;
3860 st_bp->read_pointer += cnt;
3864 if (do_count) /* Should never happen */
3871 /* Move data towards start of buffer */
3872 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3874 int src_seg, dst_seg, src_offset = 0, dst_offset;
3876 int length = PAGE_SIZE << st_bp->reserved_page_order;
3881 total=st_bp->buffer_bytes - offset;
3882 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3883 src_offset = offset;
3884 if (src_offset < length)
3889 st_bp->buffer_bytes = st_bp->read_pointer = total;
3890 for (dst_seg=dst_offset=0; total > 0; ) {
3891 struct page *dpage = st_bp->reserved_pages[dst_seg];
3892 struct page *spage = st_bp->reserved_pages[src_seg];
3894 count = min(length - dst_offset, length - src_offset);
3895 memmove(page_address(dpage) + dst_offset,
3896 page_address(spage) + src_offset, count);
3897 src_offset += count;
3898 if (src_offset >= length) {
3902 dst_offset += count;
3903 if (dst_offset >= length) {
3911 /* Validate the options from command line or module parameters */
3912 static void validate_options(void)
3915 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3916 if (max_sg_segs >= ST_FIRST_SG)
3917 st_max_sg_segs = max_sg_segs;
3921 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3923 static int __init st_setup(char *str)
3925 int i, len, ints[5];
3928 stp = get_options(str, ARRAY_SIZE(ints), ints);
3931 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3933 *parms[i].val = ints[i + 1];
3935 while (stp != NULL) {
3936 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3937 len = strlen(parms[i].name);
3938 if (!strncmp(stp, parms[i].name, len) &&
3939 (*(stp + len) == ':' || *(stp + len) == '=')) {
3942 simple_strtoul(stp + len + 1, NULL, 0);
3944 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3949 if (i >= ARRAY_SIZE(parms))
3950 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3952 stp = strchr(stp, ',');
3963 __setup("st=", st_setup);
3967 static const struct file_operations st_fops =
3969 .owner = THIS_MODULE,
3972 .unlocked_ioctl = st_ioctl,
3973 #ifdef CONFIG_COMPAT
3974 .compat_ioctl = st_compat_ioctl,
3978 .release = st_release,
3979 .llseek = noop_llseek,
3982 static int st_probe(struct device *dev)
3984 struct scsi_device *SDp = to_scsi_device(dev);
3985 struct gendisk *disk = NULL;
3986 struct cdev *cdev = NULL;
3987 struct scsi_tape *tpnt = NULL;
3988 struct st_modedef *STm;
3989 struct st_partstat *STps;
3990 struct st_buffer *buffer;
3991 int i, j, mode, dev_num, error;
3994 if (SDp->type != TYPE_TAPE)
3996 if ((stp = st_incompatible(SDp))) {
3997 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
3998 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
4002 i = queue_max_segments(SDp->request_queue);
4003 if (st_max_sg_segs < i)
4005 buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
4006 if (buffer == NULL) {
4008 "st: Can't allocate new tape buffer. Device not attached.\n");
4012 disk = alloc_disk(1);
4014 printk(KERN_ERR "st: out of memory. Device not attached.\n");
4015 goto out_buffer_free;
4018 write_lock(&st_dev_arr_lock);
4019 if (st_nr_dev >= st_dev_max) {
4020 struct scsi_tape **tmp_da;
4023 tmp_dev_max = max(st_nr_dev * 2, 8);
4024 if (tmp_dev_max > ST_MAX_TAPES)
4025 tmp_dev_max = ST_MAX_TAPES;
4026 if (tmp_dev_max <= st_nr_dev) {
4027 write_unlock(&st_dev_arr_lock);
4028 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
4033 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
4034 if (tmp_da == NULL) {
4035 write_unlock(&st_dev_arr_lock);
4036 printk(KERN_ERR "st: Can't extend device array.\n");
4040 if (scsi_tapes != NULL) {
4041 memcpy(tmp_da, scsi_tapes,
4042 st_dev_max * sizeof(struct scsi_tape *));
4045 scsi_tapes = tmp_da;
4047 st_dev_max = tmp_dev_max;
4050 for (i = 0; i < st_dev_max; i++)
4051 if (scsi_tapes[i] == NULL)
4053 if (i >= st_dev_max)
4054 panic("scsi_devices corrupt (st)");
4056 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
4058 write_unlock(&st_dev_arr_lock);
4059 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
4062 kref_init(&tpnt->kref);
4064 sprintf(disk->disk_name, "st%d", i);
4065 disk->private_data = &tpnt->driver;
4066 disk->queue = SDp->request_queue;
4067 tpnt->driver = &st_template;
4068 scsi_tapes[i] = tpnt;
4072 if (SDp->scsi_level <= 2)
4073 tpnt->tape_type = MT_ISSCSI1;
4075 tpnt->tape_type = MT_ISSCSI2;
4077 tpnt->buffer = buffer;
4078 tpnt->buffer->last_SRpnt = NULL;
4083 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
4084 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4085 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4087 tpnt->do_auto_lock = ST_AUTO_LOCK;
4088 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4089 tpnt->can_partitions = 0;
4090 tpnt->two_fm = ST_TWO_FM;
4091 tpnt->fast_mteom = ST_FAST_MTEOM;
4092 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4093 tpnt->sili = ST_SILI;
4094 tpnt->immediate = ST_NOWAIT;
4095 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
4096 tpnt->partition = 0;
4097 tpnt->new_partition = 0;
4098 tpnt->nbr_partitions = 0;
4099 blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
4100 tpnt->long_timeout = ST_LONG_TIMEOUT;
4101 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4103 for (i = 0; i < ST_NBR_MODES; i++) {
4104 STm = &(tpnt->modes[i]);
4106 STm->sysv = ST_SYSV;
4107 STm->defaults_for_writes = 0;
4108 STm->do_async_writes = ST_ASYNC_WRITES;
4109 STm->do_buffer_writes = ST_BUFFER_WRITES;
4110 STm->do_read_ahead = ST_READ_AHEAD;
4111 STm->default_compression = ST_DONT_TOUCH;
4112 STm->default_blksize = (-1); /* No forced size */
4113 STm->default_density = (-1); /* No forced density */
4116 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4117 STps = &(tpnt->ps[i]);
4119 STps->eof = ST_NOEOF;
4121 STps->last_block_valid = 0;
4122 STps->drv_block = (-1);
4123 STps->drv_file = (-1);
4126 tpnt->current_mode = 0;
4127 tpnt->modes[0].defined = 1;
4129 tpnt->density_changed = tpnt->compression_changed =
4130 tpnt->blksize_changed = 0;
4131 mutex_init(&tpnt->lock);
4134 write_unlock(&st_dev_arr_lock);
4136 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4137 STm = &(tpnt->modes[mode]);
4138 for (j=0; j < 2; j++) {
4139 cdev = cdev_alloc();
4142 "st%d: out of memory. Device not attached.\n",
4146 cdev->owner = THIS_MODULE;
4147 cdev->ops = &st_fops;
4149 error = cdev_add(cdev,
4150 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4153 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4154 dev_num, j ? "non" : "auto", mode);
4155 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4158 STm->cdevs[j] = cdev;
4161 error = do_create_class_files(tpnt, dev_num, mode);
4165 scsi_autopm_put_device(SDp);
4167 sdev_printk(KERN_NOTICE, SDp,
4168 "Attached scsi tape %s\n", tape_name(tpnt));
4169 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4170 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4171 queue_dma_alignment(SDp->request_queue) + 1);
4176 for (mode=0; mode < ST_NBR_MODES; mode++) {
4177 STm = &(tpnt->modes[mode]);
4178 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4180 for (j=0; j < 2; j++) {
4181 if (STm->cdevs[j]) {
4182 if (cdev == STm->cdevs[j])
4184 device_destroy(st_sysfs_class,
4185 MKDEV(SCSI_TAPE_MAJOR,
4186 TAPE_MINOR(i, mode, j)));
4187 cdev_del(STm->cdevs[j]);
4193 write_lock(&st_dev_arr_lock);
4194 scsi_tapes[dev_num] = NULL;
4196 write_unlock(&st_dev_arr_lock);
4207 static int st_remove(struct device *dev)
4209 struct scsi_device *SDp = to_scsi_device(dev);
4210 struct scsi_tape *tpnt;
4213 scsi_autopm_get_device(SDp);
4214 write_lock(&st_dev_arr_lock);
4215 for (i = 0; i < st_dev_max; i++) {
4216 tpnt = scsi_tapes[i];
4217 if (tpnt != NULL && tpnt->device == SDp) {
4218 scsi_tapes[i] = NULL;
4220 write_unlock(&st_dev_arr_lock);
4221 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4223 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4224 for (j=0; j < 2; j++) {
4225 device_destroy(st_sysfs_class,
4226 MKDEV(SCSI_TAPE_MAJOR,
4227 TAPE_MINOR(i, mode, j)));
4228 cdev_del(tpnt->modes[mode].cdevs[j]);
4229 tpnt->modes[mode].cdevs[j] = NULL;
4233 mutex_lock(&st_ref_mutex);
4234 kref_put(&tpnt->kref, scsi_tape_release);
4235 mutex_unlock(&st_ref_mutex);
4240 write_unlock(&st_dev_arr_lock);
4245 * scsi_tape_release - Called to free the Scsi_Tape structure
4246 * @kref: pointer to embedded kref
4248 * st_ref_mutex must be held entering this routine. Because it is
4249 * called on last put, you should always use the scsi_tape_get()
4250 * scsi_tape_put() helpers which manipulate the semaphore directly
4251 * and never do a direct kref_put().
4253 static void scsi_tape_release(struct kref *kref)
4255 struct scsi_tape *tpnt = to_scsi_tape(kref);
4256 struct gendisk *disk = tpnt->disk;
4258 tpnt->device = NULL;
4261 normalize_buffer(tpnt->buffer);
4262 kfree(tpnt->buffer->reserved_pages);
4263 kfree(tpnt->buffer);
4266 disk->private_data = NULL;
4272 static int __init init_st(void)
4278 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4279 verstr, st_fixed_buffer_size, st_max_sg_segs);
4281 st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
4282 if (IS_ERR(st_sysfs_class)) {
4283 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4284 return PTR_ERR(st_sysfs_class);
4287 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4288 ST_MAX_TAPE_ENTRIES, "st");
4290 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4295 err = scsi_register_driver(&st_template.gendrv);
4299 err = do_create_sysfs_files();
4306 scsi_unregister_driver(&st_template.gendrv);
4308 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4309 ST_MAX_TAPE_ENTRIES);
4311 class_destroy(st_sysfs_class);
4315 static void __exit exit_st(void)
4317 do_remove_sysfs_files();
4318 scsi_unregister_driver(&st_template.gendrv);
4319 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4320 ST_MAX_TAPE_ENTRIES);
4321 class_destroy(st_sysfs_class);
4323 printk(KERN_INFO "st: Unloaded.\n");
4326 module_init(init_st);
4327 module_exit(exit_st);
4330 /* The sysfs driver interface. Read-only at the moment */
4331 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4333 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4335 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4337 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4339 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4341 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4343 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4345 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4347 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4349 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4351 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4353 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4355 static int do_create_sysfs_files(void)
4357 struct device_driver *sysfs = &st_template.gendrv;
4360 err = driver_create_file(sysfs, &driver_attr_try_direct_io);
4363 err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
4365 goto err_try_direct_io;
4366 err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
4368 goto err_attr_fixed_buf;
4369 err = driver_create_file(sysfs, &driver_attr_version);
4371 goto err_attr_max_sg;
4376 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4378 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4380 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4384 static void do_remove_sysfs_files(void)
4386 struct device_driver *sysfs = &st_template.gendrv;
4388 driver_remove_file(sysfs, &driver_attr_version);
4389 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4390 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4391 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4395 /* The sysfs simple class interface */
4397 st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4399 struct st_modedef *STm = dev_get_drvdata(dev);
4402 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4406 DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4409 st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
4411 struct st_modedef *STm = dev_get_drvdata(dev);
4414 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4418 DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4421 st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
4423 struct st_modedef *STm = dev_get_drvdata(dev);
4427 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4428 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4432 DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4435 st_defcompression_show(struct device *dev, struct device_attribute *attr,
4438 struct st_modedef *STm = dev_get_drvdata(dev);
4441 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4445 DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4448 st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
4450 struct st_modedef *STm = dev_get_drvdata(dev);
4451 struct scsi_tape *STp;
4455 for (i=0; i < st_dev_max; i++) {
4456 for (j=0; j < ST_NBR_MODES; j++)
4457 if (&scsi_tapes[i]->modes[j] == STm)
4459 if (j < ST_NBR_MODES)
4462 if (i == st_dev_max)
4463 return 0; /* should never happen */
4465 STp = scsi_tapes[i];
4467 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4468 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4469 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4470 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4471 options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4472 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4473 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4474 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4475 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4476 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4477 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4478 options |= STm->sysv ? MT_ST_SYSV : 0;
4479 options |= STp->immediate ? MT_ST_NOWAIT : 0;
4480 options |= STp->sili ? MT_ST_SILI : 0;
4482 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4486 DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
4488 static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4492 struct device *st_class_member;
4494 for (rew=0; rew < 2; rew++) {
4495 /* Make sure that the minor numbers corresponding to the four
4496 first modes always get the same names */
4497 i = mode << (4 - ST_NBR_MODE_BITS);
4498 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4499 STp->disk->disk_name, st_formats[i]);
4501 device_create(st_sysfs_class, &STp->device->sdev_gendev,
4502 MKDEV(SCSI_TAPE_MAJOR,
4503 TAPE_MINOR(dev_num, mode, rew)),
4504 &STp->modes[mode], "%s", name);
4505 if (IS_ERR(st_class_member)) {
4506 printk(KERN_WARNING "st%d: device_create failed\n",
4508 error = PTR_ERR(st_class_member);
4512 error = device_create_file(st_class_member,
4514 if (error) goto out;
4515 error = device_create_file(st_class_member,
4516 &dev_attr_default_blksize);
4517 if (error) goto out;
4518 error = device_create_file(st_class_member,
4519 &dev_attr_default_density);
4520 if (error) goto out;
4521 error = device_create_file(st_class_member,
4522 &dev_attr_default_compression);
4523 if (error) goto out;
4524 error = device_create_file(st_class_member,
4526 if (error) goto out;
4528 if (mode == 0 && rew == 0) {
4529 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4530 &st_class_member->kobj,
4534 "st%d: Can't create sysfs link from SCSI device.\n",
4547 /* The following functions may be useful for a larger audience. */
4548 static int sgl_map_user_pages(struct st_buffer *STbp,
4549 const unsigned int max_pages, unsigned long uaddr,
4550 size_t count, int rw)
4552 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4553 unsigned long start = uaddr >> PAGE_SHIFT;
4554 const int nr_pages = end - start;
4556 struct page **pages;
4557 struct rq_map_data *mdata = &STbp->map_data;
4559 /* User attempted Overflow! */
4560 if ((uaddr + count) < uaddr)
4564 if (nr_pages > max_pages)
4571 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4574 /* Try to fault in all of the necessary pages */
4575 down_read(¤t->mm->mmap_sem);
4576 /* rw==READ means read from drive, write into memory area */
4577 res = get_user_pages(
4583 0, /* don't force */
4586 up_read(¤t->mm->mmap_sem);
4588 /* Errors and no page mapped should return here */
4592 for (i=0; i < nr_pages; i++) {
4593 /* FIXME: flush superflous for rw==READ,
4594 * probably wrong function for rw==WRITE
4596 flush_dcache_page(pages[i]);
4599 mdata->offset = uaddr & ~PAGE_MASK;
4600 STbp->mapped_pages = pages;
4605 for (j=0; j < res; j++)
4606 page_cache_release(pages[j]);
4614 /* And unmap them... */
4615 static int sgl_unmap_user_pages(struct st_buffer *STbp,
4616 const unsigned int nr_pages, int dirtied)
4620 for (i=0; i < nr_pages; i++) {
4621 struct page *page = STbp->mapped_pages[i];
4625 /* FIXME: cache flush missing for rw==READ
4626 * FIXME: call the correct reference counting function
4628 page_cache_release(page);
4630 kfree(STbp->mapped_pages);
4631 STbp->mapped_pages = NULL;