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 - 2004 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 char *verstr = "20041025";
22 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/sched.h>
28 #include <linux/init.h>
29 #include <linux/string.h>
30 #include <linux/errno.h>
31 #include <linux/mtio.h>
32 #include <linux/ioctl.h>
33 #include <linux/fcntl.h>
34 #include <linux/spinlock.h>
35 #include <linux/blkdev.h>
36 #include <linux/moduleparam.h>
37 #include <linux/devfs_fs_kernel.h>
38 #include <linux/cdev.h>
39 #include <asm/uaccess.h>
41 #include <asm/system.h>
43 #include <scsi/scsi.h>
44 #include <scsi/scsi_dbg.h>
45 #include <scsi/scsi_device.h>
46 #include <scsi/scsi_driver.h>
47 #include <scsi/scsi_eh.h>
48 #include <scsi/scsi_host.h>
49 #include <scsi/scsi_ioctl.h>
50 #include <scsi/scsi_request.h>
53 /* The driver prints some debugging information on the console if DEBUG
54 is defined and non-zero. */
58 /* The message level for the debug messages is currently set to KERN_NOTICE
59 so that people can easily see the messages. Later when the debugging messages
60 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
61 #define ST_DEB_MSG KERN_NOTICE
63 #define DEBC(a) if (debugging) { a ; }
69 #define ST_KILOBYTE 1024
71 #include "st_options.h"
74 static int buffer_kbs;
75 static int max_sg_segs;
76 static int try_direct_io = TRY_DIRECT_IO;
77 static int try_rdio = 1;
78 static int try_wdio = 1;
80 static int st_dev_max;
83 static struct class_simple *st_sysfs_class;
85 MODULE_AUTHOR("Kai Makisara");
86 MODULE_DESCRIPTION("SCSI Tape Driver");
87 MODULE_LICENSE("GPL");
89 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
90 * of sysfs parameters (which module_param doesn't yet support).
91 * Sysfs parameters defined explicitly later.
93 module_param_named(buffer_kbs, buffer_kbs, int, 0);
94 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
95 module_param_named(max_sg_segs, max_sg_segs, int, 0);
96 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
97 module_param_named(try_direct_io, try_direct_io, int, 0);
98 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
100 /* Extra parameters for testing */
101 module_param_named(try_rdio, try_rdio, int, 0);
102 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
103 module_param_named(try_wdio, try_wdio, int, 0);
104 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
107 static int write_threshold_kbs; /* retained for compatibility */
108 static struct st_dev_parm {
111 } parms[] __initdata = {
113 "buffer_kbs", &buffer_kbs
115 { /* Retained for compatibility with 2.4 */
116 "write_threshold_kbs", &write_threshold_kbs
122 "try_direct_io", &try_direct_io
127 /* Restrict the number of modes so that names for all are assigned */
128 #if ST_NBR_MODES > 16
129 #error "Maximum number of modes is 16"
131 /* Bit reversed order to get same names for same minors with all
133 static char *st_formats[] = {
134 "", "r", "k", "s", "l", "t", "o", "u",
135 "m", "v", "p", "x", "a", "y", "q", "z"};
137 /* The default definitions have been moved to st_options.h */
139 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
141 /* The buffer size should fit into the 24 bits for length in the
142 6-byte SCSI read and write commands. */
143 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
144 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
147 DEB( static int debugging = DEBUG; )
149 #define MAX_RETRIES 0
150 #define MAX_WRITE_RETRIES 0
151 #define MAX_READY_RETRIES 0
152 #define NO_TAPE NOT_READY
154 #define ST_TIMEOUT (900 * HZ)
155 #define ST_LONG_TIMEOUT (14000 * HZ)
157 /* Remove mode bits and auto-rewind bit (7) */
158 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
159 (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
160 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
162 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
163 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
164 (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
166 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
168 #define SET_DENS_AND_BLK 0x10001
170 static DEFINE_RWLOCK(st_dev_arr_lock);
172 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
173 static int st_max_sg_segs = ST_MAX_SG;
175 static struct scsi_tape **scsi_tapes = NULL;
177 static int modes_defined;
179 static struct st_buffer *new_tape_buffer(int, int, int);
180 static int enlarge_buffer(struct st_buffer *, int, int);
181 static void normalize_buffer(struct st_buffer *);
182 static int append_to_buffer(const char __user *, struct st_buffer *, int);
183 static int from_buffer(struct st_buffer *, char __user *, int);
184 static void move_buffer_data(struct st_buffer *, int);
185 static void buf_to_sg(struct st_buffer *, unsigned int);
187 static int st_map_user_pages(struct scatterlist *, const unsigned int,
188 unsigned long, size_t, int, unsigned long);
189 static int sgl_map_user_pages(struct scatterlist *, const unsigned int,
190 unsigned long, size_t, int);
191 static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int);
193 static int st_probe(struct device *);
194 static int st_remove(struct device *);
195 static int st_init_command(struct scsi_cmnd *);
197 static void do_create_driverfs_files(void);
198 static void do_remove_driverfs_files(void);
199 static void do_create_class_files(struct scsi_tape *, int, int);
201 static struct scsi_driver st_template = {
202 .owner = THIS_MODULE,
208 .init_command = st_init_command,
211 static int st_compression(struct scsi_tape *, int);
213 static int find_partition(struct scsi_tape *);
214 static int switch_partition(struct scsi_tape *);
216 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
219 #include "osst_detect.h"
220 #ifndef SIGS_FROM_OSST
221 #define SIGS_FROM_OSST \
222 {"OnStream", "SC-", "", "osst"}, \
223 {"OnStream", "DI-", "", "osst"}, \
224 {"OnStream", "DP-", "", "osst"}, \
225 {"OnStream", "USB", "", "osst"}, \
226 {"OnStream", "FW-", "", "osst"}
229 struct st_reject_data {
233 char *driver_hint; /* Name of the correct driver, NULL if unknown */
236 static struct st_reject_data reject_list[] = {
237 /* {"XXX", "Yy-", "", NULL}, example */
241 /* If the device signature is on the list of incompatible drives, the
242 function returns a pointer to the name of the correct driver (if known) */
243 static char * st_incompatible(struct scsi_device* SDp)
245 struct st_reject_data *rp;
247 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
248 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
249 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
250 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
252 return rp->driver_hint;
260 static inline char *tape_name(struct scsi_tape *tape)
262 return tape->disk->disk_name;
265 /* Convert the result to success code */
266 static int st_chk_result(struct scsi_tape *STp, struct scsi_request * SRpnt)
268 int result = SRpnt->sr_result;
269 unsigned char *sense = SRpnt->sr_sense_buffer, scode;
270 DEB(const char *stp;)
271 char *name = tape_name(STp);
274 sense[0] = 0; /* We don't have sense data if this byte is zero */
278 if ((driver_byte(result) & DRIVER_MASK) == DRIVER_SENSE)
279 scode = sense[2] & 0x0f;
287 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x Len: %d\n",
289 SRpnt->sr_cmnd[0], SRpnt->sr_cmnd[1], SRpnt->sr_cmnd[2],
290 SRpnt->sr_cmnd[3], SRpnt->sr_cmnd[4], SRpnt->sr_cmnd[5],
292 if (driver_byte(result) & DRIVER_SENSE)
293 scsi_print_req_sense("st", SRpnt);
294 } else ) /* end DEB */
295 if (!(driver_byte(result) & DRIVER_SENSE) ||
296 ((sense[0] & 0x70) == 0x70 &&
298 scode != RECOVERED_ERROR &&
299 /* scode != UNIT_ATTENTION && */
300 scode != BLANK_CHECK &&
301 scode != VOLUME_OVERFLOW &&
302 SRpnt->sr_cmnd[0] != MODE_SENSE &&
303 SRpnt->sr_cmnd[0] != TEST_UNIT_READY)) { /* Abnormal conditions for tape */
304 if (driver_byte(result) & DRIVER_SENSE) {
305 printk(KERN_WARNING "%s: Error with sense data: ", name);
306 scsi_print_req_sense("st", SRpnt);
309 "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
310 name, result, suggestion(result),
311 driver_byte(result) & DRIVER_MASK, host_byte(result));
314 if (STp->cln_mode >= EXTENDED_SENSE_START) {
315 if (STp->cln_sense_value)
316 STp->cleaning_req |= ((SRpnt->sr_sense_buffer[STp->cln_mode] &
317 STp->cln_sense_mask) == STp->cln_sense_value);
319 STp->cleaning_req |= ((SRpnt->sr_sense_buffer[STp->cln_mode] &
320 STp->cln_sense_mask) != 0);
322 if (sense[12] == 0 && sense[13] == 0x17) /* ASC and ASCQ => cleaning requested */
323 STp->cleaning_req = 1;
325 STp->pos_unknown |= STp->device->was_reset;
327 if ((sense[0] & 0x70) == 0x70 &&
328 scode == RECOVERED_ERROR
329 #if ST_RECOVERED_WRITE_FATAL
330 && SRpnt->sr_cmnd[0] != WRITE_6
331 && SRpnt->sr_cmnd[0] != WRITE_FILEMARKS
334 STp->recover_count++;
339 if (SRpnt->sr_cmnd[0] == READ_6)
341 else if (SRpnt->sr_cmnd[0] == WRITE_6)
345 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
349 if ((sense[2] & 0xe0) == 0)
356 /* Wakeup from interrupt */
357 static void st_sleep_done(struct scsi_cmnd * SCpnt)
360 struct scsi_tape *STp = container_of(SCpnt->request->rq_disk->private_data,
361 struct scsi_tape, driver);
363 if ((STp->buffer)->writing &&
364 (SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
365 (SCpnt->sense_buffer[2] & 0x40)) {
366 /* EOM at write-behind, has all been written? */
367 if ((SCpnt->sense_buffer[0] & 0x80) != 0)
368 remainder = (SCpnt->sense_buffer[3] << 24) |
369 (SCpnt->sense_buffer[4] << 16) |
370 (SCpnt->sense_buffer[5] << 8) |
371 SCpnt->sense_buffer[6];
374 if ((SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW ||
376 (STp->buffer)->midlevel_result = SCpnt->result; /* Error */
378 (STp->buffer)->midlevel_result = INT_MAX; /* OK */
380 (STp->buffer)->midlevel_result = SCpnt->result;
381 SCpnt->request->rq_status = RQ_SCSI_DONE;
382 (STp->buffer)->last_SRpnt = SCpnt->sc_request;
383 DEB( STp->write_pending = 0; )
385 complete(SCpnt->request->waiting);
388 /* Do the scsi command. Waits until command performed if do_wait is true.
389 Otherwise write_behind_check() is used to check that the command
391 static struct scsi_request *
392 st_do_scsi(struct scsi_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
393 int bytes, int direction, int timeout, int retries, int do_wait)
398 SRpnt = scsi_allocate_request(STp->device, GFP_ATOMIC);
400 DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n",
402 if (signal_pending(current))
403 (STp->buffer)->syscall_result = (-EINTR);
405 (STp->buffer)->syscall_result = (-EBUSY);
410 init_completion(&STp->wait);
411 SRpnt->sr_use_sg = STp->buffer->do_dio || (bytes > (STp->buffer)->frp[0].length);
412 if (SRpnt->sr_use_sg) {
413 if (!STp->buffer->do_dio)
414 buf_to_sg(STp->buffer, bytes);
415 SRpnt->sr_use_sg = (STp->buffer)->sg_segs;
416 bp = (char *) &((STp->buffer)->sg[0]);
418 bp = (STp->buffer)->b_data;
419 SRpnt->sr_data_direction = direction;
420 SRpnt->sr_cmd_len = 0;
421 SRpnt->sr_request->waiting = &(STp->wait);
422 SRpnt->sr_request->rq_status = RQ_SCSI_BUSY;
423 SRpnt->sr_request->rq_disk = STp->disk;
425 scsi_do_req(SRpnt, (void *) cmd, bp, bytes,
426 st_sleep_done, timeout, retries);
429 wait_for_completion(SRpnt->sr_request->waiting);
430 SRpnt->sr_request->waiting = NULL;
431 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
437 /* Handle the write-behind checking (downs the semaphore) */
438 static void write_behind_check(struct scsi_tape * STp)
440 struct st_buffer *STbuffer;
441 struct st_partstat *STps;
443 STbuffer = STp->buffer;
446 if (STp->write_pending)
452 wait_for_completion(&(STp->wait));
453 (STp->buffer)->last_SRpnt->sr_request->waiting = NULL;
455 (STp->buffer)->syscall_result = st_chk_result(STp, (STp->buffer)->last_SRpnt);
456 scsi_release_request((STp->buffer)->last_SRpnt);
458 STbuffer->buffer_bytes -= STbuffer->writing;
459 STps = &(STp->ps[STp->partition]);
460 if (STps->drv_block >= 0) {
461 if (STp->block_size == 0)
464 STps->drv_block += STbuffer->writing / STp->block_size;
466 STbuffer->writing = 0;
472 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
473 it messes up the block number). */
474 static int cross_eof(struct scsi_tape * STp, int forward)
476 struct scsi_request *SRpnt;
477 unsigned char cmd[MAX_COMMAND_SIZE];
480 cmd[1] = 0x01; /* Space FileMarks */
485 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
488 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
489 tape_name(STp), forward ? "forward" : "backward"));
491 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
492 STp->device->timeout, MAX_RETRIES, 1);
494 return (STp->buffer)->syscall_result;
496 scsi_release_request(SRpnt);
499 if ((STp->buffer)->midlevel_result != 0)
500 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
501 tape_name(STp), forward ? "forward" : "backward");
503 return (STp->buffer)->syscall_result;
507 /* Flush the write buffer (never need to write if variable blocksize). */
508 static int flush_write_buffer(struct scsi_tape * STp)
510 int offset, transfer, blks;
512 unsigned char cmd[MAX_COMMAND_SIZE];
513 struct scsi_request *SRpnt;
514 struct st_partstat *STps;
516 if ((STp->buffer)->writing) {
517 write_behind_check(STp);
518 if ((STp->buffer)->syscall_result) {
519 DEBC(printk(ST_DEB_MSG
520 "%s: Async write error (flush) %x.\n",
521 tape_name(STp), (STp->buffer)->midlevel_result))
522 if ((STp->buffer)->midlevel_result == INT_MAX)
527 if (STp->block_size == 0)
531 if (STp->dirty == 1) {
533 offset = (STp->buffer)->buffer_bytes;
534 transfer = ((offset + STp->block_size - 1) /
535 STp->block_size) * STp->block_size;
536 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
537 tape_name(STp), transfer));
539 memset((STp->buffer)->b_data + offset, 0, transfer - offset);
541 memset(cmd, 0, MAX_COMMAND_SIZE);
544 blks = transfer / STp->block_size;
549 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
550 STp->device->timeout, MAX_WRITE_RETRIES, 1);
552 return (STp->buffer)->syscall_result;
554 STps = &(STp->ps[STp->partition]);
555 if ((STp->buffer)->syscall_result != 0) {
556 if ((SRpnt->sr_sense_buffer[0] & 0x70) == 0x70 &&
557 (SRpnt->sr_sense_buffer[2] & 0x40) &&
558 (SRpnt->sr_sense_buffer[2] & 0x0f) == NO_SENSE) {
560 (STp->buffer)->buffer_bytes = 0;
563 printk(KERN_ERR "%s: Error on flush.\n",
567 STps->drv_block = (-1);
569 if (STps->drv_block >= 0)
570 STps->drv_block += blks;
572 (STp->buffer)->buffer_bytes = 0;
574 scsi_release_request(SRpnt);
581 /* Flush the tape buffer. The tape will be positioned correctly unless
582 seek_next is true. */
583 static int flush_buffer(struct scsi_tape *STp, int seek_next)
585 int backspace, result;
586 struct st_buffer *STbuffer;
587 struct st_partstat *STps;
589 STbuffer = STp->buffer;
592 * If there was a bus reset, block further access
595 if (STp->pos_unknown)
598 if (STp->ready != ST_READY)
600 STps = &(STp->ps[STp->partition]);
601 if (STps->rw == ST_WRITING) /* Writing */
602 return flush_write_buffer(STp);
604 if (STp->block_size == 0)
607 backspace = ((STp->buffer)->buffer_bytes +
608 (STp->buffer)->read_pointer) / STp->block_size -
609 ((STp->buffer)->read_pointer + STp->block_size - 1) /
611 (STp->buffer)->buffer_bytes = 0;
612 (STp->buffer)->read_pointer = 0;
615 if (STps->eof == ST_FM_HIT) {
616 result = cross_eof(STp, 0); /* Back over the EOF hit */
618 STps->eof = ST_NOEOF;
620 if (STps->drv_file >= 0)
625 if (!result && backspace > 0)
626 result = st_int_ioctl(STp, MTBSR, backspace);
627 } else if (STps->eof == ST_FM_HIT) {
628 if (STps->drv_file >= 0)
631 STps->eof = ST_NOEOF;
637 /* Set the mode parameters */
638 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
642 char *name = tape_name(STp);
644 if (!STp->density_changed &&
645 STm->default_density >= 0 &&
646 STm->default_density != STp->density) {
647 arg = STm->default_density;
651 arg <<= MT_ST_DENSITY_SHIFT;
652 if (!STp->blksize_changed &&
653 STm->default_blksize >= 0 &&
654 STm->default_blksize != STp->block_size) {
655 arg |= STm->default_blksize;
658 arg |= STp->block_size;
660 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
662 "%s: Can't set default block size to %d bytes and density %x.\n",
663 name, STm->default_blksize, STm->default_density);
671 /* Lock or unlock the drive door. Don't use when scsi_request allocated. */
672 static int do_door_lock(struct scsi_tape * STp, int do_lock)
675 DEB(char *name = tape_name(STp);)
678 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
679 DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
680 do_lock ? "L" : "Unl"));
681 retval = scsi_ioctl(STp->device, cmd, NULL);
683 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
686 STp->door_locked = ST_LOCK_FAILS;
692 /* Set the internal state after reset */
693 static void reset_state(struct scsi_tape *STp)
696 struct st_partstat *STps;
698 STp->pos_unknown = 0;
699 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
700 STps = &(STp->ps[i]);
702 STps->eof = ST_NOEOF;
704 STps->last_block_valid = 0;
705 STps->drv_block = -1;
708 if (STp->can_partitions) {
709 STp->partition = find_partition(STp);
710 if (STp->partition < 0)
712 STp->new_partition = STp->partition;
716 /* Test if the drive is ready. Returns either one of the codes below or a negative system
718 #define CHKRES_READY 0
719 #define CHKRES_NEW_SESSION 1
720 #define CHKRES_NOT_READY 2
721 #define CHKRES_NO_TAPE 3
723 #define MAX_ATTENTIONS 10
725 static int test_ready(struct scsi_tape *STp, int do_wait)
727 int attentions, waits, max_wait, scode;
728 int retval = CHKRES_READY, new_session = 0;
729 unsigned char cmd[MAX_COMMAND_SIZE];
730 struct scsi_request *SRpnt = NULL;
732 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
734 for (attentions=waits=0; ; ) {
735 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
736 cmd[0] = TEST_UNIT_READY;
737 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
738 STp->long_timeout, MAX_READY_RETRIES, 1);
741 retval = (STp->buffer)->syscall_result;
745 if ((SRpnt->sr_sense_buffer[0] & 0x70) == 0x70) {
747 scode = (SRpnt->sr_sense_buffer[2] & 0x0f);
749 if (scode == UNIT_ATTENTION) { /* New media? */
751 if (attentions < MAX_ATTENTIONS) {
761 if (scode == NOT_READY) {
762 if (waits < max_wait) {
763 set_current_state(TASK_INTERRUPTIBLE);
764 schedule_timeout(HZ);
765 if (signal_pending(current)) {
773 if ((STp->device)->scsi_level >= SCSI_2 &&
774 SRpnt->sr_sense_buffer[12] == 0x3a) /* Check ASC */
775 retval = CHKRES_NO_TAPE;
777 retval = CHKRES_NOT_READY;
783 retval = (STp->buffer)->syscall_result;
785 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
790 scsi_release_request(SRpnt);
795 /* See if the drive is ready and gather information about the tape. Return values:
796 < 0 negative error code from errno.h
798 1 drive not ready (possibly no tape)
800 static int check_tape(struct scsi_tape *STp, struct file *filp)
802 int i, retval, new_session = 0, do_wait;
803 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
804 unsigned short st_flags = filp->f_flags;
805 struct scsi_request *SRpnt = NULL;
806 struct st_modedef *STm;
807 struct st_partstat *STps;
808 char *name = tape_name(STp);
809 struct inode *inode = filp->f_dentry->d_inode;
810 int mode = TAPE_MODE(inode);
812 STp->ready = ST_READY;
814 if (mode != STp->current_mode) {
815 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
816 name, STp->current_mode, mode));
818 STp->current_mode = mode;
820 STm = &(STp->modes[STp->current_mode]);
822 saved_cleaning = STp->cleaning_req;
823 STp->cleaning_req = 0;
825 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
826 retval = test_ready(STp, do_wait);
831 if (retval == CHKRES_NEW_SESSION) {
832 STp->pos_unknown = 0;
833 STp->partition = STp->new_partition = 0;
834 if (STp->can_partitions)
835 STp->nbr_partitions = 1; /* This guess will be updated later
837 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
838 STps = &(STp->ps[i]);
840 STps->eof = ST_NOEOF;
842 STps->last_block_valid = 0;
849 STp->cleaning_req |= saved_cleaning;
851 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
852 if (retval == CHKRES_NO_TAPE)
853 STp->ready = ST_NO_TAPE;
855 STp->ready = ST_NOT_READY;
857 STp->density = 0; /* Clear the erroneous "residue" */
860 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
861 STp->partition = STp->new_partition = 0;
862 STp->door_locked = ST_UNLOCKED;
863 return CHKRES_NOT_READY;
867 if (STp->omit_blklims)
868 STp->min_block = STp->max_block = (-1);
870 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
871 cmd[0] = READ_BLOCK_LIMITS;
873 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
874 STp->device->timeout, MAX_READY_RETRIES, 1);
876 retval = (STp->buffer)->syscall_result;
880 if (!SRpnt->sr_result && !SRpnt->sr_sense_buffer[0]) {
881 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
882 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
883 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
884 (STp->buffer)->b_data[5];
885 if ( DEB( debugging || ) !STp->inited)
887 "%s: Block limits %d - %d bytes.\n", name,
888 STp->min_block, STp->max_block);
890 STp->min_block = STp->max_block = (-1);
891 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
896 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
900 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
901 STp->device->timeout, MAX_READY_RETRIES, 1);
903 retval = (STp->buffer)->syscall_result;
907 if ((STp->buffer)->syscall_result != 0) {
908 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
909 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
910 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */
911 STp->drv_write_prot = 0;
913 DEBC(printk(ST_DEB_MSG
914 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
916 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
917 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
919 if ((STp->buffer)->b_data[3] >= 8) {
920 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
921 STp->density = (STp->buffer)->b_data[4];
922 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
923 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
924 DEBC(printk(ST_DEB_MSG
925 "%s: Density %x, tape length: %x, drv buffer: %d\n",
926 name, STp->density, (STp->buffer)->b_data[5] * 65536 +
927 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
930 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
932 scsi_release_request(SRpnt);
936 if (STp->block_size > 0)
937 (STp->buffer)->buffer_blocks =
938 (STp->buffer)->buffer_size / STp->block_size;
940 (STp->buffer)->buffer_blocks = 1;
941 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
943 DEBC(printk(ST_DEB_MSG
944 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
945 STp->block_size, (STp->buffer)->buffer_size,
946 (STp->buffer)->buffer_blocks));
948 if (STp->drv_write_prot) {
951 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
954 ((st_flags & O_ACCMODE) == O_WRONLY ||
955 (st_flags & O_ACCMODE) == O_RDWR)) {
961 if (STp->can_partitions && STp->nbr_partitions < 1) {
962 /* This code is reached when the device is opened for the first time
963 after the driver has been initialized with tape in the drive and the
964 partition support has been enabled. */
965 DEBC(printk(ST_DEB_MSG
966 "%s: Updating partition number in status.\n", name));
967 if ((STp->partition = find_partition(STp)) < 0) {
968 retval = STp->partition;
971 STp->new_partition = STp->partition;
972 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
975 if (new_session) { /* Change the drive parameters for the new mode */
976 STp->density_changed = STp->blksize_changed = 0;
977 STp->compression_changed = 0;
978 if (!(STm->defaults_for_writes) &&
979 (retval = set_mode_densblk(STp, STm)) < 0)
982 if (STp->default_drvbuffer != 0xff) {
983 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
985 "%s: Can't set default drive buffering to %d.\n",
986 name, STp->default_drvbuffer);
997 \f/* Open the device. Needs to be called with BKL only because of incrementing the SCSI host
999 static int st_open(struct inode *inode, struct file *filp)
1001 int i, retval = (-EIO);
1002 struct scsi_tape *STp;
1003 struct st_partstat *STps;
1004 int dev = TAPE_NR(inode);
1007 nonseekable_open(inode, filp);
1008 write_lock(&st_dev_arr_lock);
1009 if (dev >= st_dev_max || scsi_tapes == NULL ||
1010 ((STp = scsi_tapes[dev]) == NULL)) {
1011 write_unlock(&st_dev_arr_lock);
1014 filp->private_data = STp;
1015 name = tape_name(STp);
1018 write_unlock(&st_dev_arr_lock);
1019 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1023 if(scsi_device_get(STp->device)) {
1024 write_unlock(&st_dev_arr_lock);
1028 write_unlock(&st_dev_arr_lock);
1029 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1031 if (!scsi_block_when_processing_errors(STp->device)) {
1036 /* See that we have at least a one page buffer available */
1037 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1038 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1040 retval = (-EOVERFLOW);
1044 (STp->buffer)->writing = 0;
1045 (STp->buffer)->syscall_result = 0;
1047 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1050 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1051 STps = &(STp->ps[i]);
1054 STp->recover_count = 0;
1055 DEB( STp->nbr_waits = STp->nbr_finished = 0;
1056 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = STp->nbr_combinable = 0; )
1058 retval = check_tape(STp, filp);
1061 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1062 retval != CHKRES_READY) {
1069 normalize_buffer(STp->buffer);
1071 scsi_device_put(STp->device);
1077 /* Flush the tape buffer before close */
1078 static int st_flush(struct file *filp)
1080 int result = 0, result2;
1081 unsigned char cmd[MAX_COMMAND_SIZE];
1082 struct scsi_request *SRpnt;
1083 struct scsi_tape *STp = filp->private_data;
1084 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1085 struct st_partstat *STps = &(STp->ps[STp->partition]);
1086 char *name = tape_name(STp);
1088 if (file_count(filp) > 1)
1091 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1092 result = flush_write_buffer(STp);
1093 if (result != 0 && result != (-ENOSPC))
1097 if (STp->can_partitions &&
1098 (result2 = switch_partition(STp)) < 0) {
1099 DEBC(printk(ST_DEB_MSG
1100 "%s: switch_partition at close failed.\n", name));
1106 DEBC( if (STp->nbr_requests)
1107 printk(KERN_WARNING "%s: Number of r/w requests %d, dio used in %d, pages %d (%d).\n",
1108 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages, STp->nbr_combinable));
1110 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1112 DEBC(printk(ST_DEB_MSG "%s: File length %lld bytes.\n",
1113 name, (long long)filp->f_pos);
1114 printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1115 name, STp->nbr_waits, STp->nbr_finished);
1118 memset(cmd, 0, MAX_COMMAND_SIZE);
1119 cmd[0] = WRITE_FILEMARKS;
1120 cmd[4] = 1 + STp->two_fm;
1122 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1123 STp->device->timeout, MAX_WRITE_RETRIES, 1);
1125 result = (STp->buffer)->syscall_result;
1129 if ((STp->buffer)->syscall_result != 0 &&
1130 ((SRpnt->sr_sense_buffer[0] & 0x70) != 0x70 ||
1131 (SRpnt->sr_sense_buffer[2] & 0x4f) != 0x40 ||
1132 ((SRpnt->sr_sense_buffer[0] & 0x80) != 0 &&
1133 (SRpnt->sr_sense_buffer[3] | SRpnt->sr_sense_buffer[4] |
1134 SRpnt->sr_sense_buffer[5] |
1135 SRpnt->sr_sense_buffer[6]) != 0))) {
1136 /* Filter out successful write at EOM */
1137 scsi_release_request(SRpnt);
1139 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1143 scsi_release_request(SRpnt);
1145 if (STps->drv_file >= 0)
1147 STps->drv_block = 0;
1153 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1155 } else if (!STp->rew_at_close) {
1156 STps = &(STp->ps[STp->partition]);
1157 if (!STm->sysv || STps->rw != ST_READING) {
1159 result = flush_buffer(STp, 0);
1160 else if (STps->eof == ST_FM_HIT) {
1161 result = cross_eof(STp, 0);
1163 if (STps->drv_file >= 0)
1165 STps->drv_block = 0;
1168 STps->eof = ST_NOEOF;
1170 } else if ((STps->eof == ST_NOEOF &&
1171 !(result = cross_eof(STp, 1))) ||
1172 STps->eof == ST_FM_HIT) {
1173 if (STps->drv_file >= 0)
1175 STps->drv_block = 0;
1181 if (STp->rew_at_close) {
1182 result2 = st_int_ioctl(STp, MTREW, 1);
1190 /* Close the device and release it. BKL is not needed: this is the only thread
1191 accessing this tape. */
1192 static int st_release(struct inode *inode, struct file *filp)
1195 struct scsi_tape *STp = filp->private_data;
1197 if (STp->door_locked == ST_LOCKED_AUTO)
1198 do_door_lock(STp, 0);
1200 normalize_buffer(STp->buffer);
1201 write_lock(&st_dev_arr_lock);
1203 write_unlock(&st_dev_arr_lock);
1204 scsi_device_put(STp->device);
1209 /* The checks common to both reading and writing */
1210 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1215 * If we are in the middle of error recovery, don't let anyone
1216 * else try and use this device. Also, if error recovery fails, it
1217 * may try and take the device offline, in which case all further
1218 * access to the device is prohibited.
1220 if (!scsi_block_when_processing_errors(STp->device)) {
1225 if (STp->ready != ST_READY) {
1226 if (STp->ready == ST_NO_TAPE)
1227 retval = (-ENOMEDIUM);
1233 if (! STp->modes[STp->current_mode].defined) {
1240 * If there was a bus reset, block further access
1243 if (STp->pos_unknown) {
1253 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1258 if (STp->can_partitions &&
1259 (retval = switch_partition(STp)) < 0)
1262 if (STp->block_size == 0 && STp->max_block > 0 &&
1263 (count < STp->min_block || count > STp->max_block)) {
1268 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1269 !do_door_lock(STp, 1))
1270 STp->door_locked = ST_LOCKED_AUTO;
1277 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1278 size_t count, int is_read)
1280 int i, bufsize, retval = 0;
1281 struct st_buffer *STbp = STp->buffer;
1284 i = STp->try_dio && try_rdio;
1286 i = STp->try_dio && try_wdio;
1287 if (i && ((unsigned long)buf & queue_dma_alignment(
1288 STp->device->request_queue)) == 0) {
1289 i = st_map_user_pages(&(STbp->sg[0]), STbp->use_sg,
1290 (unsigned long)buf, count, (is_read ? READ : WRITE),
1294 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1297 STbp->do_dio = 0; /* fall back to buffering with any error */
1298 STbp->sg_segs = STbp->do_dio;
1299 STbp->frp_sg_current = 0;
1303 STp->nbr_pages += STbp->do_dio;
1304 for (i=1; i < STbp->do_dio; i++)
1305 if (page_to_pfn(STbp->sg[i].page) == page_to_pfn(STbp->sg[i-1].page) + 1)
1306 STp->nbr_combinable++;
1311 DEB( STp->nbr_requests++; )
1313 if (!STbp->do_dio) {
1314 if (STp->block_size)
1315 bufsize = STp->block_size > st_fixed_buffer_size ?
1316 STp->block_size : st_fixed_buffer_size;
1319 if (bufsize > STbp->buffer_size &&
1320 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1321 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1322 tape_name(STp), bufsize);
1323 retval = (-EOVERFLOW);
1326 if (STp->block_size)
1327 STbp->buffer_blocks = bufsize / STp->block_size;
1335 /* Can be called more than once after each setup_buffer() */
1336 static void release_buffering(struct scsi_tape *STp)
1338 struct st_buffer *STbp;
1342 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, 0);
1350 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1353 ssize_t i, do_count, blks, transfer;
1355 int undone, retry_eot = 0, scode;
1357 unsigned char cmd[MAX_COMMAND_SIZE];
1358 const char __user *b_point;
1359 struct scsi_request *SRpnt = NULL;
1360 struct scsi_tape *STp = filp->private_data;
1361 struct st_modedef *STm;
1362 struct st_partstat *STps;
1363 struct st_buffer *STbp;
1364 char *name = tape_name(STp);
1366 if (down_interruptible(&STp->lock))
1367 return -ERESTARTSYS;
1369 retval = rw_checks(STp, filp, count);
1370 if (retval || count == 0)
1373 /* Write must be integral number of blocks */
1374 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1375 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1381 STm = &(STp->modes[STp->current_mode]);
1382 STps = &(STp->ps[STp->partition]);
1384 if (STp->write_prot) {
1390 if (STps->rw == ST_READING) {
1391 retval = flush_buffer(STp, 0);
1394 STps->rw = ST_WRITING;
1395 } else if (STps->rw != ST_WRITING &&
1396 STps->drv_file == 0 && STps->drv_block == 0) {
1397 if ((retval = set_mode_densblk(STp, STm)) < 0)
1399 if (STm->default_compression != ST_DONT_TOUCH &&
1400 !(STp->compression_changed)) {
1401 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1402 printk(KERN_WARNING "%s: Can't set default compression.\n",
1404 if (modes_defined) {
1413 if (STbp->writing) {
1414 write_behind_check(STp);
1415 if (STbp->syscall_result) {
1416 DEBC(printk(ST_DEB_MSG "%s: Async write error (write) %x.\n",
1417 name, STbp->midlevel_result));
1418 if (STbp->midlevel_result == INT_MAX)
1419 STps->eof = ST_EOM_OK;
1421 STps->eof = ST_EOM_ERROR;
1425 if (STps->eof == ST_EOM_OK) {
1426 STps->eof = ST_EOD_1; /* allow next write */
1430 else if (STps->eof == ST_EOM_ERROR) {
1435 /* Check the buffer readability in cases where copy_user might catch
1436 the problems after some tape movement. */
1437 if (STp->block_size != 0 &&
1439 (copy_from_user(&i, buf, 1) != 0 ||
1440 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1445 retval = setup_buffering(STp, buf, count, 0);
1451 memset(cmd, 0, MAX_COMMAND_SIZE);
1453 cmd[1] = (STp->block_size != 0);
1455 STps->rw = ST_WRITING;
1458 while (count > 0 && !retry_eot) {
1464 if (STp->block_size == 0)
1467 do_count = STbp->buffer_blocks * STp->block_size -
1469 if (do_count > count)
1473 i = append_to_buffer(b_point, STbp, do_count);
1480 filp->f_pos += do_count;
1481 b_point += do_count;
1483 async_write = STp->block_size == 0 && !STbp->do_dio &&
1484 STm->do_async_writes && STps->eof < ST_EOM_OK;
1486 if (STp->block_size != 0 && STm->do_buffer_writes &&
1487 !(STp->try_dio && try_wdio) && STps->eof < ST_EOM_OK &&
1488 STbp->buffer_bytes < STbp->buffer_size) {
1490 /* Don't write a buffer that is not full enough. */
1491 if (!async_write && count == 0)
1496 if (STp->block_size == 0)
1497 blks = transfer = do_count;
1500 blks = STbp->buffer_bytes;
1503 blks /= STp->block_size;
1504 transfer = blks * STp->block_size;
1506 cmd[2] = blks >> 16;
1510 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1511 STp->device->timeout, MAX_WRITE_RETRIES, !async_write);
1513 retval = STbp->syscall_result;
1517 STbp->writing = transfer;
1518 STp->dirty = !(STbp->writing ==
1519 STbp->buffer_bytes);
1520 SRpnt = NULL; /* Prevent releasing this request! */
1521 DEB( STp->write_pending = 1; )
1525 if (STbp->syscall_result != 0) {
1526 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1527 if ((SRpnt->sr_sense_buffer[0] & 0x70) == 0x70 &&
1528 (SRpnt->sr_sense_buffer[2] & 0x40)) {
1529 scode = SRpnt->sr_sense_buffer[2] & 0x0f;
1530 if ((SRpnt->sr_sense_buffer[0] & 0x80) != 0)
1531 undone = (SRpnt->sr_sense_buffer[3] << 24) |
1532 (SRpnt->sr_sense_buffer[4] << 16) |
1533 (SRpnt->sr_sense_buffer[5] << 8) |
1534 SRpnt->sr_sense_buffer[6];
1535 else if (STp->block_size == 0 &&
1536 scode == VOLUME_OVERFLOW)
1540 if (STp->block_size != 0)
1541 undone *= STp->block_size;
1542 filp->f_pos -= undone;
1543 if (undone <= do_count) {
1544 /* Only data from this write is not written */
1547 if (STp->block_size)
1548 blks = (transfer - undone) / STp->block_size;
1549 STps->eof = ST_EOM_OK;
1550 /* Continue in fixed block mode if all written
1551 in this request but still something left to write
1552 (retval left to zero)
1554 if (STp->block_size == 0 ||
1555 undone > 0 || count == 0)
1556 retval = (-ENOSPC); /* EOM within current request */
1557 DEBC(printk(ST_DEB_MSG
1558 "%s: EOM with %d bytes unwritten.\n",
1561 /* EOT within data buffered earlier (possible only
1562 in fixed block mode without direct i/o) */
1563 if (!retry_eot && (SRpnt->sr_sense_buffer[0] & 1) == 0 &&
1564 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1565 move_buffer_data(STp->buffer, transfer - undone);
1567 if (STps->drv_block >= 0) {
1568 STps->drv_block += (transfer - undone) /
1571 STps->eof = ST_EOM_OK;
1572 DEBC(printk(ST_DEB_MSG
1573 "%s: Retry write of %d bytes at EOM.\n",
1574 name, STp->buffer->buffer_bytes));
1578 /* Either error within data buffered by driver or
1581 blks = do_count = 0;
1582 STps->eof = ST_EOM_ERROR;
1583 STps->drv_block = (-1); /* Too cautious? */
1584 retval = (-EIO); /* EOM for old data */
1585 DEBC(printk(ST_DEB_MSG
1586 "%s: EOM with lost data.\n",
1591 filp->f_pos -= do_count;
1593 STps->drv_block = (-1); /* Too cautious? */
1599 if (STps->drv_block >= 0) {
1600 if (STp->block_size == 0)
1601 STps->drv_block += (do_count > 0);
1603 STps->drv_block += blks;
1606 STbp->buffer_bytes = 0;
1609 if (retval || retry_eot) {
1611 retval = total - count;
1616 if (STps->eof == ST_EOD_1)
1617 STps->eof = ST_EOM_OK;
1618 else if (STps->eof != ST_EOM_OK)
1619 STps->eof = ST_NOEOF;
1620 retval = total - count;
1624 scsi_release_request(SRpnt);
1625 release_buffering(STp);
1631 /* Read data from the tape. Returns zero in the normal case, one if the
1632 eof status has changed, and the negative error code in case of a
1633 fatal error. Otherwise updates the buffer and the eof state.
1635 Does release user buffer mapping if it is set.
1637 static long read_tape(struct scsi_tape *STp, long count,
1638 struct scsi_request ** aSRpnt)
1640 int transfer, blks, bytes;
1641 unsigned char cmd[MAX_COMMAND_SIZE];
1642 struct scsi_request *SRpnt;
1643 struct st_modedef *STm;
1644 struct st_partstat *STps;
1645 struct st_buffer *STbp;
1647 char *name = tape_name(STp);
1652 STm = &(STp->modes[STp->current_mode]);
1653 STps = &(STp->ps[STp->partition]);
1654 if (STps->eof == ST_FM_HIT)
1658 if (STp->block_size == 0)
1659 blks = bytes = count;
1661 if (!(STp->try_dio && try_rdio) && STm->do_read_ahead) {
1662 blks = (STp->buffer)->buffer_blocks;
1663 bytes = blks * STp->block_size;
1666 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1667 bytes = (STp->buffer)->buffer_size;
1668 blks = bytes / STp->block_size;
1669 bytes = blks * STp->block_size;
1673 memset(cmd, 0, MAX_COMMAND_SIZE);
1675 cmd[1] = (STp->block_size != 0);
1676 cmd[2] = blks >> 16;
1681 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1682 STp->device->timeout, MAX_RETRIES, 1);
1683 release_buffering(STp);
1686 return STbp->syscall_result;
1688 STbp->read_pointer = 0;
1691 /* Something to check */
1692 if (STbp->syscall_result) {
1694 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1696 SRpnt->sr_sense_buffer[0], SRpnt->sr_sense_buffer[1],
1697 SRpnt->sr_sense_buffer[2], SRpnt->sr_sense_buffer[3],
1698 SRpnt->sr_sense_buffer[4], SRpnt->sr_sense_buffer[5],
1699 SRpnt->sr_sense_buffer[6], SRpnt->sr_sense_buffer[7]));
1700 if ((SRpnt->sr_sense_buffer[0] & 0x70) == 0x70) { /* extended sense */
1702 if ((SRpnt->sr_sense_buffer[2] & 0x0f) == BLANK_CHECK)
1703 SRpnt->sr_sense_buffer[2] &= 0xcf; /* No need for EOM in this case */
1705 if ((SRpnt->sr_sense_buffer[2] & 0xe0) != 0) { /* EOF, EOM, or ILI */
1706 /* Compute the residual count */
1707 if ((SRpnt->sr_sense_buffer[0] & 0x80) != 0)
1708 transfer = (SRpnt->sr_sense_buffer[3] << 24) |
1709 (SRpnt->sr_sense_buffer[4] << 16) |
1710 (SRpnt->sr_sense_buffer[5] << 8) |
1711 SRpnt->sr_sense_buffer[6];
1714 if (STp->block_size == 0 &&
1715 (SRpnt->sr_sense_buffer[2] & 0x0f) == MEDIUM_ERROR)
1718 if (SRpnt->sr_sense_buffer[2] & 0x20) { /* ILI */
1719 if (STp->block_size == 0) {
1720 if (transfer <= 0) {
1723 "%s: Failed to read %d byte block with %d byte transfer.\n",
1724 name, bytes - transfer, bytes);
1725 if (STps->drv_block >= 0)
1726 STps->drv_block += 1;
1727 STbp->buffer_bytes = 0;
1730 STbp->buffer_bytes = bytes - transfer;
1732 scsi_release_request(SRpnt);
1733 SRpnt = *aSRpnt = NULL;
1734 if (transfer == blks) { /* We did not get anything, error */
1735 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1736 if (STps->drv_block >= 0)
1737 STps->drv_block += blks - transfer + 1;
1738 st_int_ioctl(STp, MTBSR, 1);
1741 /* We have some data, deliver it */
1742 STbp->buffer_bytes = (blks - transfer) *
1744 DEBC(printk(ST_DEB_MSG
1745 "%s: ILI but enough data received %ld %d.\n",
1746 name, count, STbp->buffer_bytes));
1747 if (STps->drv_block >= 0)
1748 STps->drv_block += 1;
1749 if (st_int_ioctl(STp, MTBSR, 1))
1752 } else if (SRpnt->sr_sense_buffer[2] & 0x80) { /* FM overrides EOM */
1753 if (STps->eof != ST_FM_HIT)
1754 STps->eof = ST_FM_HIT;
1756 STps->eof = ST_EOD_2;
1757 if (STp->block_size == 0)
1758 STbp->buffer_bytes = 0;
1760 STbp->buffer_bytes =
1761 bytes - transfer * STp->block_size;
1762 DEBC(printk(ST_DEB_MSG
1763 "%s: EOF detected (%d bytes read).\n",
1764 name, STbp->buffer_bytes));
1765 } else if (SRpnt->sr_sense_buffer[2] & 0x40) {
1766 if (STps->eof == ST_FM)
1767 STps->eof = ST_EOD_1;
1769 STps->eof = ST_EOM_OK;
1770 if (STp->block_size == 0)
1771 STbp->buffer_bytes = bytes - transfer;
1773 STbp->buffer_bytes =
1774 bytes - transfer * STp->block_size;
1776 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1777 name, STbp->buffer_bytes));
1780 /* end of EOF, EOM, ILI test */
1781 else { /* nonzero sense key */
1782 DEBC(printk(ST_DEB_MSG
1783 "%s: Tape error while reading.\n", name));
1784 STps->drv_block = (-1);
1785 if (STps->eof == ST_FM &&
1786 (SRpnt->sr_sense_buffer[2] & 0x0f) == BLANK_CHECK) {
1787 DEBC(printk(ST_DEB_MSG
1788 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1790 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1791 } else /* Some other extended sense code */
1795 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
1796 STbp->buffer_bytes = 0;
1798 /* End of extended sense test */
1799 else { /* Non-extended sense */
1800 retval = STbp->syscall_result;
1804 /* End of error handling */
1805 else /* Read successful */
1806 STbp->buffer_bytes = bytes;
1808 if (STps->drv_block >= 0) {
1809 if (STp->block_size == 0)
1812 STps->drv_block += STbp->buffer_bytes / STp->block_size;
1820 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
1824 ssize_t i, transfer;
1825 int special, do_dio = 0;
1826 struct scsi_request *SRpnt = NULL;
1827 struct scsi_tape *STp = filp->private_data;
1828 struct st_modedef *STm;
1829 struct st_partstat *STps;
1830 struct st_buffer *STbp = STp->buffer;
1831 DEB( char *name = tape_name(STp); )
1833 if (down_interruptible(&STp->lock))
1834 return -ERESTARTSYS;
1836 retval = rw_checks(STp, filp, count);
1837 if (retval || count == 0)
1840 STm = &(STp->modes[STp->current_mode]);
1841 if (!(STm->do_read_ahead) && STp->block_size != 0 &&
1842 (count % STp->block_size) != 0) {
1843 retval = (-EINVAL); /* Read must be integral number of blocks */
1847 STps = &(STp->ps[STp->partition]);
1848 if (STps->rw == ST_WRITING) {
1849 retval = flush_buffer(STp, 0);
1852 STps->rw = ST_READING;
1855 if (debugging && STps->eof != ST_NOEOF)
1856 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
1857 STps->eof, STbp->buffer_bytes);
1860 retval = setup_buffering(STp, buf, count, 1);
1863 do_dio = STbp->do_dio;
1865 if (STbp->buffer_bytes == 0 &&
1866 STps->eof >= ST_EOD_1) {
1867 if (STps->eof < ST_EOD) {
1872 retval = (-EIO); /* EOM or Blank Check */
1877 /* Check the buffer writability before any tape movement. Don't alter
1879 if (copy_from_user(&i, buf, 1) != 0 ||
1880 copy_to_user(buf, &i, 1) != 0 ||
1881 copy_from_user(&i, buf + count - 1, 1) != 0 ||
1882 copy_to_user(buf + count - 1, &i, 1) != 0) {
1888 STps->rw = ST_READING;
1891 /* Loop until enough data in buffer or a special condition found */
1892 for (total = 0, special = 0; total < count && !special;) {
1894 /* Get new data if the buffer is empty */
1895 if (STbp->buffer_bytes == 0) {
1896 special = read_tape(STp, count - total, &SRpnt);
1897 if (special < 0) { /* No need to continue read */
1903 /* Move the data from driver buffer to user buffer */
1904 if (STbp->buffer_bytes > 0) {
1906 if (debugging && STps->eof != ST_NOEOF)
1908 "%s: EOF up (%d). Left %d, needed %d.\n", name,
1909 STps->eof, STbp->buffer_bytes,
1912 transfer = STbp->buffer_bytes < count - total ?
1913 STbp->buffer_bytes : count - total;
1915 i = from_buffer(STbp, buf, transfer);
1921 filp->f_pos += transfer;
1926 if (STp->block_size == 0)
1927 break; /* Read only one variable length block */
1929 } /* for (total = 0, special = 0;
1930 total < count && !special; ) */
1932 /* Change the eof state if no data from tape or buffer */
1934 if (STps->eof == ST_FM_HIT) {
1936 STps->drv_block = 0;
1937 if (STps->drv_file >= 0)
1939 } else if (STps->eof == ST_EOD_1) {
1940 STps->eof = ST_EOD_2;
1941 STps->drv_block = 0;
1942 if (STps->drv_file >= 0)
1944 } else if (STps->eof == ST_EOD_2)
1946 } else if (STps->eof == ST_FM)
1947 STps->eof = ST_NOEOF;
1951 if (SRpnt != NULL) {
1952 scsi_release_request(SRpnt);
1956 release_buffering(STp);
1957 STbp->buffer_bytes = 0;
1967 /* Set the driver options */
1968 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
1972 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
1973 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
1974 STm->do_read_ahead);
1976 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
1977 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
1979 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
1980 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
1981 STp->scsi2_logical);
1983 "%s: sysv: %d nowait: %d\n", name, STm->sysv, STp->immediate);
1984 printk(KERN_INFO "%s: debugging: %d\n",
1991 static int st_set_options(struct scsi_tape *STp, long options)
1995 struct st_modedef *STm;
1996 char *name = tape_name(STp);
1997 struct cdev *cd0, *cd1;
1999 STm = &(STp->modes[STp->current_mode]);
2000 if (!STm->defined) {
2001 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2002 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2003 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2005 DEBC(printk(ST_DEB_MSG
2006 "%s: Initialized mode %d definition from mode 0\n",
2007 name, STp->current_mode));
2010 code = options & MT_ST_OPTIONS;
2011 if (code == MT_ST_BOOLEANS) {
2012 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2013 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2014 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2015 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2016 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2017 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2018 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2019 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2020 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2021 if ((STp->device)->scsi_level >= SCSI_2)
2022 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2023 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2024 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2025 STm->sysv = (options & MT_ST_SYSV) != 0;
2026 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2027 st_log_options(STp, STm, name); )
2028 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2029 value = (code == MT_ST_SETBOOLEANS);
2030 if ((options & MT_ST_BUFFER_WRITES) != 0)
2031 STm->do_buffer_writes = value;
2032 if ((options & MT_ST_ASYNC_WRITES) != 0)
2033 STm->do_async_writes = value;
2034 if ((options & MT_ST_DEF_WRITES) != 0)
2035 STm->defaults_for_writes = value;
2036 if ((options & MT_ST_READ_AHEAD) != 0)
2037 STm->do_read_ahead = value;
2038 if ((options & MT_ST_TWO_FM) != 0)
2039 STp->two_fm = value;
2040 if ((options & MT_ST_FAST_MTEOM) != 0)
2041 STp->fast_mteom = value;
2042 if ((options & MT_ST_AUTO_LOCK) != 0)
2043 STp->do_auto_lock = value;
2044 if ((options & MT_ST_CAN_BSR) != 0)
2045 STp->can_bsr = value;
2046 if ((options & MT_ST_NO_BLKLIMS) != 0)
2047 STp->omit_blklims = value;
2048 if ((STp->device)->scsi_level >= SCSI_2 &&
2049 (options & MT_ST_CAN_PARTITIONS) != 0)
2050 STp->can_partitions = value;
2051 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2052 STp->scsi2_logical = value;
2053 if ((options & MT_ST_NOWAIT) != 0)
2054 STp->immediate = value;
2055 if ((options & MT_ST_SYSV) != 0)
2058 if ((options & MT_ST_DEBUGGING) != 0)
2060 st_log_options(STp, STm, name); )
2061 } else if (code == MT_ST_WRITE_THRESHOLD) {
2062 /* Retained for compatibility */
2063 } else if (code == MT_ST_DEF_BLKSIZE) {
2064 value = (options & ~MT_ST_OPTIONS);
2065 if (value == ~MT_ST_OPTIONS) {
2066 STm->default_blksize = (-1);
2067 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2069 STm->default_blksize = value;
2070 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2071 name, STm->default_blksize));
2072 if (STp->ready == ST_READY) {
2073 STp->blksize_changed = 0;
2074 set_mode_densblk(STp, STm);
2077 } else if (code == MT_ST_TIMEOUTS) {
2078 value = (options & ~MT_ST_OPTIONS);
2079 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2080 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2081 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2082 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2084 STp->device->timeout = value * HZ;
2085 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2088 } else if (code == MT_ST_SET_CLN) {
2089 value = (options & ~MT_ST_OPTIONS) & 0xff;
2091 value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2093 STp->cln_mode = value;
2094 STp->cln_sense_mask = (options >> 8) & 0xff;
2095 STp->cln_sense_value = (options >> 16) & 0xff;
2097 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2098 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2099 } else if (code == MT_ST_DEF_OPTIONS) {
2100 code = (options & ~MT_ST_CLEAR_DEFAULT);
2101 value = (options & MT_ST_CLEAR_DEFAULT);
2102 if (code == MT_ST_DEF_DENSITY) {
2103 if (value == MT_ST_CLEAR_DEFAULT) {
2104 STm->default_density = (-1);
2105 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2108 STm->default_density = value & 0xff;
2109 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2110 name, STm->default_density));
2111 if (STp->ready == ST_READY) {
2112 STp->density_changed = 0;
2113 set_mode_densblk(STp, STm);
2116 } else if (code == MT_ST_DEF_DRVBUFFER) {
2117 if (value == MT_ST_CLEAR_DEFAULT) {
2118 STp->default_drvbuffer = 0xff;
2119 DEBC( printk(KERN_INFO
2120 "%s: Drive buffer default disabled.\n", name));
2122 STp->default_drvbuffer = value & 7;
2123 DEBC( printk(KERN_INFO
2124 "%s: Drive buffer default set to %x\n",
2125 name, STp->default_drvbuffer));
2126 if (STp->ready == ST_READY)
2127 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2129 } else if (code == MT_ST_DEF_COMPRESSION) {
2130 if (value == MT_ST_CLEAR_DEFAULT) {
2131 STm->default_compression = ST_DONT_TOUCH;
2132 DEBC( printk(KERN_INFO
2133 "%s: Compression default disabled.\n", name));
2135 if ((value & 0xff00) != 0) {
2136 STp->c_algo = (value & 0xff00) >> 8;
2137 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2138 name, STp->c_algo));
2140 if ((value & 0xff) != 0xff) {
2141 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2142 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2143 name, (value & 1)));
2144 if (STp->ready == ST_READY) {
2145 STp->compression_changed = 0;
2146 st_compression(STp, (STm->default_compression == ST_YES));
2157 #define MODE_HEADER_LENGTH 4
2159 /* Mode header and page byte offsets */
2160 #define MH_OFF_DATA_LENGTH 0
2161 #define MH_OFF_MEDIUM_TYPE 1
2162 #define MH_OFF_DEV_SPECIFIC 2
2163 #define MH_OFF_BDESCS_LENGTH 3
2164 #define MP_OFF_PAGE_NBR 0
2165 #define MP_OFF_PAGE_LENGTH 1
2167 /* Mode header and page bit masks */
2168 #define MH_BIT_WP 0x80
2169 #define MP_MSK_PAGE_NBR 0x3f
2171 /* Don't return block descriptors */
2172 #define MODE_SENSE_OMIT_BDESCS 0x08
2174 #define MODE_SELECT_PAGE_FORMAT 0x10
2176 /* Read a mode page into the tape buffer. The block descriptors are included
2177 if incl_block_descs is true. The page control is ored to the page number
2178 parameter, if necessary. */
2179 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2181 unsigned char cmd[MAX_COMMAND_SIZE];
2182 struct scsi_request *SRpnt = NULL;
2184 memset(cmd, 0, MAX_COMMAND_SIZE);
2185 cmd[0] = MODE_SENSE;
2186 if (omit_block_descs)
2187 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2191 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2192 STp->device->timeout, 0, 1);
2194 return (STp->buffer)->syscall_result;
2196 scsi_release_request(SRpnt);
2198 return (STp->buffer)->syscall_result;
2202 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2203 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2204 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2207 unsigned char cmd[MAX_COMMAND_SIZE];
2208 struct scsi_request *SRpnt = NULL;
2210 memset(cmd, 0, MAX_COMMAND_SIZE);
2211 cmd[0] = MODE_SELECT;
2212 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2213 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2214 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2216 /* Clear reserved fields */
2217 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2218 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2219 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2220 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2222 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE,
2223 (slow ? STp->long_timeout : STp->device->timeout), 0, 1);
2225 return (STp->buffer)->syscall_result;
2227 scsi_release_request(SRpnt);
2229 return (STp->buffer)->syscall_result;
2233 #define COMPRESSION_PAGE 0x0f
2234 #define COMPRESSION_PAGE_LENGTH 16
2236 #define CP_OFF_DCE_DCC 2
2237 #define CP_OFF_C_ALGO 7
2239 #define DCE_MASK 0x80
2240 #define DCC_MASK 0x40
2241 #define RED_MASK 0x60
2244 /* Control the compression with mode page 15. Algorithm not changed if zero.
2246 The block descriptors are read and written because Sony SDT-7000 does not
2247 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2248 Including block descriptors should not cause any harm to other drives. */
2250 static int st_compression(struct scsi_tape * STp, int state)
2253 int mpoffs; /* Offset to mode page start */
2254 unsigned char *b_data = (STp->buffer)->b_data;
2255 DEB( char *name = tape_name(STp); )
2257 if (STp->ready != ST_READY)
2260 /* Read the current page contents */
2261 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2263 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2268 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2269 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2270 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2272 /* Check if compression can be changed */
2273 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2274 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2280 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2281 if (STp->c_algo != 0)
2282 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2285 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2286 if (STp->c_algo != 0)
2287 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2290 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2292 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2295 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2298 STp->compression_changed = 1;
2303 /* Process the load and unload commands (does unload if the load code is zero) */
2304 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2306 int retval = (-EIO), timeout;
2307 DEB( char *name = tape_name(STp); )
2308 unsigned char cmd[MAX_COMMAND_SIZE];
2309 struct st_partstat *STps;
2310 struct scsi_request *SRpnt;
2312 if (STp->ready != ST_READY && !load_code) {
2313 if (STp->ready == ST_NO_TAPE)
2314 return (-ENOMEDIUM);
2319 memset(cmd, 0, MAX_COMMAND_SIZE);
2320 cmd[0] = START_STOP;
2324 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2326 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2327 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2328 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2329 name, (cmd[4]) ? "" : "un",
2330 load_code - MT_ST_HPLOADER_OFFSET));
2331 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2333 if (STp->immediate) {
2334 cmd[1] = 1; /* Don't wait for completion */
2335 timeout = STp->device->timeout;
2338 timeout = STp->long_timeout;
2342 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2344 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2347 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2348 timeout, MAX_RETRIES, 1);
2350 return (STp->buffer)->syscall_result;
2352 retval = (STp->buffer)->syscall_result;
2353 scsi_release_request(SRpnt);
2355 if (!retval) { /* SCSI command successful */
2358 STp->rew_at_close = 0;
2359 STp->ready = ST_NO_TAPE;
2362 STp->rew_at_close = STp->autorew_dev;
2363 retval = check_tape(STp, filp);
2369 STps = &(STp->ps[STp->partition]);
2370 STps->drv_file = STps->drv_block = (-1);
2377 /* Internal ioctl function */
2378 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2384 unsigned char cmd[MAX_COMMAND_SIZE];
2385 struct scsi_request *SRpnt;
2386 struct st_partstat *STps;
2387 int fileno, blkno, at_sm, undone;
2388 int datalen = 0, direction = DMA_NONE;
2389 char *name = tape_name(STp);
2391 WARN_ON(STp->buffer->do_dio != 0);
2392 if (STp->ready != ST_READY) {
2393 if (STp->ready == ST_NO_TAPE)
2394 return (-ENOMEDIUM);
2398 timeout = STp->long_timeout;
2399 STps = &(STp->ps[STp->partition]);
2400 fileno = STps->drv_file;
2401 blkno = STps->drv_block;
2402 at_sm = STps->at_sm;
2404 memset(cmd, 0, MAX_COMMAND_SIZE);
2407 chg_eof = 0; /* Changed from the FSF after this */
2410 cmd[1] = 0x01; /* Space FileMarks */
2411 cmd[2] = (arg >> 16);
2412 cmd[3] = (arg >> 8);
2414 DEBC(printk(ST_DEB_MSG "%s: Spacing tape forward over %d filemarks.\n",
2415 name, cmd[2] * 65536 + cmd[3] * 256 + cmd[4]));
2419 at_sm &= (arg == 0);
2422 chg_eof = 0; /* Changed from the FSF after this */
2425 cmd[1] = 0x01; /* Space FileMarks */
2427 cmd[2] = (ltmp >> 16);
2428 cmd[3] = (ltmp >> 8);
2433 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2435 "%s: Spacing tape backward over %ld filemarks.\n",
2440 blkno = (-1); /* We can't know the block number */
2441 at_sm &= (arg == 0);
2445 cmd[1] = 0x00; /* Space Blocks */
2446 cmd[2] = (arg >> 16);
2447 cmd[3] = (arg >> 8);
2449 DEBC(printk(ST_DEB_MSG "%s: Spacing tape forward %d blocks.\n", name,
2450 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]));
2453 at_sm &= (arg == 0);
2457 cmd[1] = 0x00; /* Space Blocks */
2459 cmd[2] = (ltmp >> 16);
2460 cmd[3] = (ltmp >> 8);
2465 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2467 "%s: Spacing tape backward %ld blocks.\n", name, (-ltmp));
2471 at_sm &= (arg == 0);
2475 cmd[1] = 0x04; /* Space Setmarks */
2476 cmd[2] = (arg >> 16);
2477 cmd[3] = (arg >> 8);
2479 DEBC(printk(ST_DEB_MSG "%s: Spacing tape forward %d setmarks.\n", name,
2480 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]));
2482 blkno = fileno = (-1);
2488 cmd[1] = 0x04; /* Space Setmarks */
2490 cmd[2] = (ltmp >> 16);
2491 cmd[3] = (ltmp >> 8);
2496 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2497 printk(ST_DEB_MSG "%s: Spacing tape backward %ld setmarks.\n",
2501 blkno = fileno = (-1);
2507 if (STp->write_prot)
2509 cmd[0] = WRITE_FILEMARKS;
2510 if (cmd_in == MTWSM)
2512 cmd[2] = (arg >> 16);
2513 cmd[3] = (arg >> 8);
2515 timeout = STp->device->timeout;
2517 if (cmd_in == MTWEOF)
2518 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2519 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2521 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2522 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2527 at_sm = (cmd_in == MTWSM);
2530 cmd[0] = REZERO_UNIT;
2531 if (STp->immediate) {
2532 cmd[1] = 1; /* Don't wait for completion */
2533 timeout = STp->device->timeout;
2535 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2536 fileno = blkno = at_sm = 0;
2539 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2540 return 0; /* Should do something ? */
2543 cmd[0] = START_STOP;
2544 if (STp->immediate) {
2545 cmd[1] = 1; /* Don't wait for completion */
2546 timeout = STp->device->timeout;
2549 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2550 fileno = blkno = at_sm = 0;
2553 if (!STp->fast_mteom) {
2554 /* space to the end of tape */
2555 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2556 fileno = STps->drv_file;
2557 if (STps->eof >= ST_EOD_1)
2559 /* The next lines would hide the number of spaced FileMarks
2560 That's why I inserted the previous lines. I had no luck
2561 with detecting EOM with FSF, so we go now to EOM.
2567 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2573 if (STp->write_prot)
2576 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2577 if (STp->immediate) {
2578 cmd[1] |= 2; /* Don't wait for completion */
2579 timeout = STp->device->timeout;
2582 timeout = STp->long_timeout * 8;
2584 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2585 fileno = blkno = at_sm = 0;
2587 case MTSETBLK: /* Set block length */
2588 case MTSETDENSITY: /* Set tape density */
2589 case MTSETDRVBUFFER: /* Set drive buffering */
2590 case SET_DENS_AND_BLK: /* Set density and block size */
2592 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2593 return (-EIO); /* Not allowed if data in buffer */
2594 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2595 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2596 STp->max_block > 0 &&
2597 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2598 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2599 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2602 cmd[0] = MODE_SELECT;
2603 if ((STp->use_pf & USE_PF))
2604 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2605 cmd[4] = datalen = 12;
2606 direction = DMA_TO_DEVICE;
2608 memset((STp->buffer)->b_data, 0, 12);
2609 if (cmd_in == MTSETDRVBUFFER)
2610 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2612 (STp->buffer)->b_data[2] =
2613 STp->drv_buffer << 4;
2614 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2615 if (cmd_in == MTSETDENSITY) {
2616 (STp->buffer)->b_data[4] = arg;
2617 STp->density_changed = 1; /* At least we tried ;-) */
2618 } else if (cmd_in == SET_DENS_AND_BLK)
2619 (STp->buffer)->b_data[4] = arg >> 24;
2621 (STp->buffer)->b_data[4] = STp->density;
2622 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2623 ltmp = arg & MT_ST_BLKSIZE_MASK;
2624 if (cmd_in == MTSETBLK)
2625 STp->blksize_changed = 1; /* At least we tried ;-) */
2627 ltmp = STp->block_size;
2628 (STp->buffer)->b_data[9] = (ltmp >> 16);
2629 (STp->buffer)->b_data[10] = (ltmp >> 8);
2630 (STp->buffer)->b_data[11] = ltmp;
2631 timeout = STp->device->timeout;
2633 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2635 "%s: Setting block size to %d bytes.\n", name,
2636 (STp->buffer)->b_data[9] * 65536 +
2637 (STp->buffer)->b_data[10] * 256 +
2638 (STp->buffer)->b_data[11]);
2639 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2641 "%s: Setting density code to %x.\n", name,
2642 (STp->buffer)->b_data[4]);
2643 if (cmd_in == MTSETDRVBUFFER)
2645 "%s: Setting drive buffer code to %d.\n", name,
2646 ((STp->buffer)->b_data[2] >> 4) & 7);
2653 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2654 timeout, MAX_RETRIES, 1);
2656 return (STp->buffer)->syscall_result;
2658 ioctl_result = (STp->buffer)->syscall_result;
2660 if (!ioctl_result) { /* SCSI command successful */
2661 scsi_release_request(SRpnt);
2663 STps->drv_block = blkno;
2664 STps->drv_file = fileno;
2665 STps->at_sm = at_sm;
2667 if (cmd_in == MTBSFM)
2668 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2669 else if (cmd_in == MTFSFM)
2670 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2672 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2673 int old_block_size = STp->block_size;
2674 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2675 if (STp->block_size != 0) {
2676 if (old_block_size == 0)
2677 normalize_buffer(STp->buffer);
2678 (STp->buffer)->buffer_blocks =
2679 (STp->buffer)->buffer_size / STp->block_size;
2681 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2682 if (cmd_in == SET_DENS_AND_BLK)
2683 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2684 } else if (cmd_in == MTSETDRVBUFFER)
2685 STp->drv_buffer = (arg & 7);
2686 else if (cmd_in == MTSETDENSITY)
2689 if (cmd_in == MTEOM)
2691 else if (cmd_in == MTFSF)
2694 STps->eof = ST_NOEOF;
2696 } else { /* SCSI command was not completely successful. Don't return
2697 from this block without releasing the SCSI command block! */
2699 if (SRpnt->sr_sense_buffer[2] & 0x40) {
2700 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2701 cmd_in != MTBSR && cmd_in != MTBSS)
2702 STps->eof = ST_EOM_OK;
2703 STps->drv_block = 0;
2706 undone = ((SRpnt->sr_sense_buffer[3] << 24) +
2707 (SRpnt->sr_sense_buffer[4] << 16) +
2708 (SRpnt->sr_sense_buffer[5] << 8) +
2709 SRpnt->sr_sense_buffer[6]);
2711 if (cmd_in == MTWEOF &&
2712 (SRpnt->sr_sense_buffer[0] & 0x70) == 0x70 &&
2713 (SRpnt->sr_sense_buffer[2] & 0x4f) == 0x40 &&
2714 ((SRpnt->sr_sense_buffer[0] & 0x80) == 0 || undone == 0)) {
2715 ioctl_result = 0; /* EOF written succesfully at EOM */
2718 STps->drv_file = fileno;
2719 STps->eof = ST_NOEOF;
2720 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2722 STps->drv_file = fileno - undone;
2724 STps->drv_file = fileno;
2725 STps->drv_block = 0;
2726 STps->eof = ST_NOEOF;
2727 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2728 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2730 if (STps->drv_file >= 0)
2731 STps->drv_file = fileno + undone;
2732 STps->drv_block = 0;
2733 STps->eof = ST_NOEOF;
2734 } else if (cmd_in == MTFSR) {
2735 if (SRpnt->sr_sense_buffer[2] & 0x80) { /* Hit filemark */
2736 if (STps->drv_file >= 0)
2738 STps->drv_block = 0;
2741 if (blkno >= undone)
2742 STps->drv_block = blkno - undone;
2744 STps->drv_block = (-1);
2745 STps->eof = ST_NOEOF;
2747 } else if (cmd_in == MTBSR) {
2748 if (SRpnt->sr_sense_buffer[2] & 0x80) { /* Hit filemark */
2750 STps->drv_block = (-1);
2752 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2754 if (STps->drv_block >= 0)
2755 STps->drv_block = blkno + undone;
2757 STps->eof = ST_NOEOF;
2758 } else if (cmd_in == MTEOM) {
2759 STps->drv_file = (-1);
2760 STps->drv_block = (-1);
2762 } else if (cmd_in == MTSETBLK ||
2763 cmd_in == MTSETDENSITY ||
2764 cmd_in == MTSETDRVBUFFER ||
2765 cmd_in == SET_DENS_AND_BLK) {
2766 if ((SRpnt->sr_sense_buffer[2] & 0x0f) == ILLEGAL_REQUEST &&
2767 !(STp->use_pf & PF_TESTED)) {
2768 /* Try the other possible state of Page Format if not
2770 STp->use_pf = !STp->use_pf | PF_TESTED;
2771 scsi_release_request(SRpnt);
2773 return st_int_ioctl(STp, cmd_in, arg);
2776 STps->eof = ST_NOEOF;
2778 if ((SRpnt->sr_sense_buffer[2] & 0x0f) == BLANK_CHECK)
2781 scsi_release_request(SRpnt);
2785 return ioctl_result;
2789 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2792 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2796 unsigned char scmd[MAX_COMMAND_SIZE];
2797 struct scsi_request *SRpnt;
2798 DEB( char *name = tape_name(STp); )
2800 if (STp->ready != ST_READY)
2803 memset(scmd, 0, MAX_COMMAND_SIZE);
2804 if ((STp->device)->scsi_level < SCSI_2) {
2805 scmd[0] = QFA_REQUEST_BLOCK;
2808 scmd[0] = READ_POSITION;
2809 if (!logical && !STp->scsi2_logical)
2812 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
2813 STp->device->timeout, MAX_READY_RETRIES, 1);
2815 return (STp->buffer)->syscall_result;
2817 if ((STp->buffer)->syscall_result != 0 ||
2818 (STp->device->scsi_level >= SCSI_2 &&
2819 ((STp->buffer)->b_data[0] & 4) != 0)) {
2820 *block = *partition = 0;
2821 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
2825 if ((STp->device)->scsi_level < SCSI_2) {
2826 *block = ((STp->buffer)->b_data[0] << 16)
2827 + ((STp->buffer)->b_data[1] << 8)
2828 + (STp->buffer)->b_data[2];
2831 *block = ((STp->buffer)->b_data[4] << 24)
2832 + ((STp->buffer)->b_data[5] << 16)
2833 + ((STp->buffer)->b_data[6] << 8)
2834 + (STp->buffer)->b_data[7];
2835 *partition = (STp->buffer)->b_data[1];
2836 if (((STp->buffer)->b_data[0] & 0x80) &&
2837 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
2838 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
2840 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
2841 *block, *partition));
2843 scsi_release_request(SRpnt);
2850 /* Set the tape block and partition. Negative partition means that only the
2851 block should be set in vendor specific way. */
2852 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
2855 struct st_partstat *STps;
2859 unsigned char scmd[MAX_COMMAND_SIZE];
2860 struct scsi_request *SRpnt;
2861 DEB( char *name = tape_name(STp); )
2863 if (STp->ready != ST_READY)
2865 timeout = STp->long_timeout;
2866 STps = &(STp->ps[STp->partition]);
2868 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
2869 name, block, partition));
2870 DEB(if (partition < 0)
2873 /* Update the location at the partition we are leaving */
2874 if ((!STp->can_partitions && partition != 0) ||
2875 partition >= ST_NBR_PARTITIONS)
2877 if (partition != STp->partition) {
2878 if (get_location(STp, &blk, &p, 1))
2879 STps->last_block_valid = 0;
2881 STps->last_block_valid = 1;
2882 STps->last_block_visited = blk;
2883 DEBC(printk(ST_DEB_MSG
2884 "%s: Visited block %d for partition %d saved.\n",
2885 name, blk, STp->partition));
2889 memset(scmd, 0, MAX_COMMAND_SIZE);
2890 if ((STp->device)->scsi_level < SCSI_2) {
2891 scmd[0] = QFA_SEEK_BLOCK;
2892 scmd[2] = (block >> 16);
2893 scmd[3] = (block >> 8);
2898 scmd[3] = (block >> 24);
2899 scmd[4] = (block >> 16);
2900 scmd[5] = (block >> 8);
2902 if (!logical && !STp->scsi2_logical)
2904 if (STp->partition != partition) {
2906 scmd[8] = partition;
2907 DEBC(printk(ST_DEB_MSG
2908 "%s: Trying to change partition from %d to %d\n",
2909 name, STp->partition, partition));
2912 if (STp->immediate) {
2913 scmd[1] |= 1; /* Don't wait for completion */
2914 timeout = STp->device->timeout;
2917 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
2918 timeout, MAX_READY_RETRIES, 1);
2920 return (STp->buffer)->syscall_result;
2922 STps->drv_block = STps->drv_file = (-1);
2923 STps->eof = ST_NOEOF;
2924 if ((STp->buffer)->syscall_result != 0) {
2926 if (STp->can_partitions &&
2927 (STp->device)->scsi_level >= SCSI_2 &&
2928 (p = find_partition(STp)) >= 0)
2931 if (STp->can_partitions) {
2932 STp->partition = partition;
2933 STps = &(STp->ps[partition]);
2934 if (!STps->last_block_valid ||
2935 STps->last_block_visited != block) {
2942 STps->drv_block = STps->drv_file = 0;
2946 scsi_release_request(SRpnt);
2953 /* Find the current partition number for the drive status. Called from open and
2954 returns either partition number of negative error code. */
2955 static int find_partition(struct scsi_tape *STp)
2960 if ((i = get_location(STp, &block, &partition, 1)) < 0)
2962 if (partition >= ST_NBR_PARTITIONS)
2968 /* Change the partition if necessary */
2969 static int switch_partition(struct scsi_tape *STp)
2971 struct st_partstat *STps;
2973 if (STp->partition == STp->new_partition)
2975 STps = &(STp->ps[STp->new_partition]);
2976 if (!STps->last_block_valid)
2977 STps->last_block_visited = 0;
2978 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
2981 /* Functions for reading and writing the medium partition mode page. */
2983 #define PART_PAGE 0x11
2984 #define PART_PAGE_FIXED_LENGTH 8
2986 #define PP_OFF_MAX_ADD_PARTS 2
2987 #define PP_OFF_NBR_ADD_PARTS 3
2988 #define PP_OFF_FLAGS 4
2989 #define PP_OFF_PART_UNITS 6
2990 #define PP_OFF_RESERVED 7
2992 #define PP_BIT_IDP 0x20
2993 #define PP_MSK_PSUM_MB 0x10
2995 /* Get the number of partitions on the tape. As a side effect reads the
2996 mode page into the tape buffer. */
2997 static int nbr_partitions(struct scsi_tape *STp)
3000 DEB( char *name = tape_name(STp); )
3002 if (STp->ready != ST_READY)
3005 result = read_mode_page(STp, PART_PAGE, 1);
3008 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3012 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3013 PP_OFF_NBR_ADD_PARTS] + 1;
3014 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3021 /* Partition the tape into two partitions if size > 0 or one partition if
3024 The block descriptors are read and written because Sony SDT-7000 does not
3025 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3027 My HP C1533A drive returns only one partition size field. This is used to
3028 set the size of partition 1. There is no size field for the default partition.
3029 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3030 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3031 The following algorithm is used to accommodate both drives: if the number of
3032 partition size fields is greater than the maximum number of additional partitions
3033 in the mode page, the second field is used. Otherwise the first field is used.
3035 For Seagate DDS drives the page length must be 8 when no partitions is defined
3036 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3037 is acceptable also to some other old drives and enforced if the first partition
3038 size field is used for the first additional partition size.
3040 static int partition_tape(struct scsi_tape *STp, int size)
3042 char *name = tape_name(STp);
3044 int pgo, psd_cnt, psdo;
3047 result = read_mode_page(STp, PART_PAGE, 0);
3049 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3052 /* The mode page is in the buffer. Let's modify it and write it. */
3053 bp = (STp->buffer)->b_data;
3054 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3055 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3056 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3058 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3059 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3060 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3061 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3064 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3066 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3067 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3068 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3071 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3072 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3073 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3074 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3077 bp[psdo] = (size >> 8) & 0xff;
3078 bp[psdo + 1] = size & 0xff;
3080 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3081 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3082 DEBC(printk(ST_DEB_MSG
3083 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3086 bp[pgo + PP_OFF_PART_UNITS] = 0;
3087 bp[pgo + PP_OFF_RESERVED] = 0;
3088 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3090 result = write_mode_page(STp, PART_PAGE, 1);
3092 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3101 /* The ioctl command */
3102 static int st_ioctl(struct inode *inode, struct file *file,
3103 unsigned int cmd_in, unsigned long arg)
3105 int i, cmd_nr, cmd_type, bt;
3108 struct scsi_tape *STp = file->private_data;
3109 struct st_modedef *STm;
3110 struct st_partstat *STps;
3111 char *name = tape_name(STp);
3112 void __user *p = (void __user *)arg;
3114 if (down_interruptible(&STp->lock))
3115 return -ERESTARTSYS;
3118 if (debugging && !STp->in_use) {
3119 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3124 STm = &(STp->modes[STp->current_mode]);
3125 STps = &(STp->ps[STp->partition]);
3128 * If we are in the middle of error recovery, don't let anyone
3129 * else try and use this device. Also, if error recovery fails, it
3130 * may try and take the device offline, in which case all further
3131 * access to the device is prohibited.
3133 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p, file);
3134 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3138 cmd_type = _IOC_TYPE(cmd_in);
3139 cmd_nr = _IOC_NR(cmd_in);
3141 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3144 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3149 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3155 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3157 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3161 if (!STm->defined &&
3162 (mtc.mt_op != MTSETDRVBUFFER &&
3163 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3168 if (!STp->pos_unknown) {
3170 if (STps->eof == ST_FM_HIT) {
3171 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3172 mtc.mt_op == MTEOM) {
3174 if (STps->drv_file >= 0)
3175 STps->drv_file += 1;
3176 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3178 if (STps->drv_file >= 0)
3179 STps->drv_file += 1;
3183 if (mtc.mt_op == MTSEEK) {
3184 /* Old position must be restored if partition will be
3186 i = !STp->can_partitions ||
3187 (STp->new_partition != STp->partition);
3189 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3190 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3191 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3192 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3193 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3194 mtc.mt_op == MTCOMPRESSION;
3196 i = flush_buffer(STp, i);
3203 * If there was a bus reset, block further access
3204 * to this device. If the user wants to rewind the tape,
3205 * then reset the flag and allow access again.
3207 if (mtc.mt_op != MTREW &&
3208 mtc.mt_op != MTOFFL &&
3209 mtc.mt_op != MTRETEN &&
3210 mtc.mt_op != MTERASE &&
3211 mtc.mt_op != MTSEEK &&
3212 mtc.mt_op != MTEOM) {
3217 /* remove this when the midlevel properly clears was_reset */
3218 STp->device->was_reset = 0;
3221 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3222 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3223 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3224 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3226 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3227 do_door_lock(STp, 0); /* Ignore result! */
3229 if (mtc.mt_op == MTSETDRVBUFFER &&
3230 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3231 retval = st_set_options(STp, mtc.mt_count);
3235 if (mtc.mt_op == MTSETPART) {
3236 if (!STp->can_partitions ||
3237 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3241 if (mtc.mt_count >= STp->nbr_partitions &&
3242 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3246 if (mtc.mt_count >= STp->nbr_partitions) {
3250 STp->new_partition = mtc.mt_count;
3255 if (mtc.mt_op == MTMKPART) {
3256 if (!STp->can_partitions) {
3260 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3261 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3265 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3266 STp->ps[i].rw = ST_IDLE;
3267 STp->ps[i].at_sm = 0;
3268 STp->ps[i].last_block_valid = 0;
3270 STp->partition = STp->new_partition = 0;
3271 STp->nbr_partitions = 1; /* Bad guess ?-) */
3272 STps->drv_block = STps->drv_file = 0;
3277 if (mtc.mt_op == MTSEEK) {
3278 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3279 if (!STp->can_partitions)
3280 STp->ps[0].rw = ST_IDLE;
3285 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3286 retval = do_load_unload(STp, file, 0);
3290 if (mtc.mt_op == MTLOAD) {
3291 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3295 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3296 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3300 if (STp->can_partitions && STp->ready == ST_READY &&
3301 (i = switch_partition(STp)) < 0) {
3306 if (mtc.mt_op == MTCOMPRESSION)
3307 retval = st_compression(STp, (mtc.mt_count & 1));
3309 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3312 if (!STm->defined) {
3317 if ((i = flush_buffer(STp, 0)) < 0) {
3321 if (STp->can_partitions &&
3322 (i = switch_partition(STp)) < 0) {
3327 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3328 struct mtget mt_status;
3330 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3335 mt_status.mt_type = STp->tape_type;
3336 mt_status.mt_dsreg =
3337 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3338 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3339 mt_status.mt_blkno = STps->drv_block;
3340 mt_status.mt_fileno = STps->drv_file;
3341 if (STp->block_size != 0) {
3342 if (STps->rw == ST_WRITING)
3343 mt_status.mt_blkno +=
3344 (STp->buffer)->buffer_bytes / STp->block_size;
3345 else if (STps->rw == ST_READING)
3346 mt_status.mt_blkno -=
3347 ((STp->buffer)->buffer_bytes +
3348 STp->block_size - 1) / STp->block_size;
3351 mt_status.mt_gstat = 0;
3352 if (STp->drv_write_prot)
3353 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3354 if (mt_status.mt_blkno == 0) {
3355 if (mt_status.mt_fileno == 0)
3356 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3358 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3360 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3361 mt_status.mt_resid = STp->partition;
3362 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3363 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3364 else if (STps->eof >= ST_EOM_OK)
3365 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3366 if (STp->density == 1)
3367 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3368 else if (STp->density == 2)
3369 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3370 else if (STp->density == 3)
3371 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3372 if (STp->ready == ST_READY)
3373 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3374 if (STp->ready == ST_NO_TAPE)
3375 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3377 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3378 if (STm->do_async_writes ||
3379 (STm->do_buffer_writes && STp->block_size != 0) ||
3380 STp->drv_buffer != 0)
3381 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3382 if (STp->cleaning_req)
3383 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3385 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3391 STp->recover_reg = 0; /* Clear after read */
3394 } /* End of MTIOCGET */
3395 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3396 struct mtpos mt_pos;
3397 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3401 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3405 mt_pos.mt_blkno = blk;
3406 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3413 case SCSI_IOCTL_GET_IDLUN:
3414 case SCSI_IOCTL_GET_BUS_NUMBER:
3417 i = scsi_cmd_ioctl(file, STp->disk, cmd_in, p);
3422 return scsi_ioctl(STp->device, cmd_in, p);
3430 /* Try to allocate a new tape buffer. Calling function must not hold
3432 static struct st_buffer *
3433 new_tape_buffer(int from_initialization, int need_dma, int max_sg)
3435 int i, priority, got = 0, segs = 0;
3436 struct st_buffer *tb;
3438 if (from_initialization)
3439 priority = GFP_ATOMIC;
3441 priority = GFP_KERNEL;
3443 i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3444 max_sg * sizeof(struct st_buf_fragment);
3445 tb = kmalloc(i, priority);
3447 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3451 tb->frp_segs = tb->orig_frp_segs = segs;
3452 tb->use_sg = max_sg;
3454 tb->b_data = page_address(tb->sg[0].page);
3455 tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
3459 tb->buffer_size = got;
3465 /* Try to allocate enough space in the tape buffer */
3466 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3468 int segs, nbr, max_segs, b_size, priority, order, got;
3470 if (new_size <= STbuffer->buffer_size)
3473 if (STbuffer->buffer_size <= PAGE_SIZE)
3474 normalize_buffer(STbuffer); /* Avoid extra segment */
3476 max_segs = STbuffer->use_sg;
3477 nbr = max_segs - STbuffer->frp_segs;
3481 priority = GFP_KERNEL | __GFP_NOWARN;
3483 priority |= GFP_DMA;
3484 for (b_size = PAGE_SIZE, order=0;
3485 b_size < new_size - STbuffer->buffer_size;
3486 order++, b_size *= 2)
3489 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3490 segs < max_segs && got < new_size;) {
3491 STbuffer->frp[segs].page = alloc_pages(priority, order);
3492 if (STbuffer->frp[segs].page == NULL) {
3493 if (new_size - got <= (max_segs - segs) * b_size / 2) {
3494 b_size /= 2; /* Large enough for the rest of the buffers */
3498 DEB(STbuffer->buffer_size = got);
3499 normalize_buffer(STbuffer);
3502 STbuffer->frp[segs].length = b_size;
3503 STbuffer->frp_segs += 1;
3505 STbuffer->buffer_size = got;
3508 STbuffer->b_data = page_address(STbuffer->frp[0].page);
3514 /* Release the extra buffer */
3515 static void normalize_buffer(struct st_buffer * STbuffer)
3519 for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3520 order = get_order(STbuffer->frp[i].length);
3521 __free_pages(STbuffer->frp[i].page, order);
3522 STbuffer->buffer_size -= STbuffer->frp[i].length;
3524 STbuffer->frp_segs = STbuffer->orig_frp_segs;
3525 STbuffer->frp_sg_current = 0;
3529 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3530 negative error code. */
3531 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3533 int i, cnt, res, offset;
3535 for (i = 0, offset = st_bp->buffer_bytes;
3536 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3537 offset -= st_bp->frp[i].length;
3538 if (i == st_bp->frp_segs) { /* Should never happen */
3539 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3542 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3543 cnt = st_bp->frp[i].length - offset < do_count ?
3544 st_bp->frp[i].length - offset : do_count;
3545 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3549 st_bp->buffer_bytes += cnt;
3553 if (do_count) /* Should never happen */
3560 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3561 negative error code. */
3562 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3564 int i, cnt, res, offset;
3566 for (i = 0, offset = st_bp->read_pointer;
3567 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3568 offset -= st_bp->frp[i].length;
3569 if (i == st_bp->frp_segs) { /* Should never happen */
3570 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3573 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3574 cnt = st_bp->frp[i].length - offset < do_count ?
3575 st_bp->frp[i].length - offset : do_count;
3576 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3580 st_bp->buffer_bytes -= cnt;
3581 st_bp->read_pointer += cnt;
3585 if (do_count) /* Should never happen */
3592 /* Move data towards start of buffer */
3593 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3595 int src_seg, dst_seg, src_offset = 0, dst_offset;
3601 total=st_bp->buffer_bytes - offset;
3602 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3603 src_offset = offset;
3604 if (src_offset < st_bp->frp[src_seg].length)
3606 offset -= st_bp->frp[src_seg].length;
3609 st_bp->buffer_bytes = st_bp->read_pointer = total;
3610 for (dst_seg=dst_offset=0; total > 0; ) {
3611 count = min(st_bp->frp[dst_seg].length - dst_offset,
3612 st_bp->frp[src_seg].length - src_offset);
3613 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3614 page_address(st_bp->frp[src_seg].page) + src_offset, count);
3615 src_offset += count;
3616 if (src_offset >= st_bp->frp[src_seg].length) {
3620 dst_offset += count;
3621 if (dst_offset >= st_bp->frp[dst_seg].length) {
3630 /* Fill the s/g list up to the length required for this transfer */
3631 static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
3635 struct scatterlist *sg;
3636 struct st_buf_fragment *frp;
3638 if (length == STbp->frp_sg_current)
3639 return; /* work already done */
3641 sg = &(STbp->sg[0]);
3643 for (i=count=0; count < length; i++) {
3644 sg[i].page = frp[i].page;
3645 if (length - count > frp[i].length)
3646 sg[i].length = frp[i].length;
3648 sg[i].length = length - count;
3649 count += sg[i].length;
3653 STbp->frp_sg_current = length;
3657 /* Validate the options from command line or module parameters */
3658 static void validate_options(void)
3661 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3662 if (max_sg_segs >= ST_FIRST_SG)
3663 st_max_sg_segs = max_sg_segs;
3667 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3669 static int __init st_setup(char *str)
3671 int i, len, ints[5];
3674 stp = get_options(str, ARRAY_SIZE(ints), ints);
3677 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3679 *parms[i].val = ints[i + 1];
3681 while (stp != NULL) {
3682 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3683 len = strlen(parms[i].name);
3684 if (!strncmp(stp, parms[i].name, len) &&
3685 (*(stp + len) == ':' || *(stp + len) == '=')) {
3688 simple_strtoul(stp + len + 1, NULL, 0);
3690 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3695 if (i >= sizeof(parms) / sizeof(struct st_dev_parm))
3696 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3698 stp = strchr(stp, ',');
3709 __setup("st=", st_setup);
3713 static struct file_operations st_fops =
3715 .owner = THIS_MODULE,
3721 .release = st_release,
3724 static int st_probe(struct device *dev)
3726 struct scsi_device *SDp = to_scsi_device(dev);
3727 struct gendisk *disk = NULL;
3728 struct cdev *cdev = NULL;
3729 struct scsi_tape *tpnt = NULL;
3730 struct st_modedef *STm;
3731 struct st_partstat *STps;
3732 struct st_buffer *buffer;
3733 int i, j, mode, dev_num, error;
3737 if (SDp->type != TYPE_TAPE)
3739 if ((stp = st_incompatible(SDp))) {
3741 "st: Found incompatible tape at scsi%d, channel %d, id %d, lun %d\n",
3742 SDp->host->host_no, SDp->channel, SDp->id, SDp->lun);
3743 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3747 i = SDp->host->sg_tablesize;
3748 if (st_max_sg_segs < i)
3750 buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i);
3751 if (buffer == NULL) {
3753 "st: Can't allocate new tape buffer. Device not attached.\n");
3757 disk = alloc_disk(1);
3759 printk(KERN_ERR "st: out of memory. Device not attached.\n");
3760 goto out_buffer_free;
3763 write_lock(&st_dev_arr_lock);
3764 if (st_nr_dev >= st_dev_max) {
3765 struct scsi_tape **tmp_da;
3768 tmp_dev_max = max(st_nr_dev * 2, 8);
3769 if (tmp_dev_max > ST_MAX_TAPES)
3770 tmp_dev_max = ST_MAX_TAPES;
3771 if (tmp_dev_max <= st_nr_dev) {
3772 write_unlock(&st_dev_arr_lock);
3773 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
3778 tmp_da = kmalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
3779 if (tmp_da == NULL) {
3780 write_unlock(&st_dev_arr_lock);
3781 printk(KERN_ERR "st: Can't extend device array.\n");
3785 memset(tmp_da, 0, tmp_dev_max * sizeof(struct scsi_tape *));
3786 if (scsi_tapes != NULL) {
3787 memcpy(tmp_da, scsi_tapes,
3788 st_dev_max * sizeof(struct scsi_tape *));
3791 scsi_tapes = tmp_da;
3793 st_dev_max = tmp_dev_max;
3796 for (i = 0; i < st_dev_max; i++)
3797 if (scsi_tapes[i] == NULL)
3799 if (i >= st_dev_max)
3800 panic("scsi_devices corrupt (st)");
3802 tpnt = kmalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
3804 write_unlock(&st_dev_arr_lock);
3805 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
3808 memset(tpnt, 0, sizeof(struct scsi_tape));
3810 sprintf(disk->disk_name, "st%d", i);
3811 disk->private_data = &tpnt->driver;
3812 disk->queue = SDp->request_queue;
3813 tpnt->driver = &st_template;
3814 scsi_tapes[i] = tpnt;
3818 if (SDp->scsi_level <= 2)
3819 tpnt->tape_type = MT_ISSCSI1;
3821 tpnt->tape_type = MT_ISSCSI2;
3823 tpnt->buffer = buffer;
3828 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
3829 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
3830 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
3832 tpnt->do_auto_lock = ST_AUTO_LOCK;
3833 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
3834 tpnt->can_partitions = 0;
3835 tpnt->two_fm = ST_TWO_FM;
3836 tpnt->fast_mteom = ST_FAST_MTEOM;
3837 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
3838 tpnt->immediate = ST_NOWAIT;
3839 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
3840 tpnt->partition = 0;
3841 tpnt->new_partition = 0;
3842 tpnt->nbr_partitions = 0;
3843 tpnt->device->timeout = ST_TIMEOUT;
3844 tpnt->long_timeout = ST_LONG_TIMEOUT;
3845 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
3847 bounce_limit = scsi_calculate_bounce_limit(SDp->host) >> PAGE_SHIFT;
3848 if (bounce_limit > ULONG_MAX)
3849 bounce_limit = ULONG_MAX;
3850 tpnt->max_pfn = bounce_limit;
3852 for (i = 0; i < ST_NBR_MODES; i++) {
3853 STm = &(tpnt->modes[i]);
3855 STm->sysv = ST_SYSV;
3856 STm->defaults_for_writes = 0;
3857 STm->do_async_writes = ST_ASYNC_WRITES;
3858 STm->do_buffer_writes = ST_BUFFER_WRITES;
3859 STm->do_read_ahead = ST_READ_AHEAD;
3860 STm->default_compression = ST_DONT_TOUCH;
3861 STm->default_blksize = (-1); /* No forced size */
3862 STm->default_density = (-1); /* No forced density */
3865 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3866 STps = &(tpnt->ps[i]);
3868 STps->eof = ST_NOEOF;
3870 STps->last_block_valid = 0;
3871 STps->drv_block = (-1);
3872 STps->drv_file = (-1);
3875 tpnt->current_mode = 0;
3876 tpnt->modes[0].defined = 1;
3878 tpnt->density_changed = tpnt->compression_changed =
3879 tpnt->blksize_changed = 0;
3880 init_MUTEX(&tpnt->lock);
3883 write_unlock(&st_dev_arr_lock);
3885 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
3886 STm = &(tpnt->modes[mode]);
3887 for (j=0; j < 2; j++) {
3888 cdev = cdev_alloc();
3891 "st%d: out of memory. Device not attached.\n",
3895 cdev->owner = THIS_MODULE;
3896 cdev->ops = &st_fops;
3898 error = cdev_add(cdev,
3899 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
3902 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
3903 dev_num, j ? "non" : "auto", mode);
3904 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
3907 STm->cdevs[j] = cdev;
3910 do_create_class_files(tpnt, dev_num, mode);
3913 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
3914 /* Make sure that the minor numbers corresponding to the four
3915 first modes always get the same names */
3916 i = mode << (4 - ST_NBR_MODE_BITS);
3918 devfs_mk_cdev(MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, 0)),
3919 S_IFCHR | S_IRUGO | S_IWUGO,
3920 "%s/mt%s", SDp->devfs_name, st_formats[i]);
3921 /* No-rewind entry */
3922 devfs_mk_cdev(MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, 1)),
3923 S_IFCHR | S_IRUGO | S_IWUGO,
3924 "%s/mt%sn", SDp->devfs_name, st_formats[i]);
3926 disk->number = devfs_register_tape(SDp->devfs_name);
3929 "Attached scsi tape %s at scsi%d, channel %d, id %d, lun %d\n",
3930 tape_name(tpnt), SDp->host->host_no, SDp->channel, SDp->id, SDp->lun);
3931 printk(KERN_WARNING "%s: try direct i/o: %s (alignment %d B), max page reachable by HBA %lu\n",
3932 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
3933 queue_dma_alignment(SDp->request_queue) + 1, tpnt->max_pfn);
3938 for (mode=0; mode < ST_NBR_MODES; mode++) {
3939 STm = &(tpnt->modes[mode]);
3940 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
3942 for (j=0; j < 2; j++) {
3943 if (STm->cdevs[j]) {
3944 if (cdev == STm->cdevs[j])
3946 class_simple_device_remove(MKDEV(SCSI_TAPE_MAJOR,
3947 TAPE_MINOR(i, mode, j)));
3948 cdev_del(STm->cdevs[j]);
3954 write_lock(&st_dev_arr_lock);
3955 scsi_tapes[dev_num] = NULL;
3957 write_unlock(&st_dev_arr_lock);
3969 static int st_remove(struct device *dev)
3971 struct scsi_device *SDp = to_scsi_device(dev);
3972 struct scsi_tape *tpnt;
3975 write_lock(&st_dev_arr_lock);
3976 for (i = 0; i < st_dev_max; i++) {
3977 tpnt = scsi_tapes[i];
3978 if (tpnt != NULL && tpnt->device == SDp) {
3979 scsi_tapes[i] = NULL;
3981 write_unlock(&st_dev_arr_lock);
3982 devfs_unregister_tape(tpnt->disk->number);
3983 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
3985 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
3986 j = mode << (4 - ST_NBR_MODE_BITS);
3987 devfs_remove("%s/mt%s", SDp->devfs_name, st_formats[j]);
3988 devfs_remove("%s/mt%sn", SDp->devfs_name, st_formats[j]);
3989 for (j=0; j < 2; j++) {
3990 class_simple_device_remove(MKDEV(SCSI_TAPE_MAJOR,
3991 TAPE_MINOR(i, mode, j)));
3992 cdev_del(tpnt->modes[mode].cdevs[j]);
3993 tpnt->modes[mode].cdevs[j] = NULL;
3996 tpnt->device = NULL;
3999 tpnt->buffer->orig_frp_segs = 0;
4000 normalize_buffer(tpnt->buffer);
4001 kfree(tpnt->buffer);
4003 put_disk(tpnt->disk);
4009 write_unlock(&st_dev_arr_lock);
4013 static void st_intr(struct scsi_cmnd *SCpnt)
4015 scsi_io_completion(SCpnt, (SCpnt->result ? 0: SCpnt->bufflen), 1);
4019 * st_init_command: only called via the scsi_cmd_ioctl (block SG_IO)
4020 * interface for REQ_BLOCK_PC commands.
4022 static int st_init_command(struct scsi_cmnd *SCpnt)
4026 if (!(SCpnt->request->flags & REQ_BLOCK_PC))
4029 rq = SCpnt->request;
4030 if (sizeof(rq->cmd) > sizeof(SCpnt->cmnd))
4033 memcpy(SCpnt->cmnd, rq->cmd, sizeof(SCpnt->cmnd));
4035 if (rq_data_dir(rq) == WRITE)
4036 SCpnt->sc_data_direction = DMA_TO_DEVICE;
4037 else if (rq->data_len)
4038 SCpnt->sc_data_direction = DMA_FROM_DEVICE;
4040 SCpnt->sc_data_direction = DMA_NONE;
4042 SCpnt->timeout_per_command = rq->timeout;
4043 SCpnt->transfersize = rq->data_len;
4044 SCpnt->done = st_intr;
4048 static int __init init_st(void)
4053 "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4054 verstr, st_fixed_buffer_size, st_max_sg_segs);
4056 st_sysfs_class = class_simple_create(THIS_MODULE, "scsi_tape");
4057 if (IS_ERR(st_sysfs_class)) {
4058 st_sysfs_class = NULL;
4059 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4063 if (!register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4064 ST_MAX_TAPE_ENTRIES, "st")) {
4065 if (scsi_register_driver(&st_template.gendrv) == 0) {
4066 do_create_driverfs_files();
4070 class_simple_destroy(st_sysfs_class);
4071 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4073 ST_MAX_TAPE_ENTRIES);
4076 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n", SCSI_TAPE_MAJOR);
4080 static void __exit exit_st(void)
4083 class_simple_destroy(st_sysfs_class);
4084 st_sysfs_class = NULL;
4085 do_remove_driverfs_files();
4086 scsi_unregister_driver(&st_template.gendrv);
4087 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4088 ST_MAX_TAPE_ENTRIES);
4090 printk(KERN_INFO "st: Unloaded.\n");
4093 module_init(init_st);
4094 module_exit(exit_st);
4097 /* The sysfs driver interface. Read-only at the moment */
4098 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4100 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4102 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4104 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4106 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4108 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4110 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4112 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4114 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4116 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4118 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4120 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4122 static void do_create_driverfs_files(void)
4124 struct device_driver *driverfs = &st_template.gendrv;
4126 driver_create_file(driverfs, &driver_attr_try_direct_io);
4127 driver_create_file(driverfs, &driver_attr_fixed_buffer_size);
4128 driver_create_file(driverfs, &driver_attr_max_sg_segs);
4129 driver_create_file(driverfs, &driver_attr_version);
4132 static void do_remove_driverfs_files(void)
4134 struct device_driver *driverfs = &st_template.gendrv;
4136 driver_remove_file(driverfs, &driver_attr_version);
4137 driver_remove_file(driverfs, &driver_attr_max_sg_segs);
4138 driver_remove_file(driverfs, &driver_attr_fixed_buffer_size);
4139 driver_remove_file(driverfs, &driver_attr_try_direct_io);
4143 /* The sysfs simple class interface */
4144 static ssize_t st_defined_show(struct class_device *class_dev, char *buf)
4146 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4149 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4153 CLASS_DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4155 static ssize_t st_defblk_show(struct class_device *class_dev, char *buf)
4157 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4160 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4164 CLASS_DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4166 static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf)
4168 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4172 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4173 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4177 CLASS_DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4179 static ssize_t st_defcompression_show(struct class_device *class_dev, char *buf)
4181 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4184 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4188 CLASS_DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4190 static void do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4194 struct class_device *st_class_member;
4196 if (!st_sysfs_class)
4199 for (rew=0; rew < 2; rew++) {
4200 /* Make sure that the minor numbers corresponding to the four
4201 first modes always get the same names */
4202 i = mode << (4 - ST_NBR_MODE_BITS);
4203 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4204 STp->disk->disk_name, st_formats[i]);
4206 class_simple_device_add(st_sysfs_class,
4207 MKDEV(SCSI_TAPE_MAJOR,
4208 TAPE_MINOR(dev_num, mode, rew)),
4209 &STp->device->sdev_gendev, "%s", name);
4210 if (IS_ERR(st_class_member)) {
4211 printk(KERN_WARNING "st%d: class_simple_device_add failed\n",
4215 class_set_devdata(st_class_member, &STp->modes[mode]);
4217 class_device_create_file(st_class_member,
4218 &class_device_attr_defined);
4219 class_device_create_file(st_class_member,
4220 &class_device_attr_default_blksize);
4221 class_device_create_file(st_class_member,
4222 &class_device_attr_default_density);
4223 class_device_create_file(st_class_member,
4224 &class_device_attr_default_compression);
4225 if (mode == 0 && rew == 0) {
4226 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4227 &st_class_member->kobj,
4231 "st%d: Can't create sysfs link from SCSI device.\n",
4241 /* Pin down user pages and put them into a scatter gather list. Returns <= 0 if
4242 - mapping of all pages not successful
4243 - any page is above max_pfn
4244 (i.e., either completely successful or fails)
4246 static int st_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4247 unsigned long uaddr, size_t count, int rw,
4248 unsigned long max_pfn)
4252 nr_pages = sgl_map_user_pages(sgl, max_pages, uaddr, count, rw);
4256 for (i=0; i < nr_pages; i++) {
4257 if (page_to_pfn(sgl[i].page) > max_pfn)
4263 sgl_unmap_user_pages(sgl, nr_pages, 0);
4268 /* The following functions may be useful for a larger audience. */
4269 static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4270 unsigned long uaddr, size_t count, int rw)
4273 unsigned int nr_pages;
4274 struct page **pages;
4276 nr_pages = ((uaddr & ~PAGE_MASK) + count + ~PAGE_MASK) >> PAGE_SHIFT;
4278 /* User attempted Overflow! */
4279 if ((uaddr + count) < uaddr)
4283 if (nr_pages > max_pages)
4290 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4293 /* Try to fault in all of the necessary pages */
4294 down_read(¤t->mm->mmap_sem);
4295 /* rw==READ means read from drive, write into memory area */
4296 res = get_user_pages(
4302 0, /* don't force */
4305 up_read(¤t->mm->mmap_sem);
4307 /* Errors and no page mapped should return here */
4311 for (i=0; i < nr_pages; i++) {
4312 /* FIXME: flush superflous for rw==READ,
4313 * probably wrong function for rw==WRITE
4315 flush_dcache_page(pages[i]);
4318 /* Populate the scatter/gather list */
4319 sgl[0].page = pages[0];
4320 sgl[0].offset = uaddr & ~PAGE_MASK;
4322 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4323 count -= sgl[0].length;
4324 for (i=1; i < nr_pages ; i++) {
4326 sgl[i].page = pages[i];
4327 sgl[i].length = count < PAGE_SIZE ? count : PAGE_SIZE;
4332 sgl[0].length = count;
4340 for (j=0; j < res; j++)
4341 page_cache_release(pages[j]);
4348 /* And unmap them... */
4349 static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4354 for (i=0; i < nr_pages; i++) {
4355 if (dirtied && !PageReserved(sgl[i].page))
4356 SetPageDirty(sgl[i].page);
4357 /* FIXME: cache flush missing for rw==READ
4358 * FIXME: call the correct reference counting function
4360 page_cache_release(sgl[i].page);