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 = "20040403";
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 /* The driver prints some debugging information on the console if DEBUG
44 is defined and non-zero. */
48 /* The message level for the debug messages is currently set to KERN_NOTICE
49 so that people can easily see the messages. Later when the debugging messages
50 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
51 #define ST_DEB_MSG KERN_NOTICE
53 #define DEBC(a) if (debugging) { a ; }
61 #include <scsi/scsi_host.h>
63 #include <scsi/scsi_driver.h>
64 #include <scsi/scsi_ioctl.h>
66 #define ST_KILOBYTE 1024
68 #include "st_options.h"
71 static int buffer_kbs;
72 static int max_sg_segs;
73 static int try_direct_io = TRY_DIRECT_IO;
74 static int try_rdio = TRUE;
75 static int try_wdio = TRUE;
77 static int st_dev_max;
80 static struct class_simple *st_sysfs_class;
82 MODULE_AUTHOR("Kai Makisara");
83 MODULE_DESCRIPTION("SCSI Tape Driver");
84 MODULE_LICENSE("GPL");
86 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
87 * of sysfs parameters (which module_param doesn't yet support).
88 * Sysfs parameters defined explicitly later.
90 module_param_named(buffer_kbs, buffer_kbs, int, 0);
91 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
92 module_param_named(max_sg_segs, max_sg_segs, int, 0);
93 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
94 module_param_named(try_direct_io, try_direct_io, int, 0);
95 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
97 /* Extra parameters for testing */
98 module_param_named(try_rdio, try_rdio, int, 0);
99 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
100 module_param_named(try_wdio, try_wdio, int, 0);
101 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
104 static int write_threshold_kbs; /* retained for compatibility */
105 static struct st_dev_parm {
108 } parms[] __initdata = {
110 "buffer_kbs", &buffer_kbs
112 { /* Retained for compatibility with 2.4 */
113 "write_threshold_kbs", &write_threshold_kbs
119 "try_direct_io", &try_direct_io
124 /* Restrict the number of modes so that names for all are assigned */
125 #if ST_NBR_MODES > 16
126 #error "Maximum number of modes is 16"
128 /* Bit reversed order to get same names for same minors with all
130 static char *st_formats[] = {
131 "", "r", "k", "s", "l", "t", "o", "u",
132 "m", "v", "p", "x", "a", "y", "q", "z"};
134 /* The default definitions have been moved to st_options.h */
136 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
138 /* The buffer size should fit into the 24 bits for length in the
139 6-byte SCSI read and write commands. */
140 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
141 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
144 DEB( static int debugging = DEBUG; )
146 #define MAX_RETRIES 0
147 #define MAX_WRITE_RETRIES 0
148 #define MAX_READY_RETRIES 0
149 #define NO_TAPE NOT_READY
151 #define ST_TIMEOUT (900 * HZ)
152 #define ST_LONG_TIMEOUT (14000 * HZ)
154 /* Remove mode bits and auto-rewind bit (7) */
155 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
156 (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
157 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
159 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
160 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
161 (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
163 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
165 #define SET_DENS_AND_BLK 0x10001
167 static rwlock_t st_dev_arr_lock = RW_LOCK_UNLOCKED;
169 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
170 static int st_max_sg_segs = ST_MAX_SG;
172 static Scsi_Tape **scsi_tapes = NULL;
174 static int modes_defined;
176 static ST_buffer *new_tape_buffer(int, int, int);
177 static int enlarge_buffer(ST_buffer *, int, int);
178 static void normalize_buffer(ST_buffer *);
179 static int append_to_buffer(const char __user *, ST_buffer *, int);
180 static int from_buffer(ST_buffer *, char __user *, int);
181 static void move_buffer_data(ST_buffer *, int);
182 static void buf_to_sg(ST_buffer *, unsigned int);
184 static int st_map_user_pages(struct scatterlist *, const unsigned int,
185 unsigned long, size_t, int, unsigned long);
186 static int sgl_map_user_pages(struct scatterlist *, const unsigned int,
187 unsigned long, size_t, int);
188 static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int);
190 static int st_probe(struct device *);
191 static int st_remove(struct device *);
192 static int st_init_command(struct scsi_cmnd *);
194 static void do_create_driverfs_files(void);
195 static void do_remove_driverfs_files(void);
196 static void do_create_class_files(Scsi_Tape *, int, int);
198 static struct scsi_driver st_template = {
199 .owner = THIS_MODULE,
205 .init_command = st_init_command,
208 static int st_compression(Scsi_Tape *, int);
210 static int find_partition(Scsi_Tape *);
211 static int switch_partition(Scsi_Tape *);
213 static int st_int_ioctl(Scsi_Tape *, unsigned int, unsigned long);
216 #include "osst_detect.h"
217 #ifndef SIGS_FROM_OSST
218 #define SIGS_FROM_OSST \
219 {"OnStream", "SC-", "", "osst"}, \
220 {"OnStream", "DI-", "", "osst"}, \
221 {"OnStream", "DP-", "", "osst"}, \
222 {"OnStream", "USB", "", "osst"}, \
223 {"OnStream", "FW-", "", "osst"}
226 struct st_reject_data {
230 char *driver_hint; /* Name of the correct driver, NULL if unknown */
233 static struct st_reject_data reject_list[] = {
234 /* {"XXX", "Yy-", "", NULL}, example */
238 /* If the device signature is on the list of incompatible drives, the
239 function returns a pointer to the name of the correct driver (if known) */
240 static char * st_incompatible(Scsi_Device* SDp)
242 struct st_reject_data *rp;
244 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
245 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
246 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
247 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
249 return rp->driver_hint;
257 static inline char *tape_name(Scsi_Tape *tape)
259 return tape->disk->disk_name;
262 /* Convert the result to success code */
263 static int st_chk_result(Scsi_Tape *STp, Scsi_Request * SRpnt)
265 int result = SRpnt->sr_result;
266 unsigned char *sense = SRpnt->sr_sense_buffer, scode;
267 DEB(const char *stp;)
268 char *name = tape_name(STp);
271 sense[0] = 0; /* We don't have sense data if this byte is zero */
275 if ((driver_byte(result) & DRIVER_MASK) == DRIVER_SENSE)
276 scode = sense[2] & 0x0f;
284 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x Len: %d\n",
286 SRpnt->sr_cmnd[0], SRpnt->sr_cmnd[1], SRpnt->sr_cmnd[2],
287 SRpnt->sr_cmnd[3], SRpnt->sr_cmnd[4], SRpnt->sr_cmnd[5],
289 if (driver_byte(result) & DRIVER_SENSE)
290 print_req_sense("st", SRpnt);
291 } else ) /* end DEB */
292 if (!(driver_byte(result) & DRIVER_SENSE) ||
293 ((sense[0] & 0x70) == 0x70 &&
295 scode != RECOVERED_ERROR &&
296 /* scode != UNIT_ATTENTION && */
297 scode != BLANK_CHECK &&
298 scode != VOLUME_OVERFLOW &&
299 SRpnt->sr_cmnd[0] != MODE_SENSE &&
300 SRpnt->sr_cmnd[0] != TEST_UNIT_READY)) { /* Abnormal conditions for tape */
301 if (driver_byte(result) & DRIVER_SENSE) {
302 printk(KERN_WARNING "%s: Error with sense data: ", name);
303 print_req_sense("st", SRpnt);
306 "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
307 name, result, suggestion(result),
308 driver_byte(result) & DRIVER_MASK, host_byte(result));
311 if (STp->cln_mode >= EXTENDED_SENSE_START) {
312 if (STp->cln_sense_value)
313 STp->cleaning_req |= ((SRpnt->sr_sense_buffer[STp->cln_mode] &
314 STp->cln_sense_mask) == STp->cln_sense_value);
316 STp->cleaning_req |= ((SRpnt->sr_sense_buffer[STp->cln_mode] &
317 STp->cln_sense_mask) != 0);
319 if (sense[12] == 0 && sense[13] == 0x17) /* ASC and ASCQ => cleaning requested */
320 STp->cleaning_req = 1;
322 STp->pos_unknown |= STp->device->was_reset;
324 if ((sense[0] & 0x70) == 0x70 &&
325 scode == RECOVERED_ERROR
326 #if ST_RECOVERED_WRITE_FATAL
327 && SRpnt->sr_cmnd[0] != WRITE_6
328 && SRpnt->sr_cmnd[0] != WRITE_FILEMARKS
331 STp->recover_count++;
336 if (SRpnt->sr_cmnd[0] == READ_6)
338 else if (SRpnt->sr_cmnd[0] == WRITE_6)
342 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
346 if ((sense[2] & 0xe0) == 0)
353 /* Wakeup from interrupt */
354 static void st_sleep_done(Scsi_Cmnd * SCpnt)
357 Scsi_Tape *STp = container_of(SCpnt->request->rq_disk->private_data,
360 if ((STp->buffer)->writing &&
361 (SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
362 (SCpnt->sense_buffer[2] & 0x40)) {
363 /* EOM at write-behind, has all been written? */
364 if ((SCpnt->sense_buffer[0] & 0x80) != 0)
365 remainder = (SCpnt->sense_buffer[3] << 24) |
366 (SCpnt->sense_buffer[4] << 16) |
367 (SCpnt->sense_buffer[5] << 8) |
368 SCpnt->sense_buffer[6];
371 if ((SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW ||
373 (STp->buffer)->midlevel_result = SCpnt->result; /* Error */
375 (STp->buffer)->midlevel_result = INT_MAX; /* OK */
377 (STp->buffer)->midlevel_result = SCpnt->result;
378 SCpnt->request->rq_status = RQ_SCSI_DONE;
379 (STp->buffer)->last_SRpnt = SCpnt->sc_request;
380 DEB( STp->write_pending = 0; )
382 complete(SCpnt->request->waiting);
385 /* Do the scsi command. Waits until command performed if do_wait is true.
386 Otherwise write_behind_check() is used to check that the command
388 static Scsi_Request *
389 st_do_scsi(Scsi_Request * SRpnt, Scsi_Tape * STp, unsigned char *cmd, int bytes,
390 int direction, int timeout, int retries, int do_wait)
395 SRpnt = scsi_allocate_request(STp->device, GFP_ATOMIC);
397 DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n",
399 if (signal_pending(current))
400 (STp->buffer)->syscall_result = (-EINTR);
402 (STp->buffer)->syscall_result = (-EBUSY);
407 init_completion(&STp->wait);
408 SRpnt->sr_use_sg = STp->buffer->do_dio || (bytes > (STp->buffer)->frp[0].length);
409 if (SRpnt->sr_use_sg) {
410 if (!STp->buffer->do_dio)
411 buf_to_sg(STp->buffer, bytes);
412 SRpnt->sr_use_sg = (STp->buffer)->sg_segs;
413 bp = (char *) &((STp->buffer)->sg[0]);
415 bp = (STp->buffer)->b_data;
416 SRpnt->sr_data_direction = direction;
417 SRpnt->sr_cmd_len = 0;
418 SRpnt->sr_request->waiting = &(STp->wait);
419 SRpnt->sr_request->rq_status = RQ_SCSI_BUSY;
420 SRpnt->sr_request->rq_disk = STp->disk;
422 scsi_do_req(SRpnt, (void *) cmd, bp, bytes,
423 st_sleep_done, timeout, retries);
426 wait_for_completion(SRpnt->sr_request->waiting);
427 SRpnt->sr_request->waiting = NULL;
428 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
434 /* Handle the write-behind checking (downs the semaphore) */
435 static void write_behind_check(Scsi_Tape * STp)
440 STbuffer = STp->buffer;
443 if (STp->write_pending)
449 wait_for_completion(&(STp->wait));
450 (STp->buffer)->last_SRpnt->sr_request->waiting = NULL;
452 (STp->buffer)->syscall_result = st_chk_result(STp, (STp->buffer)->last_SRpnt);
453 scsi_release_request((STp->buffer)->last_SRpnt);
455 STbuffer->buffer_bytes -= STbuffer->writing;
456 STps = &(STp->ps[STp->partition]);
457 if (STps->drv_block >= 0) {
458 if (STp->block_size == 0)
461 STps->drv_block += STbuffer->writing / STp->block_size;
463 STbuffer->writing = 0;
469 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
470 it messes up the block number). */
471 static int cross_eof(Scsi_Tape * STp, int forward)
474 unsigned char cmd[MAX_COMMAND_SIZE];
477 cmd[1] = 0x01; /* Space FileMarks */
482 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
485 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
486 tape_name(STp), forward ? "forward" : "backward"));
488 SRpnt = st_do_scsi(NULL, STp, cmd, 0, SCSI_DATA_NONE,
489 STp->device->timeout, MAX_RETRIES, TRUE);
491 return (STp->buffer)->syscall_result;
493 scsi_release_request(SRpnt);
496 if ((STp->buffer)->midlevel_result != 0)
497 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
498 tape_name(STp), forward ? "forward" : "backward");
500 return (STp->buffer)->syscall_result;
504 /* Flush the write buffer (never need to write if variable blocksize). */
505 static int flush_write_buffer(Scsi_Tape * STp)
507 int offset, transfer, blks;
509 unsigned char cmd[MAX_COMMAND_SIZE];
513 if ((STp->buffer)->writing) {
514 write_behind_check(STp);
515 if ((STp->buffer)->syscall_result) {
516 DEBC(printk(ST_DEB_MSG
517 "%s: Async write error (flush) %x.\n",
518 tape_name(STp), (STp->buffer)->midlevel_result))
519 if ((STp->buffer)->midlevel_result == INT_MAX)
524 if (STp->block_size == 0)
528 if (STp->dirty == 1) {
530 offset = (STp->buffer)->buffer_bytes;
531 transfer = ((offset + STp->block_size - 1) /
532 STp->block_size) * STp->block_size;
533 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
534 tape_name(STp), transfer));
536 memset((STp->buffer)->b_data + offset, 0, transfer - offset);
538 memset(cmd, 0, MAX_COMMAND_SIZE);
541 blks = transfer / STp->block_size;
546 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, SCSI_DATA_WRITE,
547 STp->device->timeout, MAX_WRITE_RETRIES, TRUE);
549 return (STp->buffer)->syscall_result;
551 STps = &(STp->ps[STp->partition]);
552 if ((STp->buffer)->syscall_result != 0) {
553 if ((SRpnt->sr_sense_buffer[0] & 0x70) == 0x70 &&
554 (SRpnt->sr_sense_buffer[2] & 0x40) &&
555 (SRpnt->sr_sense_buffer[2] & 0x0f) == NO_SENSE) {
557 (STp->buffer)->buffer_bytes = 0;
560 printk(KERN_ERR "%s: Error on flush.\n",
564 STps->drv_block = (-1);
566 if (STps->drv_block >= 0)
567 STps->drv_block += blks;
569 (STp->buffer)->buffer_bytes = 0;
571 scsi_release_request(SRpnt);
578 /* Flush the tape buffer. The tape will be positioned correctly unless
579 seek_next is true. */
580 static int flush_buffer(Scsi_Tape *STp, int seek_next)
582 int backspace, result;
586 STbuffer = STp->buffer;
589 * If there was a bus reset, block further access
592 if (STp->pos_unknown)
595 if (STp->ready != ST_READY)
597 STps = &(STp->ps[STp->partition]);
598 if (STps->rw == ST_WRITING) /* Writing */
599 return flush_write_buffer(STp);
601 if (STp->block_size == 0)
604 backspace = ((STp->buffer)->buffer_bytes +
605 (STp->buffer)->read_pointer) / STp->block_size -
606 ((STp->buffer)->read_pointer + STp->block_size - 1) /
608 (STp->buffer)->buffer_bytes = 0;
609 (STp->buffer)->read_pointer = 0;
612 if (STps->eof == ST_FM_HIT) {
613 result = cross_eof(STp, FALSE); /* Back over the EOF hit */
615 STps->eof = ST_NOEOF;
617 if (STps->drv_file >= 0)
622 if (!result && backspace > 0)
623 result = st_int_ioctl(STp, MTBSR, backspace);
624 } else if (STps->eof == ST_FM_HIT) {
625 if (STps->drv_file >= 0)
628 STps->eof = ST_NOEOF;
634 /* Set the mode parameters */
635 static int set_mode_densblk(Scsi_Tape * STp, ST_mode * STm)
639 char *name = tape_name(STp);
641 if (!STp->density_changed &&
642 STm->default_density >= 0 &&
643 STm->default_density != STp->density) {
644 arg = STm->default_density;
648 arg <<= MT_ST_DENSITY_SHIFT;
649 if (!STp->blksize_changed &&
650 STm->default_blksize >= 0 &&
651 STm->default_blksize != STp->block_size) {
652 arg |= STm->default_blksize;
655 arg |= STp->block_size;
657 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
659 "%s: Can't set default block size to %d bytes and density %x.\n",
660 name, STm->default_blksize, STm->default_density);
668 /* Lock or unlock the drive door. Don't use when Scsi_Request allocated. */
669 static int do_door_lock(Scsi_Tape * STp, int do_lock)
672 DEB(char *name = tape_name(STp);)
675 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
676 DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
677 do_lock ? "L" : "Unl"));
678 retval = scsi_ioctl(STp->device, cmd, NULL);
680 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
683 STp->door_locked = ST_LOCK_FAILS;
689 /* Set the internal state after reset */
690 static void reset_state(Scsi_Tape *STp)
695 STp->pos_unknown = 0;
696 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
697 STps = &(STp->ps[i]);
699 STps->eof = ST_NOEOF;
701 STps->last_block_valid = FALSE;
702 STps->drv_block = -1;
705 if (STp->can_partitions) {
706 STp->partition = find_partition(STp);
707 if (STp->partition < 0)
709 STp->new_partition = STp->partition;
713 /* Test if the drive is ready. Returns either one of the codes below or a negative system
715 #define CHKRES_READY 0
716 #define CHKRES_NEW_SESSION 1
717 #define CHKRES_NOT_READY 2
718 #define CHKRES_NO_TAPE 3
720 #define MAX_ATTENTIONS 10
722 static int test_ready(Scsi_Tape *STp, int do_wait)
724 int attentions, waits, max_wait, scode;
725 int retval = CHKRES_READY, new_session = FALSE;
726 unsigned char cmd[MAX_COMMAND_SIZE];
727 Scsi_Request *SRpnt = NULL;
729 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
731 for (attentions=waits=0; ; ) {
732 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
733 cmd[0] = TEST_UNIT_READY;
734 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, SCSI_DATA_NONE,
735 STp->long_timeout, MAX_READY_RETRIES, TRUE);
738 retval = (STp->buffer)->syscall_result;
742 if ((SRpnt->sr_sense_buffer[0] & 0x70) == 0x70) {
744 scode = (SRpnt->sr_sense_buffer[2] & 0x0f);
746 if (scode == UNIT_ATTENTION) { /* New media? */
748 if (attentions < MAX_ATTENTIONS) {
758 if (scode == NOT_READY) {
759 if (waits < max_wait) {
760 set_current_state(TASK_INTERRUPTIBLE);
761 schedule_timeout(HZ);
762 if (signal_pending(current)) {
770 if ((STp->device)->scsi_level >= SCSI_2 &&
771 SRpnt->sr_sense_buffer[12] == 0x3a) /* Check ASC */
772 retval = CHKRES_NO_TAPE;
774 retval = CHKRES_NOT_READY;
780 retval = (STp->buffer)->syscall_result;
782 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
787 scsi_release_request(SRpnt);
792 /* See if the drive is ready and gather information about the tape. Return values:
793 < 0 negative error code from errno.h
795 1 drive not ready (possibly no tape)
797 static int check_tape(Scsi_Tape *STp, struct file *filp)
799 int i, retval, new_session = FALSE, do_wait;
800 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
801 unsigned short st_flags = filp->f_flags;
802 Scsi_Request *SRpnt = NULL;
805 char *name = tape_name(STp);
806 struct inode *inode = filp->f_dentry->d_inode;
807 int mode = TAPE_MODE(inode);
809 STp->ready = ST_READY;
811 if (mode != STp->current_mode) {
812 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
813 name, STp->current_mode, mode));
815 STp->current_mode = mode;
817 STm = &(STp->modes[STp->current_mode]);
819 saved_cleaning = STp->cleaning_req;
820 STp->cleaning_req = 0;
822 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
823 retval = test_ready(STp, do_wait);
828 if (retval == CHKRES_NEW_SESSION) {
829 STp->pos_unknown = 0;
830 STp->partition = STp->new_partition = 0;
831 if (STp->can_partitions)
832 STp->nbr_partitions = 1; /* This guess will be updated later
834 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
835 STps = &(STp->ps[i]);
837 STps->eof = ST_NOEOF;
839 STps->last_block_valid = FALSE;
846 STp->cleaning_req |= saved_cleaning;
848 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
849 if (retval == CHKRES_NO_TAPE)
850 STp->ready = ST_NO_TAPE;
852 STp->ready = ST_NOT_READY;
854 STp->density = 0; /* Clear the erroneous "residue" */
857 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
858 STp->partition = STp->new_partition = 0;
859 STp->door_locked = ST_UNLOCKED;
860 return CHKRES_NOT_READY;
864 if (STp->omit_blklims)
865 STp->min_block = STp->max_block = (-1);
867 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
868 cmd[0] = READ_BLOCK_LIMITS;
870 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, SCSI_DATA_READ, STp->device->timeout,
871 MAX_READY_RETRIES, TRUE);
873 retval = (STp->buffer)->syscall_result;
877 if (!SRpnt->sr_result && !SRpnt->sr_sense_buffer[0]) {
878 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
879 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
880 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
881 (STp->buffer)->b_data[5];
882 if ( DEB( debugging || ) !STp->inited)
884 "%s: Block limits %d - %d bytes.\n", name,
885 STp->min_block, STp->max_block);
887 STp->min_block = STp->max_block = (-1);
888 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
893 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
897 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, SCSI_DATA_READ, STp->device->timeout,
898 MAX_READY_RETRIES, TRUE);
900 retval = (STp->buffer)->syscall_result;
904 if ((STp->buffer)->syscall_result != 0) {
905 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
906 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
907 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */
908 STp->drv_write_prot = 0;
910 DEBC(printk(ST_DEB_MSG
911 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
913 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
914 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
916 if ((STp->buffer)->b_data[3] >= 8) {
917 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
918 STp->density = (STp->buffer)->b_data[4];
919 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
920 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
921 DEBC(printk(ST_DEB_MSG
922 "%s: Density %x, tape length: %x, drv buffer: %d\n",
923 name, STp->density, (STp->buffer)->b_data[5] * 65536 +
924 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
927 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
929 scsi_release_request(SRpnt);
933 if (STp->block_size > 0)
934 (STp->buffer)->buffer_blocks =
935 (STp->buffer)->buffer_size / STp->block_size;
937 (STp->buffer)->buffer_blocks = 1;
938 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
940 DEBC(printk(ST_DEB_MSG
941 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
942 STp->block_size, (STp->buffer)->buffer_size,
943 (STp->buffer)->buffer_blocks));
945 if (STp->drv_write_prot) {
948 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
951 ((st_flags & O_ACCMODE) == O_WRONLY ||
952 (st_flags & O_ACCMODE) == O_RDWR)) {
958 if (STp->can_partitions && STp->nbr_partitions < 1) {
959 /* This code is reached when the device is opened for the first time
960 after the driver has been initialized with tape in the drive and the
961 partition support has been enabled. */
962 DEBC(printk(ST_DEB_MSG
963 "%s: Updating partition number in status.\n", name));
964 if ((STp->partition = find_partition(STp)) < 0) {
965 retval = STp->partition;
968 STp->new_partition = STp->partition;
969 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
972 if (new_session) { /* Change the drive parameters for the new mode */
973 STp->density_changed = STp->blksize_changed = FALSE;
974 STp->compression_changed = FALSE;
975 if (!(STm->defaults_for_writes) &&
976 (retval = set_mode_densblk(STp, STm)) < 0)
979 if (STp->default_drvbuffer != 0xff) {
980 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
982 "%s: Can't set default drive buffering to %d.\n",
983 name, STp->default_drvbuffer);
994 \f/* Open the device. Needs to be called with BKL only because of incrementing the SCSI host
996 static int st_open(struct inode *inode, struct file *filp)
998 int i, retval = (-EIO);
1001 int dev = TAPE_NR(inode);
1004 nonseekable_open(inode, filp);
1005 write_lock(&st_dev_arr_lock);
1006 if (dev >= st_dev_max || scsi_tapes == NULL ||
1007 ((STp = scsi_tapes[dev]) == NULL)) {
1008 write_unlock(&st_dev_arr_lock);
1011 filp->private_data = STp;
1012 name = tape_name(STp);
1015 write_unlock(&st_dev_arr_lock);
1016 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1020 if(scsi_device_get(STp->device)) {
1021 write_unlock(&st_dev_arr_lock);
1025 write_unlock(&st_dev_arr_lock);
1026 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1028 if (!scsi_block_when_processing_errors(STp->device)) {
1033 /* See that we have at least a one page buffer available */
1034 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1035 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1037 retval = (-EOVERFLOW);
1041 (STp->buffer)->writing = 0;
1042 (STp->buffer)->syscall_result = 0;
1044 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1047 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1048 STps = &(STp->ps[i]);
1051 STp->recover_count = 0;
1052 DEB( STp->nbr_waits = STp->nbr_finished = 0;
1053 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = STp->nbr_combinable = 0; )
1055 retval = check_tape(STp, filp);
1058 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1059 retval != CHKRES_READY) {
1066 normalize_buffer(STp->buffer);
1068 scsi_device_put(STp->device);
1074 /* Flush the tape buffer before close */
1075 static int st_flush(struct file *filp)
1077 int result = 0, result2;
1078 unsigned char cmd[MAX_COMMAND_SIZE];
1079 Scsi_Request *SRpnt;
1080 Scsi_Tape *STp = filp->private_data;
1081 ST_mode *STm = &(STp->modes[STp->current_mode]);
1082 ST_partstat *STps = &(STp->ps[STp->partition]);
1083 char *name = tape_name(STp);
1085 if (file_count(filp) > 1)
1088 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1089 result = flush_write_buffer(STp);
1090 if (result != 0 && result != (-ENOSPC))
1094 if (STp->can_partitions &&
1095 (result2 = switch_partition(STp)) < 0) {
1096 DEBC(printk(ST_DEB_MSG
1097 "%s: switch_partition at close failed.\n", name));
1103 DEBC( if (STp->nbr_requests)
1104 printk(KERN_WARNING "%s: Number of r/w requests %d, dio used in %d, pages %d (%d).\n",
1105 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages, STp->nbr_combinable));
1107 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1109 DEBC(printk(ST_DEB_MSG "%s: File length %ld bytes.\n",
1110 name, (long) (filp->f_pos));
1111 printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1112 name, STp->nbr_waits, STp->nbr_finished);
1115 memset(cmd, 0, MAX_COMMAND_SIZE);
1116 cmd[0] = WRITE_FILEMARKS;
1117 cmd[4] = 1 + STp->two_fm;
1119 SRpnt = st_do_scsi(NULL, STp, cmd, 0, SCSI_DATA_NONE,
1120 STp->device->timeout, MAX_WRITE_RETRIES, TRUE);
1122 result = (STp->buffer)->syscall_result;
1126 if ((STp->buffer)->syscall_result != 0 &&
1127 ((SRpnt->sr_sense_buffer[0] & 0x70) != 0x70 ||
1128 (SRpnt->sr_sense_buffer[2] & 0x4f) != 0x40 ||
1129 ((SRpnt->sr_sense_buffer[0] & 0x80) != 0 &&
1130 (SRpnt->sr_sense_buffer[3] | SRpnt->sr_sense_buffer[4] |
1131 SRpnt->sr_sense_buffer[5] |
1132 SRpnt->sr_sense_buffer[6]) != 0))) {
1133 /* Filter out successful write at EOM */
1134 scsi_release_request(SRpnt);
1136 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1140 scsi_release_request(SRpnt);
1142 if (STps->drv_file >= 0)
1144 STps->drv_block = 0;
1146 cross_eof(STp, FALSE);
1150 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1152 } else if (!STp->rew_at_close) {
1153 STps = &(STp->ps[STp->partition]);
1154 if (!STm->sysv || STps->rw != ST_READING) {
1156 result = flush_buffer(STp, 0);
1157 else if (STps->eof == ST_FM_HIT) {
1158 result = cross_eof(STp, FALSE);
1160 if (STps->drv_file >= 0)
1162 STps->drv_block = 0;
1165 STps->eof = ST_NOEOF;
1167 } else if ((STps->eof == ST_NOEOF &&
1168 !(result = cross_eof(STp, TRUE))) ||
1169 STps->eof == ST_FM_HIT) {
1170 if (STps->drv_file >= 0)
1172 STps->drv_block = 0;
1178 if (STp->rew_at_close) {
1179 result2 = st_int_ioctl(STp, MTREW, 1);
1187 /* Close the device and release it. BKL is not needed: this is the only thread
1188 accessing this tape. */
1189 static int st_release(struct inode *inode, struct file *filp)
1192 Scsi_Tape *STp = filp->private_data;
1194 if (STp->door_locked == ST_LOCKED_AUTO)
1195 do_door_lock(STp, 0);
1197 normalize_buffer(STp->buffer);
1198 write_lock(&st_dev_arr_lock);
1200 write_unlock(&st_dev_arr_lock);
1201 scsi_device_put(STp->device);
1206 /* The checks common to both reading and writing */
1207 static ssize_t rw_checks(Scsi_Tape *STp, struct file *filp, size_t count)
1212 * If we are in the middle of error recovery, don't let anyone
1213 * else try and use this device. Also, if error recovery fails, it
1214 * may try and take the device offline, in which case all further
1215 * access to the device is prohibited.
1217 if (!scsi_block_when_processing_errors(STp->device)) {
1222 if (STp->ready != ST_READY) {
1223 if (STp->ready == ST_NO_TAPE)
1224 retval = (-ENOMEDIUM);
1230 if (! STp->modes[STp->current_mode].defined) {
1237 * If there was a bus reset, block further access
1240 if (STp->pos_unknown) {
1250 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1255 if (STp->can_partitions &&
1256 (retval = switch_partition(STp)) < 0)
1259 if (STp->block_size == 0 && STp->max_block > 0 &&
1260 (count < STp->min_block || count > STp->max_block)) {
1265 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1266 !do_door_lock(STp, 1))
1267 STp->door_locked = ST_LOCKED_AUTO;
1274 static int setup_buffering(Scsi_Tape *STp, const char __user *buf, size_t count, int is_read)
1276 int i, bufsize, retval = 0;
1277 ST_buffer *STbp = STp->buffer;
1280 i = STp->try_dio && try_rdio;
1282 i = STp->try_dio && try_wdio;
1283 if (i && ((unsigned long)buf & queue_dma_alignment(
1284 STp->device->request_queue)) == 0) {
1285 i = st_map_user_pages(&(STbp->sg[0]), STbp->use_sg,
1286 (unsigned long)buf, count, (is_read ? READ : WRITE),
1290 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1293 STbp->do_dio = FALSE; /* fall back to buffering with any error */
1294 STbp->sg_segs = STbp->do_dio;
1295 STbp->frp_sg_current = 0;
1299 STp->nbr_pages += STbp->do_dio;
1300 for (i=1; i < STbp->do_dio; i++)
1301 if (page_to_pfn(STbp->sg[i].page) == page_to_pfn(STbp->sg[i-1].page) + 1)
1302 STp->nbr_combinable++;
1306 STbp->do_dio = FALSE;
1307 DEB( STp->nbr_requests++; )
1309 if (!STbp->do_dio) {
1310 if (STp->block_size)
1311 bufsize = STp->block_size > st_fixed_buffer_size ?
1312 STp->block_size : st_fixed_buffer_size;
1315 if (bufsize > STbp->buffer_size &&
1316 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1317 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1318 tape_name(STp), bufsize);
1319 retval = (-EOVERFLOW);
1322 if (STp->block_size)
1323 STbp->buffer_blocks = bufsize / STp->block_size;
1331 /* Can be called more than once after each setup_buffer() */
1332 static void release_buffering(Scsi_Tape *STp)
1338 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, FALSE);
1346 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1349 ssize_t i, do_count, blks, transfer;
1351 int undone, retry_eot = 0, scode;
1353 unsigned char cmd[MAX_COMMAND_SIZE];
1354 const char __user *b_point;
1355 Scsi_Request *SRpnt = NULL;
1356 Scsi_Tape *STp = filp->private_data;
1360 char *name = tape_name(STp);
1362 if (down_interruptible(&STp->lock))
1363 return -ERESTARTSYS;
1365 retval = rw_checks(STp, filp, count);
1366 if (retval || count == 0)
1369 /* Write must be integral number of blocks */
1370 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1371 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1377 STm = &(STp->modes[STp->current_mode]);
1378 STps = &(STp->ps[STp->partition]);
1380 if (STp->write_prot) {
1386 if (STps->rw == ST_READING) {
1387 retval = flush_buffer(STp, 0);
1390 STps->rw = ST_WRITING;
1391 } else if (STps->rw != ST_WRITING &&
1392 STps->drv_file == 0 && STps->drv_block == 0) {
1393 if ((retval = set_mode_densblk(STp, STm)) < 0)
1395 if (STm->default_compression != ST_DONT_TOUCH &&
1396 !(STp->compression_changed)) {
1397 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1398 printk(KERN_WARNING "%s: Can't set default compression.\n",
1400 if (modes_defined) {
1409 if (STbp->writing) {
1410 write_behind_check(STp);
1411 if (STbp->syscall_result) {
1412 DEBC(printk(ST_DEB_MSG "%s: Async write error (write) %x.\n",
1413 name, STbp->midlevel_result));
1414 if (STbp->midlevel_result == INT_MAX)
1415 STps->eof = ST_EOM_OK;
1417 STps->eof = ST_EOM_ERROR;
1421 if (STps->eof == ST_EOM_OK) {
1422 STps->eof = ST_EOD_1; /* allow next write */
1426 else if (STps->eof == ST_EOM_ERROR) {
1431 /* Check the buffer readability in cases where copy_user might catch
1432 the problems after some tape movement. */
1433 if (STp->block_size != 0 &&
1435 (copy_from_user(&i, buf, 1) != 0 ||
1436 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1441 retval = setup_buffering(STp, buf, count, FALSE);
1447 memset(cmd, 0, MAX_COMMAND_SIZE);
1449 cmd[1] = (STp->block_size != 0);
1451 STps->rw = ST_WRITING;
1454 while (count > 0 && !retry_eot) {
1460 if (STp->block_size == 0)
1463 do_count = STbp->buffer_blocks * STp->block_size -
1465 if (do_count > count)
1469 i = append_to_buffer(b_point, STbp, do_count);
1476 filp->f_pos += do_count;
1477 b_point += do_count;
1479 async_write = STp->block_size == 0 && !STbp->do_dio &&
1480 STm->do_async_writes && STps->eof < ST_EOM_OK;
1482 if (STp->block_size != 0 && STm->do_buffer_writes &&
1483 !(STp->try_dio && try_wdio) && STps->eof < ST_EOM_OK &&
1484 STbp->buffer_bytes < STbp->buffer_size) {
1486 /* Don't write a buffer that is not full enough. */
1487 if (!async_write && count == 0)
1492 if (STp->block_size == 0)
1493 blks = transfer = do_count;
1496 blks = STbp->buffer_bytes;
1499 blks /= STp->block_size;
1500 transfer = blks * STp->block_size;
1502 cmd[2] = blks >> 16;
1506 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, SCSI_DATA_WRITE,
1507 STp->device->timeout, MAX_WRITE_RETRIES, !async_write);
1509 retval = STbp->syscall_result;
1513 STbp->writing = transfer;
1514 STp->dirty = !(STbp->writing ==
1515 STbp->buffer_bytes);
1516 SRpnt = NULL; /* Prevent releasing this request! */
1517 DEB( STp->write_pending = 1; )
1521 if (STbp->syscall_result != 0) {
1522 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1523 if ((SRpnt->sr_sense_buffer[0] & 0x70) == 0x70 &&
1524 (SRpnt->sr_sense_buffer[2] & 0x40)) {
1525 scode = SRpnt->sr_sense_buffer[2] & 0x0f;
1526 if ((SRpnt->sr_sense_buffer[0] & 0x80) != 0)
1527 undone = (SRpnt->sr_sense_buffer[3] << 24) |
1528 (SRpnt->sr_sense_buffer[4] << 16) |
1529 (SRpnt->sr_sense_buffer[5] << 8) |
1530 SRpnt->sr_sense_buffer[6];
1531 else if (STp->block_size == 0 &&
1532 scode == VOLUME_OVERFLOW)
1536 if (STp->block_size != 0)
1537 undone *= STp->block_size;
1538 filp->f_pos -= undone;
1539 if (undone <= do_count) {
1540 /* Only data from this write is not written */
1543 if (STp->block_size)
1544 blks = (transfer - undone) / STp->block_size;
1545 STps->eof = ST_EOM_OK;
1546 /* Continue in fixed block mode if all written
1547 in this request but still something left to write
1548 (retval left to zero)
1550 if (STp->block_size == 0 ||
1551 undone > 0 || count == 0)
1552 retval = (-ENOSPC); /* EOM within current request */
1553 DEBC(printk(ST_DEB_MSG
1554 "%s: EOM with %d bytes unwritten.\n",
1557 /* EOT within data buffered earlier (possible only
1558 in fixed block mode without direct i/o) */
1559 if (!retry_eot && (SRpnt->sr_sense_buffer[0] & 1) == 0 &&
1560 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1561 move_buffer_data(STp->buffer, transfer - undone);
1563 if (STps->drv_block >= 0) {
1564 STps->drv_block += (transfer - undone) /
1567 STps->eof = ST_EOM_OK;
1568 DEBC(printk(ST_DEB_MSG
1569 "%s: Retry write of %d bytes at EOM.\n",
1570 name, STp->buffer->buffer_bytes));
1574 /* Either error within data buffered by driver or
1577 blks = do_count = 0;
1578 STps->eof = ST_EOM_ERROR;
1579 STps->drv_block = (-1); /* Too cautious? */
1580 retval = (-EIO); /* EOM for old data */
1581 DEBC(printk(ST_DEB_MSG
1582 "%s: EOM with lost data.\n",
1587 filp->f_pos -= do_count;
1589 STps->drv_block = (-1); /* Too cautious? */
1595 if (STps->drv_block >= 0) {
1596 if (STp->block_size == 0)
1597 STps->drv_block += (do_count > 0);
1599 STps->drv_block += blks;
1602 STbp->buffer_bytes = 0;
1605 if (retval || retry_eot) {
1607 retval = total - count;
1612 if (STps->eof == ST_EOD_1)
1613 STps->eof = ST_EOM_OK;
1614 else if (STps->eof != ST_EOM_OK)
1615 STps->eof = ST_NOEOF;
1616 retval = total - count;
1620 scsi_release_request(SRpnt);
1621 release_buffering(STp);
1627 /* Read data from the tape. Returns zero in the normal case, one if the
1628 eof status has changed, and the negative error code in case of a
1629 fatal error. Otherwise updates the buffer and the eof state.
1631 Does release user buffer mapping if it is set.
1633 static long read_tape(Scsi_Tape *STp, long count, Scsi_Request ** aSRpnt)
1635 int transfer, blks, bytes;
1636 unsigned char cmd[MAX_COMMAND_SIZE];
1637 Scsi_Request *SRpnt;
1642 char *name = tape_name(STp);
1647 STm = &(STp->modes[STp->current_mode]);
1648 STps = &(STp->ps[STp->partition]);
1649 if (STps->eof == ST_FM_HIT)
1653 if (STp->block_size == 0)
1654 blks = bytes = count;
1656 if (!(STp->try_dio && try_rdio) && STm->do_read_ahead) {
1657 blks = (STp->buffer)->buffer_blocks;
1658 bytes = blks * STp->block_size;
1661 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1662 bytes = (STp->buffer)->buffer_size;
1663 blks = bytes / STp->block_size;
1664 bytes = blks * STp->block_size;
1668 memset(cmd, 0, MAX_COMMAND_SIZE);
1670 cmd[1] = (STp->block_size != 0);
1671 cmd[2] = blks >> 16;
1676 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, SCSI_DATA_READ,
1677 STp->device->timeout, MAX_RETRIES, TRUE);
1678 release_buffering(STp);
1681 return STbp->syscall_result;
1683 STbp->read_pointer = 0;
1686 /* Something to check */
1687 if (STbp->syscall_result) {
1689 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1691 SRpnt->sr_sense_buffer[0], SRpnt->sr_sense_buffer[1],
1692 SRpnt->sr_sense_buffer[2], SRpnt->sr_sense_buffer[3],
1693 SRpnt->sr_sense_buffer[4], SRpnt->sr_sense_buffer[5],
1694 SRpnt->sr_sense_buffer[6], SRpnt->sr_sense_buffer[7]));
1695 if ((SRpnt->sr_sense_buffer[0] & 0x70) == 0x70) { /* extended sense */
1697 if ((SRpnt->sr_sense_buffer[2] & 0x0f) == BLANK_CHECK)
1698 SRpnt->sr_sense_buffer[2] &= 0xcf; /* No need for EOM in this case */
1700 if ((SRpnt->sr_sense_buffer[2] & 0xe0) != 0) { /* EOF, EOM, or ILI */
1701 /* Compute the residual count */
1702 if ((SRpnt->sr_sense_buffer[0] & 0x80) != 0)
1703 transfer = (SRpnt->sr_sense_buffer[3] << 24) |
1704 (SRpnt->sr_sense_buffer[4] << 16) |
1705 (SRpnt->sr_sense_buffer[5] << 8) |
1706 SRpnt->sr_sense_buffer[6];
1709 if (STp->block_size == 0 &&
1710 (SRpnt->sr_sense_buffer[2] & 0x0f) == MEDIUM_ERROR)
1713 if (SRpnt->sr_sense_buffer[2] & 0x20) { /* ILI */
1714 if (STp->block_size == 0) {
1715 if (transfer <= 0) {
1718 "%s: Failed to read %d byte block with %d byte transfer.\n",
1719 name, bytes - transfer, bytes);
1720 if (STps->drv_block >= 0)
1721 STps->drv_block += 1;
1722 STbp->buffer_bytes = 0;
1725 STbp->buffer_bytes = bytes - transfer;
1727 scsi_release_request(SRpnt);
1728 SRpnt = *aSRpnt = NULL;
1729 if (transfer == blks) { /* We did not get anything, error */
1730 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1731 if (STps->drv_block >= 0)
1732 STps->drv_block += blks - transfer + 1;
1733 st_int_ioctl(STp, MTBSR, 1);
1736 /* We have some data, deliver it */
1737 STbp->buffer_bytes = (blks - transfer) *
1739 DEBC(printk(ST_DEB_MSG
1740 "%s: ILI but enough data received %ld %d.\n",
1741 name, count, STbp->buffer_bytes));
1742 if (STps->drv_block >= 0)
1743 STps->drv_block += 1;
1744 if (st_int_ioctl(STp, MTBSR, 1))
1747 } else if (SRpnt->sr_sense_buffer[2] & 0x80) { /* FM overrides EOM */
1748 if (STps->eof != ST_FM_HIT)
1749 STps->eof = ST_FM_HIT;
1751 STps->eof = ST_EOD_2;
1752 if (STp->block_size == 0)
1753 STbp->buffer_bytes = 0;
1755 STbp->buffer_bytes =
1756 bytes - transfer * STp->block_size;
1757 DEBC(printk(ST_DEB_MSG
1758 "%s: EOF detected (%d bytes read).\n",
1759 name, STbp->buffer_bytes));
1760 } else if (SRpnt->sr_sense_buffer[2] & 0x40) {
1761 if (STps->eof == ST_FM)
1762 STps->eof = ST_EOD_1;
1764 STps->eof = ST_EOM_OK;
1765 if (STp->block_size == 0)
1766 STbp->buffer_bytes = bytes - transfer;
1768 STbp->buffer_bytes =
1769 bytes - transfer * STp->block_size;
1771 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1772 name, STbp->buffer_bytes));
1775 /* end of EOF, EOM, ILI test */
1776 else { /* nonzero sense key */
1777 DEBC(printk(ST_DEB_MSG
1778 "%s: Tape error while reading.\n", name));
1779 STps->drv_block = (-1);
1780 if (STps->eof == ST_FM &&
1781 (SRpnt->sr_sense_buffer[2] & 0x0f) == BLANK_CHECK) {
1782 DEBC(printk(ST_DEB_MSG
1783 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1785 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1786 } else /* Some other extended sense code */
1790 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
1791 STbp->buffer_bytes = 0;
1793 /* End of extended sense test */
1794 else { /* Non-extended sense */
1795 retval = STbp->syscall_result;
1799 /* End of error handling */
1800 else /* Read successful */
1801 STbp->buffer_bytes = bytes;
1803 if (STps->drv_block >= 0) {
1804 if (STp->block_size == 0)
1807 STps->drv_block += STbp->buffer_bytes / STp->block_size;
1815 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
1819 ssize_t i, transfer;
1820 int special, do_dio = 0;
1821 Scsi_Request *SRpnt = NULL;
1822 Scsi_Tape *STp = filp->private_data;
1825 ST_buffer *STbp = STp->buffer;
1826 DEB( char *name = tape_name(STp); )
1828 if (down_interruptible(&STp->lock))
1829 return -ERESTARTSYS;
1831 retval = rw_checks(STp, filp, count);
1832 if (retval || count == 0)
1835 STm = &(STp->modes[STp->current_mode]);
1836 if (!(STm->do_read_ahead) && STp->block_size != 0 &&
1837 (count % STp->block_size) != 0) {
1838 retval = (-EINVAL); /* Read must be integral number of blocks */
1842 STps = &(STp->ps[STp->partition]);
1843 if (STps->rw == ST_WRITING) {
1844 retval = flush_buffer(STp, 0);
1847 STps->rw = ST_READING;
1850 if (debugging && STps->eof != ST_NOEOF)
1851 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
1852 STps->eof, STbp->buffer_bytes);
1855 retval = setup_buffering(STp, buf, count, TRUE);
1858 do_dio = STbp->do_dio;
1860 if (STbp->buffer_bytes == 0 &&
1861 STps->eof >= ST_EOD_1) {
1862 if (STps->eof < ST_EOD) {
1867 retval = (-EIO); /* EOM or Blank Check */
1872 /* Check the buffer writability before any tape movement. Don't alter
1874 if (copy_from_user(&i, buf, 1) != 0 ||
1875 copy_to_user(buf, &i, 1) != 0 ||
1876 copy_from_user(&i, buf + count - 1, 1) != 0 ||
1877 copy_to_user(buf + count - 1, &i, 1) != 0) {
1883 STps->rw = ST_READING;
1886 /* Loop until enough data in buffer or a special condition found */
1887 for (total = 0, special = 0; total < count && !special;) {
1889 /* Get new data if the buffer is empty */
1890 if (STbp->buffer_bytes == 0) {
1891 special = read_tape(STp, count - total, &SRpnt);
1892 if (special < 0) { /* No need to continue read */
1898 /* Move the data from driver buffer to user buffer */
1899 if (STbp->buffer_bytes > 0) {
1901 if (debugging && STps->eof != ST_NOEOF)
1903 "%s: EOF up (%d). Left %d, needed %d.\n", name,
1904 STps->eof, STbp->buffer_bytes,
1907 transfer = STbp->buffer_bytes < count - total ?
1908 STbp->buffer_bytes : count - total;
1910 i = from_buffer(STbp, buf, transfer);
1916 filp->f_pos += transfer;
1921 if (STp->block_size == 0)
1922 break; /* Read only one variable length block */
1924 } /* for (total = 0, special = 0;
1925 total < count && !special; ) */
1927 /* Change the eof state if no data from tape or buffer */
1929 if (STps->eof == ST_FM_HIT) {
1931 STps->drv_block = 0;
1932 if (STps->drv_file >= 0)
1934 } else if (STps->eof == ST_EOD_1) {
1935 STps->eof = ST_EOD_2;
1936 STps->drv_block = 0;
1937 if (STps->drv_file >= 0)
1939 } else if (STps->eof == ST_EOD_2)
1941 } else if (STps->eof == ST_FM)
1942 STps->eof = ST_NOEOF;
1946 if (SRpnt != NULL) {
1947 scsi_release_request(SRpnt);
1951 release_buffering(STp);
1952 STbp->buffer_bytes = 0;
1962 /* Set the driver options */
1963 static void st_log_options(Scsi_Tape * STp, ST_mode * STm, char *name)
1967 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
1968 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
1969 STm->do_read_ahead);
1971 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
1972 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
1974 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
1975 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
1976 STp->scsi2_logical);
1978 "%s: sysv: %d nowait: %d\n", name, STm->sysv, STp->immediate);
1979 printk(KERN_INFO "%s: debugging: %d\n",
1986 static int st_set_options(Scsi_Tape *STp, long options)
1991 char *name = tape_name(STp);
1992 struct cdev *cd0, *cd1;
1994 STm = &(STp->modes[STp->current_mode]);
1995 if (!STm->defined) {
1996 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
1997 memcpy(STm, &(STp->modes[0]), sizeof(ST_mode));
1998 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
1999 modes_defined = TRUE;
2000 DEBC(printk(ST_DEB_MSG
2001 "%s: Initialized mode %d definition from mode 0\n",
2002 name, STp->current_mode));
2005 code = options & MT_ST_OPTIONS;
2006 if (code == MT_ST_BOOLEANS) {
2007 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2008 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2009 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2010 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2011 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2012 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2013 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2014 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2015 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2016 if ((STp->device)->scsi_level >= SCSI_2)
2017 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2018 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2019 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2020 STm->sysv = (options & MT_ST_SYSV) != 0;
2021 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2022 st_log_options(STp, STm, name); )
2023 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2024 value = (code == MT_ST_SETBOOLEANS);
2025 if ((options & MT_ST_BUFFER_WRITES) != 0)
2026 STm->do_buffer_writes = value;
2027 if ((options & MT_ST_ASYNC_WRITES) != 0)
2028 STm->do_async_writes = value;
2029 if ((options & MT_ST_DEF_WRITES) != 0)
2030 STm->defaults_for_writes = value;
2031 if ((options & MT_ST_READ_AHEAD) != 0)
2032 STm->do_read_ahead = value;
2033 if ((options & MT_ST_TWO_FM) != 0)
2034 STp->two_fm = value;
2035 if ((options & MT_ST_FAST_MTEOM) != 0)
2036 STp->fast_mteom = value;
2037 if ((options & MT_ST_AUTO_LOCK) != 0)
2038 STp->do_auto_lock = value;
2039 if ((options & MT_ST_CAN_BSR) != 0)
2040 STp->can_bsr = value;
2041 if ((options & MT_ST_NO_BLKLIMS) != 0)
2042 STp->omit_blklims = value;
2043 if ((STp->device)->scsi_level >= SCSI_2 &&
2044 (options & MT_ST_CAN_PARTITIONS) != 0)
2045 STp->can_partitions = value;
2046 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2047 STp->scsi2_logical = value;
2048 if ((options & MT_ST_NOWAIT) != 0)
2049 STp->immediate = value;
2050 if ((options & MT_ST_SYSV) != 0)
2053 if ((options & MT_ST_DEBUGGING) != 0)
2055 st_log_options(STp, STm, name); )
2056 } else if (code == MT_ST_WRITE_THRESHOLD) {
2057 /* Retained for compatibility */
2058 } else if (code == MT_ST_DEF_BLKSIZE) {
2059 value = (options & ~MT_ST_OPTIONS);
2060 if (value == ~MT_ST_OPTIONS) {
2061 STm->default_blksize = (-1);
2062 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2064 STm->default_blksize = value;
2065 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2066 name, STm->default_blksize));
2067 if (STp->ready == ST_READY) {
2068 STp->blksize_changed = FALSE;
2069 set_mode_densblk(STp, STm);
2072 } else if (code == MT_ST_TIMEOUTS) {
2073 value = (options & ~MT_ST_OPTIONS);
2074 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2075 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2076 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2077 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2079 STp->device->timeout = value * HZ;
2080 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2083 } else if (code == MT_ST_SET_CLN) {
2084 value = (options & ~MT_ST_OPTIONS) & 0xff;
2086 value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2088 STp->cln_mode = value;
2089 STp->cln_sense_mask = (options >> 8) & 0xff;
2090 STp->cln_sense_value = (options >> 16) & 0xff;
2092 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2093 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2094 } else if (code == MT_ST_DEF_OPTIONS) {
2095 code = (options & ~MT_ST_CLEAR_DEFAULT);
2096 value = (options & MT_ST_CLEAR_DEFAULT);
2097 if (code == MT_ST_DEF_DENSITY) {
2098 if (value == MT_ST_CLEAR_DEFAULT) {
2099 STm->default_density = (-1);
2100 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2103 STm->default_density = value & 0xff;
2104 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2105 name, STm->default_density));
2106 if (STp->ready == ST_READY) {
2107 STp->density_changed = FALSE;
2108 set_mode_densblk(STp, STm);
2111 } else if (code == MT_ST_DEF_DRVBUFFER) {
2112 if (value == MT_ST_CLEAR_DEFAULT) {
2113 STp->default_drvbuffer = 0xff;
2114 DEBC( printk(KERN_INFO
2115 "%s: Drive buffer default disabled.\n", name));
2117 STp->default_drvbuffer = value & 7;
2118 DEBC( printk(KERN_INFO
2119 "%s: Drive buffer default set to %x\n",
2120 name, STp->default_drvbuffer));
2121 if (STp->ready == ST_READY)
2122 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2124 } else if (code == MT_ST_DEF_COMPRESSION) {
2125 if (value == MT_ST_CLEAR_DEFAULT) {
2126 STm->default_compression = ST_DONT_TOUCH;
2127 DEBC( printk(KERN_INFO
2128 "%s: Compression default disabled.\n", name));
2130 if ((value & 0xff00) != 0) {
2131 STp->c_algo = (value & 0xff00) >> 8;
2132 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2133 name, STp->c_algo));
2135 if ((value & 0xff) != 0xff) {
2136 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2137 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2138 name, (value & 1)));
2139 if (STp->ready == ST_READY) {
2140 STp->compression_changed = FALSE;
2141 st_compression(STp, (STm->default_compression == ST_YES));
2152 #define MODE_HEADER_LENGTH 4
2154 /* Mode header and page byte offsets */
2155 #define MH_OFF_DATA_LENGTH 0
2156 #define MH_OFF_MEDIUM_TYPE 1
2157 #define MH_OFF_DEV_SPECIFIC 2
2158 #define MH_OFF_BDESCS_LENGTH 3
2159 #define MP_OFF_PAGE_NBR 0
2160 #define MP_OFF_PAGE_LENGTH 1
2162 /* Mode header and page bit masks */
2163 #define MH_BIT_WP 0x80
2164 #define MP_MSK_PAGE_NBR 0x3f
2166 /* Don't return block descriptors */
2167 #define MODE_SENSE_OMIT_BDESCS 0x08
2169 #define MODE_SELECT_PAGE_FORMAT 0x10
2171 /* Read a mode page into the tape buffer. The block descriptors are included
2172 if incl_block_descs is true. The page control is ored to the page number
2173 parameter, if necessary. */
2174 static int read_mode_page(Scsi_Tape *STp, int page, int omit_block_descs)
2176 unsigned char cmd[MAX_COMMAND_SIZE];
2177 Scsi_Request *SRpnt = NULL;
2179 memset(cmd, 0, MAX_COMMAND_SIZE);
2180 cmd[0] = MODE_SENSE;
2181 if (omit_block_descs)
2182 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2186 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], SCSI_DATA_READ,
2187 STp->device->timeout, 0, TRUE);
2189 return (STp->buffer)->syscall_result;
2191 scsi_release_request(SRpnt);
2193 return (STp->buffer)->syscall_result;
2197 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2198 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2199 static int write_mode_page(Scsi_Tape *STp, int page, int slow)
2202 unsigned char cmd[MAX_COMMAND_SIZE];
2203 Scsi_Request *SRpnt = NULL;
2205 memset(cmd, 0, MAX_COMMAND_SIZE);
2206 cmd[0] = MODE_SELECT;
2207 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2208 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2209 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2211 /* Clear reserved fields */
2212 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2213 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2214 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2215 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2217 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], SCSI_DATA_WRITE,
2218 (slow ? STp->long_timeout : STp->device->timeout), 0, TRUE);
2220 return (STp->buffer)->syscall_result;
2222 scsi_release_request(SRpnt);
2224 return (STp->buffer)->syscall_result;
2228 #define COMPRESSION_PAGE 0x0f
2229 #define COMPRESSION_PAGE_LENGTH 16
2231 #define CP_OFF_DCE_DCC 2
2232 #define CP_OFF_C_ALGO 7
2234 #define DCE_MASK 0x80
2235 #define DCC_MASK 0x40
2236 #define RED_MASK 0x60
2239 /* Control the compression with mode page 15. Algorithm not changed if zero.
2241 The block descriptors are read and written because Sony SDT-7000 does not
2242 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2243 Including block descriptors should not cause any harm to other drives. */
2245 static int st_compression(Scsi_Tape * STp, int state)
2248 int mpoffs; /* Offset to mode page start */
2249 unsigned char *b_data = (STp->buffer)->b_data;
2250 DEB( char *name = tape_name(STp); )
2252 if (STp->ready != ST_READY)
2255 /* Read the current page contents */
2256 retval = read_mode_page(STp, COMPRESSION_PAGE, FALSE);
2258 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2263 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2264 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2265 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2267 /* Check if compression can be changed */
2268 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2269 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2275 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2276 if (STp->c_algo != 0)
2277 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2280 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2281 if (STp->c_algo != 0)
2282 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2285 retval = write_mode_page(STp, COMPRESSION_PAGE, FALSE);
2287 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2290 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2293 STp->compression_changed = TRUE;
2298 /* Process the load and unload commands (does unload if the load code is zero) */
2299 static int do_load_unload(Scsi_Tape *STp, struct file *filp, int load_code)
2301 int retval = (-EIO), timeout;
2302 DEB( char *name = tape_name(STp); )
2303 unsigned char cmd[MAX_COMMAND_SIZE];
2305 Scsi_Request *SRpnt;
2307 if (STp->ready != ST_READY && !load_code) {
2308 if (STp->ready == ST_NO_TAPE)
2309 return (-ENOMEDIUM);
2314 memset(cmd, 0, MAX_COMMAND_SIZE);
2315 cmd[0] = START_STOP;
2319 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2321 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2322 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2323 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2324 name, (cmd[4]) ? "" : "un",
2325 load_code - MT_ST_HPLOADER_OFFSET));
2326 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2328 if (STp->immediate) {
2329 cmd[1] = 1; /* Don't wait for completion */
2330 timeout = STp->device->timeout;
2333 timeout = STp->long_timeout;
2337 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2339 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2342 SRpnt = st_do_scsi(NULL, STp, cmd, 0, SCSI_DATA_NONE,
2343 timeout, MAX_RETRIES, TRUE);
2345 return (STp->buffer)->syscall_result;
2347 retval = (STp->buffer)->syscall_result;
2348 scsi_release_request(SRpnt);
2350 if (!retval) { /* SCSI command successful */
2353 STp->rew_at_close = 0;
2354 STp->ready = ST_NO_TAPE;
2357 STp->rew_at_close = STp->autorew_dev;
2358 retval = check_tape(STp, filp);
2364 STps = &(STp->ps[STp->partition]);
2365 STps->drv_file = STps->drv_block = (-1);
2372 /* Internal ioctl function */
2373 static int st_int_ioctl(Scsi_Tape *STp, unsigned int cmd_in, unsigned long arg)
2379 unsigned char cmd[MAX_COMMAND_SIZE];
2380 Scsi_Request *SRpnt;
2382 int fileno, blkno, at_sm, undone;
2383 int datalen = 0, direction = SCSI_DATA_NONE;
2384 char *name = tape_name(STp);
2386 WARN_ON(STp->buffer->do_dio != 0);
2387 if (STp->ready != ST_READY) {
2388 if (STp->ready == ST_NO_TAPE)
2389 return (-ENOMEDIUM);
2393 timeout = STp->long_timeout;
2394 STps = &(STp->ps[STp->partition]);
2395 fileno = STps->drv_file;
2396 blkno = STps->drv_block;
2397 at_sm = STps->at_sm;
2399 memset(cmd, 0, MAX_COMMAND_SIZE);
2402 chg_eof = FALSE; /* Changed from the FSF after this */
2405 cmd[1] = 0x01; /* Space FileMarks */
2406 cmd[2] = (arg >> 16);
2407 cmd[3] = (arg >> 8);
2409 DEBC(printk(ST_DEB_MSG "%s: Spacing tape forward over %d filemarks.\n",
2410 name, cmd[2] * 65536 + cmd[3] * 256 + cmd[4]));
2414 at_sm &= (arg == 0);
2417 chg_eof = FALSE; /* Changed from the FSF after this */
2420 cmd[1] = 0x01; /* Space FileMarks */
2422 cmd[2] = (ltmp >> 16);
2423 cmd[3] = (ltmp >> 8);
2428 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2430 "%s: Spacing tape backward over %ld filemarks.\n",
2435 blkno = (-1); /* We can't know the block number */
2436 at_sm &= (arg == 0);
2440 cmd[1] = 0x00; /* Space Blocks */
2441 cmd[2] = (arg >> 16);
2442 cmd[3] = (arg >> 8);
2444 DEBC(printk(ST_DEB_MSG "%s: Spacing tape forward %d blocks.\n", name,
2445 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]));
2448 at_sm &= (arg == 0);
2452 cmd[1] = 0x00; /* Space Blocks */
2454 cmd[2] = (ltmp >> 16);
2455 cmd[3] = (ltmp >> 8);
2460 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2462 "%s: Spacing tape backward %ld blocks.\n", name, (-ltmp));
2466 at_sm &= (arg == 0);
2470 cmd[1] = 0x04; /* Space Setmarks */
2471 cmd[2] = (arg >> 16);
2472 cmd[3] = (arg >> 8);
2474 DEBC(printk(ST_DEB_MSG "%s: Spacing tape forward %d setmarks.\n", name,
2475 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]));
2477 blkno = fileno = (-1);
2483 cmd[1] = 0x04; /* Space Setmarks */
2485 cmd[2] = (ltmp >> 16);
2486 cmd[3] = (ltmp >> 8);
2491 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2492 printk(ST_DEB_MSG "%s: Spacing tape backward %ld setmarks.\n",
2496 blkno = fileno = (-1);
2502 if (STp->write_prot)
2504 cmd[0] = WRITE_FILEMARKS;
2505 if (cmd_in == MTWSM)
2507 cmd[2] = (arg >> 16);
2508 cmd[3] = (arg >> 8);
2510 timeout = STp->device->timeout;
2512 if (cmd_in == MTWEOF)
2513 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2514 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2516 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2517 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2522 at_sm = (cmd_in == MTWSM);
2525 cmd[0] = REZERO_UNIT;
2526 if (STp->immediate) {
2527 cmd[1] = 1; /* Don't wait for completion */
2528 timeout = STp->device->timeout;
2530 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2531 fileno = blkno = at_sm = 0;
2534 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2535 return 0; /* Should do something ? */
2538 cmd[0] = START_STOP;
2539 if (STp->immediate) {
2540 cmd[1] = 1; /* Don't wait for completion */
2541 timeout = STp->device->timeout;
2544 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2545 fileno = blkno = at_sm = 0;
2548 if (!STp->fast_mteom) {
2549 /* space to the end of tape */
2550 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2551 fileno = STps->drv_file;
2552 if (STps->eof >= ST_EOD_1)
2554 /* The next lines would hide the number of spaced FileMarks
2555 That's why I inserted the previous lines. I had no luck
2556 with detecting EOM with FSF, so we go now to EOM.
2562 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2568 if (STp->write_prot)
2571 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2572 if (STp->immediate) {
2573 cmd[1] |= 2; /* Don't wait for completion */
2574 timeout = STp->device->timeout;
2577 timeout = STp->long_timeout * 8;
2579 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2580 fileno = blkno = at_sm = 0;
2582 case MTSETBLK: /* Set block length */
2583 case MTSETDENSITY: /* Set tape density */
2584 case MTSETDRVBUFFER: /* Set drive buffering */
2585 case SET_DENS_AND_BLK: /* Set density and block size */
2587 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2588 return (-EIO); /* Not allowed if data in buffer */
2589 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2590 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2591 STp->max_block > 0 &&
2592 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2593 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2594 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2597 cmd[0] = MODE_SELECT;
2598 if ((STp->use_pf & USE_PF))
2599 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2600 cmd[4] = datalen = 12;
2601 direction = SCSI_DATA_WRITE;
2603 memset((STp->buffer)->b_data, 0, 12);
2604 if (cmd_in == MTSETDRVBUFFER)
2605 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2607 (STp->buffer)->b_data[2] =
2608 STp->drv_buffer << 4;
2609 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2610 if (cmd_in == MTSETDENSITY) {
2611 (STp->buffer)->b_data[4] = arg;
2612 STp->density_changed = TRUE; /* At least we tried ;-) */
2613 } else if (cmd_in == SET_DENS_AND_BLK)
2614 (STp->buffer)->b_data[4] = arg >> 24;
2616 (STp->buffer)->b_data[4] = STp->density;
2617 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2618 ltmp = arg & MT_ST_BLKSIZE_MASK;
2619 if (cmd_in == MTSETBLK)
2620 STp->blksize_changed = TRUE; /* At least we tried ;-) */
2622 ltmp = STp->block_size;
2623 (STp->buffer)->b_data[9] = (ltmp >> 16);
2624 (STp->buffer)->b_data[10] = (ltmp >> 8);
2625 (STp->buffer)->b_data[11] = ltmp;
2626 timeout = STp->device->timeout;
2628 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2630 "%s: Setting block size to %d bytes.\n", name,
2631 (STp->buffer)->b_data[9] * 65536 +
2632 (STp->buffer)->b_data[10] * 256 +
2633 (STp->buffer)->b_data[11]);
2634 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2636 "%s: Setting density code to %x.\n", name,
2637 (STp->buffer)->b_data[4]);
2638 if (cmd_in == MTSETDRVBUFFER)
2640 "%s: Setting drive buffer code to %d.\n", name,
2641 ((STp->buffer)->b_data[2] >> 4) & 7);
2648 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2649 timeout, MAX_RETRIES, TRUE);
2651 return (STp->buffer)->syscall_result;
2653 ioctl_result = (STp->buffer)->syscall_result;
2655 if (!ioctl_result) { /* SCSI command successful */
2656 scsi_release_request(SRpnt);
2658 STps->drv_block = blkno;
2659 STps->drv_file = fileno;
2660 STps->at_sm = at_sm;
2662 if (cmd_in == MTBSFM)
2663 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2664 else if (cmd_in == MTFSFM)
2665 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2667 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2668 int old_block_size = STp->block_size;
2669 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2670 if (STp->block_size != 0) {
2671 if (old_block_size == 0)
2672 normalize_buffer(STp->buffer);
2673 (STp->buffer)->buffer_blocks =
2674 (STp->buffer)->buffer_size / STp->block_size;
2676 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2677 if (cmd_in == SET_DENS_AND_BLK)
2678 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2679 } else if (cmd_in == MTSETDRVBUFFER)
2680 STp->drv_buffer = (arg & 7);
2681 else if (cmd_in == MTSETDENSITY)
2684 if (cmd_in == MTEOM)
2686 else if (cmd_in == MTFSF)
2689 STps->eof = ST_NOEOF;
2691 } else { /* SCSI command was not completely successful. Don't return
2692 from this block without releasing the SCSI command block! */
2694 if (SRpnt->sr_sense_buffer[2] & 0x40) {
2695 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2696 cmd_in != MTBSR && cmd_in != MTBSS)
2697 STps->eof = ST_EOM_OK;
2698 STps->drv_block = 0;
2701 undone = ((SRpnt->sr_sense_buffer[3] << 24) +
2702 (SRpnt->sr_sense_buffer[4] << 16) +
2703 (SRpnt->sr_sense_buffer[5] << 8) +
2704 SRpnt->sr_sense_buffer[6]);
2706 if (cmd_in == MTWEOF &&
2707 (SRpnt->sr_sense_buffer[0] & 0x70) == 0x70 &&
2708 (SRpnt->sr_sense_buffer[2] & 0x4f) == 0x40 &&
2709 ((SRpnt->sr_sense_buffer[0] & 0x80) == 0 || undone == 0)) {
2710 ioctl_result = 0; /* EOF written succesfully at EOM */
2713 STps->drv_file = fileno;
2714 STps->eof = ST_NOEOF;
2715 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2717 STps->drv_file = fileno - undone;
2719 STps->drv_file = fileno;
2720 STps->drv_block = 0;
2721 STps->eof = ST_NOEOF;
2722 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2723 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2725 if (STps->drv_file >= 0)
2726 STps->drv_file = fileno + undone;
2727 STps->drv_block = 0;
2728 STps->eof = ST_NOEOF;
2729 } else if (cmd_in == MTFSR) {
2730 if (SRpnt->sr_sense_buffer[2] & 0x80) { /* Hit filemark */
2731 if (STps->drv_file >= 0)
2733 STps->drv_block = 0;
2736 if (blkno >= undone)
2737 STps->drv_block = blkno - undone;
2739 STps->drv_block = (-1);
2740 STps->eof = ST_NOEOF;
2742 } else if (cmd_in == MTBSR) {
2743 if (SRpnt->sr_sense_buffer[2] & 0x80) { /* Hit filemark */
2745 STps->drv_block = (-1);
2747 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2749 if (STps->drv_block >= 0)
2750 STps->drv_block = blkno + undone;
2752 STps->eof = ST_NOEOF;
2753 } else if (cmd_in == MTEOM) {
2754 STps->drv_file = (-1);
2755 STps->drv_block = (-1);
2757 } else if (cmd_in == MTSETBLK ||
2758 cmd_in == MTSETDENSITY ||
2759 cmd_in == MTSETDRVBUFFER ||
2760 cmd_in == SET_DENS_AND_BLK) {
2761 if ((SRpnt->sr_sense_buffer[2] & 0x0f) == ILLEGAL_REQUEST &&
2762 !(STp->use_pf & PF_TESTED)) {
2763 /* Try the other possible state of Page Format if not
2765 STp->use_pf = !STp->use_pf | PF_TESTED;
2766 scsi_release_request(SRpnt);
2768 return st_int_ioctl(STp, cmd_in, arg);
2771 STps->eof = ST_NOEOF;
2773 if ((SRpnt->sr_sense_buffer[2] & 0x0f) == BLANK_CHECK)
2776 scsi_release_request(SRpnt);
2780 return ioctl_result;
2784 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2787 static int get_location(Scsi_Tape *STp, unsigned int *block, int *partition,
2791 unsigned char scmd[MAX_COMMAND_SIZE];
2792 Scsi_Request *SRpnt;
2793 DEB( char *name = tape_name(STp); )
2795 if (STp->ready != ST_READY)
2798 memset(scmd, 0, MAX_COMMAND_SIZE);
2799 if ((STp->device)->scsi_level < SCSI_2) {
2800 scmd[0] = QFA_REQUEST_BLOCK;
2803 scmd[0] = READ_POSITION;
2804 if (!logical && !STp->scsi2_logical)
2807 SRpnt = st_do_scsi(NULL, STp, scmd, 20, SCSI_DATA_READ, STp->device->timeout,
2808 MAX_READY_RETRIES, TRUE);
2810 return (STp->buffer)->syscall_result;
2812 if ((STp->buffer)->syscall_result != 0 ||
2813 (STp->device->scsi_level >= SCSI_2 &&
2814 ((STp->buffer)->b_data[0] & 4) != 0)) {
2815 *block = *partition = 0;
2816 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
2820 if ((STp->device)->scsi_level < SCSI_2) {
2821 *block = ((STp->buffer)->b_data[0] << 16)
2822 + ((STp->buffer)->b_data[1] << 8)
2823 + (STp->buffer)->b_data[2];
2826 *block = ((STp->buffer)->b_data[4] << 24)
2827 + ((STp->buffer)->b_data[5] << 16)
2828 + ((STp->buffer)->b_data[6] << 8)
2829 + (STp->buffer)->b_data[7];
2830 *partition = (STp->buffer)->b_data[1];
2831 if (((STp->buffer)->b_data[0] & 0x80) &&
2832 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
2833 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
2835 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
2836 *block, *partition));
2838 scsi_release_request(SRpnt);
2845 /* Set the tape block and partition. Negative partition means that only the
2846 block should be set in vendor specific way. */
2847 static int set_location(Scsi_Tape *STp, unsigned int block, int partition,
2854 unsigned char scmd[MAX_COMMAND_SIZE];
2855 Scsi_Request *SRpnt;
2856 DEB( char *name = tape_name(STp); )
2858 if (STp->ready != ST_READY)
2860 timeout = STp->long_timeout;
2861 STps = &(STp->ps[STp->partition]);
2863 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
2864 name, block, partition));
2865 DEB(if (partition < 0)
2868 /* Update the location at the partition we are leaving */
2869 if ((!STp->can_partitions && partition != 0) ||
2870 partition >= ST_NBR_PARTITIONS)
2872 if (partition != STp->partition) {
2873 if (get_location(STp, &blk, &p, 1))
2874 STps->last_block_valid = FALSE;
2876 STps->last_block_valid = TRUE;
2877 STps->last_block_visited = blk;
2878 DEBC(printk(ST_DEB_MSG
2879 "%s: Visited block %d for partition %d saved.\n",
2880 name, blk, STp->partition));
2884 memset(scmd, 0, MAX_COMMAND_SIZE);
2885 if ((STp->device)->scsi_level < SCSI_2) {
2886 scmd[0] = QFA_SEEK_BLOCK;
2887 scmd[2] = (block >> 16);
2888 scmd[3] = (block >> 8);
2893 scmd[3] = (block >> 24);
2894 scmd[4] = (block >> 16);
2895 scmd[5] = (block >> 8);
2897 if (!logical && !STp->scsi2_logical)
2899 if (STp->partition != partition) {
2901 scmd[8] = partition;
2902 DEBC(printk(ST_DEB_MSG
2903 "%s: Trying to change partition from %d to %d\n",
2904 name, STp->partition, partition));
2907 if (STp->immediate) {
2908 scmd[1] |= 1; /* Don't wait for completion */
2909 timeout = STp->device->timeout;
2912 SRpnt = st_do_scsi(NULL, STp, scmd, 0, SCSI_DATA_NONE,
2913 timeout, MAX_READY_RETRIES, TRUE);
2915 return (STp->buffer)->syscall_result;
2917 STps->drv_block = STps->drv_file = (-1);
2918 STps->eof = ST_NOEOF;
2919 if ((STp->buffer)->syscall_result != 0) {
2921 if (STp->can_partitions &&
2922 (STp->device)->scsi_level >= SCSI_2 &&
2923 (p = find_partition(STp)) >= 0)
2926 if (STp->can_partitions) {
2927 STp->partition = partition;
2928 STps = &(STp->ps[partition]);
2929 if (!STps->last_block_valid ||
2930 STps->last_block_visited != block) {
2937 STps->drv_block = STps->drv_file = 0;
2941 scsi_release_request(SRpnt);
2948 /* Find the current partition number for the drive status. Called from open and
2949 returns either partition number of negative error code. */
2950 static int find_partition(Scsi_Tape *STp)
2955 if ((i = get_location(STp, &block, &partition, 1)) < 0)
2957 if (partition >= ST_NBR_PARTITIONS)
2963 /* Change the partition if necessary */
2964 static int switch_partition(Scsi_Tape *STp)
2968 if (STp->partition == STp->new_partition)
2970 STps = &(STp->ps[STp->new_partition]);
2971 if (!STps->last_block_valid)
2972 STps->last_block_visited = 0;
2973 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
2976 /* Functions for reading and writing the medium partition mode page. */
2978 #define PART_PAGE 0x11
2979 #define PART_PAGE_FIXED_LENGTH 8
2981 #define PP_OFF_MAX_ADD_PARTS 2
2982 #define PP_OFF_NBR_ADD_PARTS 3
2983 #define PP_OFF_FLAGS 4
2984 #define PP_OFF_PART_UNITS 6
2985 #define PP_OFF_RESERVED 7
2987 #define PP_BIT_IDP 0x20
2988 #define PP_MSK_PSUM_MB 0x10
2990 /* Get the number of partitions on the tape. As a side effect reads the
2991 mode page into the tape buffer. */
2992 static int nbr_partitions(Scsi_Tape *STp)
2995 DEB( char *name = tape_name(STp); )
2997 if (STp->ready != ST_READY)
3000 result = read_mode_page(STp, PART_PAGE, TRUE);
3003 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3007 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3008 PP_OFF_NBR_ADD_PARTS] + 1;
3009 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3016 /* Partition the tape into two partitions if size > 0 or one partition if
3019 The block descriptors are read and written because Sony SDT-7000 does not
3020 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3022 My HP C1533A drive returns only one partition size field. This is used to
3023 set the size of partition 1. There is no size field for the default partition.
3024 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3025 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3026 The following algorithm is used to accommodate both drives: if the number of
3027 partition size fields is greater than the maximum number of additional partitions
3028 in the mode page, the second field is used. Otherwise the first field is used.
3030 For Seagate DDS drives the page length must be 8 when no partitions is defined
3031 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3032 is acceptable also to some other old drives and enforced if the first partition
3033 size field is used for the first additional partition size.
3035 static int partition_tape(Scsi_Tape *STp, int size)
3037 char *name = tape_name(STp);
3039 int pgo, psd_cnt, psdo;
3042 result = read_mode_page(STp, PART_PAGE, FALSE);
3044 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3047 /* The mode page is in the buffer. Let's modify it and write it. */
3048 bp = (STp->buffer)->b_data;
3049 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3050 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3051 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3053 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3054 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3055 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3056 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3059 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3061 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3062 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3063 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3066 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3067 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3068 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3069 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3072 bp[psdo] = (size >> 8) & 0xff;
3073 bp[psdo + 1] = size & 0xff;
3075 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3076 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3077 DEBC(printk(ST_DEB_MSG
3078 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3081 bp[pgo + PP_OFF_PART_UNITS] = 0;
3082 bp[pgo + PP_OFF_RESERVED] = 0;
3083 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3085 result = write_mode_page(STp, PART_PAGE, TRUE);
3087 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3096 /* The ioctl command */
3097 static int st_ioctl(struct inode *inode, struct file *file,
3098 unsigned int cmd_in, unsigned long arg)
3100 int i, cmd_nr, cmd_type, bt;
3103 Scsi_Tape *STp = file->private_data;
3106 char *name = tape_name(STp);
3107 void __user *p = (void __user *)arg;
3109 if (down_interruptible(&STp->lock))
3110 return -ERESTARTSYS;
3113 if (debugging && !STp->in_use) {
3114 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3119 STm = &(STp->modes[STp->current_mode]);
3120 STps = &(STp->ps[STp->partition]);
3123 * If we are in the middle of error recovery, don't let anyone
3124 * else try and use this device. Also, if error recovery fails, it
3125 * may try and take the device offline, in which case all further
3126 * access to the device is prohibited.
3128 if (!scsi_block_when_processing_errors(STp->device)) {
3132 cmd_type = _IOC_TYPE(cmd_in);
3133 cmd_nr = _IOC_NR(cmd_in);
3135 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3138 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3143 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3149 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3151 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3155 if (!STm->defined &&
3156 (mtc.mt_op != MTSETDRVBUFFER &&
3157 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3162 if (!STp->pos_unknown) {
3164 if (STps->eof == ST_FM_HIT) {
3165 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3166 mtc.mt_op == MTEOM) {
3168 if (STps->drv_file >= 0)
3169 STps->drv_file += 1;
3170 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3172 if (STps->drv_file >= 0)
3173 STps->drv_file += 1;
3177 if (mtc.mt_op == MTSEEK) {
3178 /* Old position must be restored if partition will be
3180 i = !STp->can_partitions ||
3181 (STp->new_partition != STp->partition);
3183 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3184 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3185 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3186 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3187 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3188 mtc.mt_op == MTCOMPRESSION;
3190 i = flush_buffer(STp, i);
3197 * If there was a bus reset, block further access
3198 * to this device. If the user wants to rewind the tape,
3199 * then reset the flag and allow access again.
3201 if (mtc.mt_op != MTREW &&
3202 mtc.mt_op != MTOFFL &&
3203 mtc.mt_op != MTRETEN &&
3204 mtc.mt_op != MTERASE &&
3205 mtc.mt_op != MTSEEK &&
3206 mtc.mt_op != MTEOM) {
3211 /* remove this when the midlevel properly clears was_reset */
3212 STp->device->was_reset = 0;
3215 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3216 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3217 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3218 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3220 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3221 do_door_lock(STp, 0); /* Ignore result! */
3223 if (mtc.mt_op == MTSETDRVBUFFER &&
3224 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3225 retval = st_set_options(STp, mtc.mt_count);
3229 if (mtc.mt_op == MTSETPART) {
3230 if (!STp->can_partitions ||
3231 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3235 if (mtc.mt_count >= STp->nbr_partitions &&
3236 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3240 if (mtc.mt_count >= STp->nbr_partitions) {
3244 STp->new_partition = mtc.mt_count;
3249 if (mtc.mt_op == MTMKPART) {
3250 if (!STp->can_partitions) {
3254 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3255 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3259 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3260 STp->ps[i].rw = ST_IDLE;
3261 STp->ps[i].at_sm = 0;
3262 STp->ps[i].last_block_valid = FALSE;
3264 STp->partition = STp->new_partition = 0;
3265 STp->nbr_partitions = 1; /* Bad guess ?-) */
3266 STps->drv_block = STps->drv_file = 0;
3271 if (mtc.mt_op == MTSEEK) {
3272 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3273 if (!STp->can_partitions)
3274 STp->ps[0].rw = ST_IDLE;
3279 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3280 retval = do_load_unload(STp, file, 0);
3284 if (mtc.mt_op == MTLOAD) {
3285 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3289 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3290 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3294 if (STp->can_partitions && STp->ready == ST_READY &&
3295 (i = switch_partition(STp)) < 0) {
3300 if (mtc.mt_op == MTCOMPRESSION)
3301 retval = st_compression(STp, (mtc.mt_count & 1));
3303 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3306 if (!STm->defined) {
3311 if ((i = flush_buffer(STp, FALSE)) < 0) {
3315 if (STp->can_partitions &&
3316 (i = switch_partition(STp)) < 0) {
3321 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3322 struct mtget mt_status;
3324 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3329 mt_status.mt_type = STp->tape_type;
3330 mt_status.mt_dsreg =
3331 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3332 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3333 mt_status.mt_blkno = STps->drv_block;
3334 mt_status.mt_fileno = STps->drv_file;
3335 if (STp->block_size != 0) {
3336 if (STps->rw == ST_WRITING)
3337 mt_status.mt_blkno +=
3338 (STp->buffer)->buffer_bytes / STp->block_size;
3339 else if (STps->rw == ST_READING)
3340 mt_status.mt_blkno -=
3341 ((STp->buffer)->buffer_bytes +
3342 STp->block_size - 1) / STp->block_size;
3345 mt_status.mt_gstat = 0;
3346 if (STp->drv_write_prot)
3347 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3348 if (mt_status.mt_blkno == 0) {
3349 if (mt_status.mt_fileno == 0)
3350 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3352 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3354 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3355 mt_status.mt_resid = STp->partition;
3356 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3357 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3358 else if (STps->eof >= ST_EOM_OK)
3359 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3360 if (STp->density == 1)
3361 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3362 else if (STp->density == 2)
3363 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3364 else if (STp->density == 3)
3365 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3366 if (STp->ready == ST_READY)
3367 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3368 if (STp->ready == ST_NO_TAPE)
3369 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3371 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3372 if (STm->do_async_writes ||
3373 (STm->do_buffer_writes && STp->block_size != 0) ||
3374 STp->drv_buffer != 0)
3375 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3376 if (STp->cleaning_req)
3377 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3379 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3385 STp->recover_reg = 0; /* Clear after read */
3388 } /* End of MTIOCGET */
3389 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3390 struct mtpos mt_pos;
3391 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3395 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3399 mt_pos.mt_blkno = blk;
3400 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3407 case SCSI_IOCTL_GET_IDLUN:
3408 case SCSI_IOCTL_GET_BUS_NUMBER:
3411 i = scsi_cmd_ioctl(file, STp->disk, cmd_in, p);
3416 return scsi_ioctl(STp->device, cmd_in, p);
3424 /* Try to allocate a new tape buffer. Calling function must not hold
3427 new_tape_buffer(int from_initialization, int need_dma, int max_sg)
3429 int i, priority, got = 0, segs = 0;
3432 if (from_initialization)
3433 priority = GFP_ATOMIC;
3435 priority = GFP_KERNEL;
3437 i = sizeof(ST_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3438 max_sg * sizeof(struct st_buf_fragment);
3439 tb = kmalloc(i, priority);
3441 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3445 tb->frp_segs = tb->orig_frp_segs = segs;
3446 tb->use_sg = max_sg;
3448 tb->b_data = page_address(tb->sg[0].page);
3449 tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
3453 tb->buffer_size = got;
3459 /* Try to allocate enough space in the tape buffer */
3460 static int enlarge_buffer(ST_buffer * STbuffer, int new_size, int need_dma)
3462 int segs, nbr, max_segs, b_size, priority, order, got;
3464 if (new_size <= STbuffer->buffer_size)
3467 if (STbuffer->buffer_size <= PAGE_SIZE)
3468 normalize_buffer(STbuffer); /* Avoid extra segment */
3470 max_segs = STbuffer->use_sg;
3471 nbr = max_segs - STbuffer->frp_segs;
3475 priority = GFP_KERNEL | __GFP_NOWARN;
3477 priority |= GFP_DMA;
3478 for (b_size = PAGE_SIZE, order=0;
3479 b_size < new_size - STbuffer->buffer_size;
3480 order++, b_size *= 2)
3483 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3484 segs < max_segs && got < new_size;) {
3485 STbuffer->frp[segs].page = alloc_pages(priority, order);
3486 if (STbuffer->frp[segs].page == NULL) {
3487 if (new_size - got <= (max_segs - segs) * b_size / 2) {
3488 b_size /= 2; /* Large enough for the rest of the buffers */
3492 DEB(STbuffer->buffer_size = got);
3493 normalize_buffer(STbuffer);
3496 STbuffer->frp[segs].length = b_size;
3497 STbuffer->frp_segs += 1;
3499 STbuffer->buffer_size = got;
3502 STbuffer->b_data = page_address(STbuffer->frp[0].page);
3508 /* Release the extra buffer */
3509 static void normalize_buffer(ST_buffer * STbuffer)
3513 for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3514 order = get_order(STbuffer->frp[i].length);
3515 __free_pages(STbuffer->frp[i].page, order);
3516 STbuffer->buffer_size -= STbuffer->frp[i].length;
3518 STbuffer->frp_segs = STbuffer->orig_frp_segs;
3519 STbuffer->frp_sg_current = 0;
3523 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3524 negative error code. */
3525 static int append_to_buffer(const char __user *ubp, ST_buffer * st_bp, int do_count)
3527 int i, cnt, res, offset;
3529 for (i = 0, offset = st_bp->buffer_bytes;
3530 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3531 offset -= st_bp->frp[i].length;
3532 if (i == st_bp->frp_segs) { /* Should never happen */
3533 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3536 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3537 cnt = st_bp->frp[i].length - offset < do_count ?
3538 st_bp->frp[i].length - offset : do_count;
3539 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3543 st_bp->buffer_bytes += cnt;
3547 if (do_count) /* Should never happen */
3554 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3555 negative error code. */
3556 static int from_buffer(ST_buffer * st_bp, char __user *ubp, int do_count)
3558 int i, cnt, res, offset;
3560 for (i = 0, offset = st_bp->read_pointer;
3561 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3562 offset -= st_bp->frp[i].length;
3563 if (i == st_bp->frp_segs) { /* Should never happen */
3564 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3567 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3568 cnt = st_bp->frp[i].length - offset < do_count ?
3569 st_bp->frp[i].length - offset : do_count;
3570 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3574 st_bp->buffer_bytes -= cnt;
3575 st_bp->read_pointer += cnt;
3579 if (do_count) /* Should never happen */
3586 /* Move data towards start of buffer */
3587 static void move_buffer_data(ST_buffer * st_bp, int offset)
3589 int src_seg, dst_seg, src_offset = 0, dst_offset;
3595 total=st_bp->buffer_bytes - offset;
3596 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3597 src_offset = offset;
3598 if (src_offset < st_bp->frp[src_seg].length)
3600 offset -= st_bp->frp[src_seg].length;
3603 st_bp->buffer_bytes = st_bp->read_pointer = total;
3604 for (dst_seg=dst_offset=0; total > 0; ) {
3605 count = min(st_bp->frp[dst_seg].length - dst_offset,
3606 st_bp->frp[src_seg].length - src_offset);
3607 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3608 page_address(st_bp->frp[src_seg].page) + src_offset, count);
3609 src_offset += count;
3610 if (src_offset >= st_bp->frp[src_seg].length) {
3614 dst_offset += count;
3615 if (dst_offset >= st_bp->frp[dst_seg].length) {
3624 /* Fill the s/g list up to the length required for this transfer */
3625 static void buf_to_sg(ST_buffer *STbp, unsigned int length)
3629 struct scatterlist *sg;
3630 struct st_buf_fragment *frp;
3632 if (length == STbp->frp_sg_current)
3633 return; /* work already done */
3635 sg = &(STbp->sg[0]);
3637 for (i=count=0; count < length; i++) {
3638 sg[i].page = frp[i].page;
3639 if (length - count > frp[i].length)
3640 sg[i].length = frp[i].length;
3642 sg[i].length = length - count;
3643 count += sg[i].length;
3647 STbp->frp_sg_current = length;
3651 /* Validate the options from command line or module parameters */
3652 static void validate_options(void)
3655 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3656 if (max_sg_segs >= ST_FIRST_SG)
3657 st_max_sg_segs = max_sg_segs;
3661 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3663 static int __init st_setup(char *str)
3665 int i, len, ints[5];
3668 stp = get_options(str, ARRAY_SIZE(ints), ints);
3671 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3673 *parms[i].val = ints[i + 1];
3675 while (stp != NULL) {
3676 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3677 len = strlen(parms[i].name);
3678 if (!strncmp(stp, parms[i].name, len) &&
3679 (*(stp + len) == ':' || *(stp + len) == '=')) {
3682 simple_strtoul(stp + len + 1, NULL, 0);
3684 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3689 if (i >= sizeof(parms) / sizeof(struct st_dev_parm))
3690 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3692 stp = strchr(stp, ',');
3703 __setup("st=", st_setup);
3707 static struct file_operations st_fops =
3709 .owner = THIS_MODULE,
3715 .release = st_release,
3718 static int st_probe(struct device *dev)
3720 struct scsi_device *SDp = to_scsi_device(dev);
3721 struct gendisk *disk = NULL;
3722 struct cdev *cdev = NULL;
3723 Scsi_Tape *tpnt = NULL;
3727 int i, j, mode, dev_num, error;
3731 if (SDp->type != TYPE_TAPE)
3733 if ((stp = st_incompatible(SDp))) {
3735 "st: Found incompatible tape at scsi%d, channel %d, id %d, lun %d\n",
3736 SDp->host->host_no, SDp->channel, SDp->id, SDp->lun);
3737 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3741 i = SDp->host->sg_tablesize;
3742 if (st_max_sg_segs < i)
3744 buffer = new_tape_buffer(TRUE, (SDp->host)->unchecked_isa_dma, i);
3745 if (buffer == NULL) {
3746 printk(KERN_ERR "st: Can't allocate new tape buffer. Device not attached.\n");
3750 disk = alloc_disk(1);
3752 printk(KERN_ERR "st: out of memory. Device not attached.\n");
3753 goto out_buffer_free;
3756 write_lock(&st_dev_arr_lock);
3757 if (st_nr_dev >= st_dev_max) {
3761 tmp_dev_max = max(st_nr_dev * 2, 8);
3762 if (tmp_dev_max > ST_MAX_TAPES)
3763 tmp_dev_max = ST_MAX_TAPES;
3764 if (tmp_dev_max <= st_nr_dev) {
3765 write_unlock(&st_dev_arr_lock);
3766 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
3771 tmp_da = kmalloc(tmp_dev_max * sizeof(Scsi_Tape *), GFP_ATOMIC);
3772 if (tmp_da == NULL) {
3773 write_unlock(&st_dev_arr_lock);
3774 printk(KERN_ERR "st: Can't extend device array.\n");
3778 memset(tmp_da, 0, tmp_dev_max * sizeof(Scsi_Tape *));
3779 if (scsi_tapes != NULL) {
3780 memcpy(tmp_da, scsi_tapes,
3781 st_dev_max * sizeof(Scsi_Tape *));
3784 scsi_tapes = tmp_da;
3786 st_dev_max = tmp_dev_max;
3789 for (i = 0; i < st_dev_max; i++)
3790 if (scsi_tapes[i] == NULL)
3792 if (i >= st_dev_max)
3793 panic("scsi_devices corrupt (st)");
3795 tpnt = kmalloc(sizeof(Scsi_Tape), GFP_ATOMIC);
3797 write_unlock(&st_dev_arr_lock);
3798 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
3801 memset(tpnt, 0, sizeof(Scsi_Tape));
3803 sprintf(disk->disk_name, "st%d", i);
3804 disk->private_data = &tpnt->driver;
3805 disk->queue = SDp->request_queue;
3806 tpnt->driver = &st_template;
3807 scsi_tapes[i] = tpnt;
3811 if (SDp->scsi_level <= 2)
3812 tpnt->tape_type = MT_ISSCSI1;
3814 tpnt->tape_type = MT_ISSCSI2;
3816 tpnt->buffer = buffer;
3821 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
3822 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
3823 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
3825 tpnt->do_auto_lock = ST_AUTO_LOCK;
3826 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
3827 tpnt->can_partitions = 0;
3828 tpnt->two_fm = ST_TWO_FM;
3829 tpnt->fast_mteom = ST_FAST_MTEOM;
3830 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
3831 tpnt->immediate = ST_NOWAIT;
3832 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
3833 tpnt->partition = 0;
3834 tpnt->new_partition = 0;
3835 tpnt->nbr_partitions = 0;
3836 tpnt->device->timeout = ST_TIMEOUT;
3837 tpnt->long_timeout = ST_LONG_TIMEOUT;
3838 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
3840 bounce_limit = scsi_calculate_bounce_limit(SDp->host) >> PAGE_SHIFT;
3841 if (bounce_limit > ULONG_MAX)
3842 bounce_limit = ULONG_MAX;
3843 tpnt->max_pfn = bounce_limit;
3845 for (i = 0; i < ST_NBR_MODES; i++) {
3846 STm = &(tpnt->modes[i]);
3847 STm->defined = FALSE;
3848 STm->sysv = ST_SYSV;
3849 STm->defaults_for_writes = 0;
3850 STm->do_async_writes = ST_ASYNC_WRITES;
3851 STm->do_buffer_writes = ST_BUFFER_WRITES;
3852 STm->do_read_ahead = ST_READ_AHEAD;
3853 STm->default_compression = ST_DONT_TOUCH;
3854 STm->default_blksize = (-1); /* No forced size */
3855 STm->default_density = (-1); /* No forced density */
3858 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3859 STps = &(tpnt->ps[i]);
3861 STps->eof = ST_NOEOF;
3863 STps->last_block_valid = FALSE;
3864 STps->drv_block = (-1);
3865 STps->drv_file = (-1);
3868 tpnt->current_mode = 0;
3869 tpnt->modes[0].defined = TRUE;
3871 tpnt->density_changed = tpnt->compression_changed =
3872 tpnt->blksize_changed = FALSE;
3873 init_MUTEX(&tpnt->lock);
3876 write_unlock(&st_dev_arr_lock);
3878 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
3879 STm = &(tpnt->modes[mode]);
3880 for (j=0; j < 2; j++) {
3881 cdev = cdev_alloc();
3884 "st%d: out of memory. Device not attached.\n",
3888 cdev->owner = THIS_MODULE;
3889 cdev->ops = &st_fops;
3891 error = cdev_add(cdev,
3892 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
3895 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
3896 dev_num, j ? "non" : "auto", mode);
3897 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
3900 STm->cdevs[j] = cdev;
3903 do_create_class_files(tpnt, dev_num, mode);
3906 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
3907 /* Make sure that the minor numbers corresponding to the four
3908 first modes always get the same names */
3909 i = mode << (4 - ST_NBR_MODE_BITS);
3911 devfs_mk_cdev(MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, 0)),
3912 S_IFCHR | S_IRUGO | S_IWUGO,
3913 "%s/mt%s", SDp->devfs_name, st_formats[i]);
3914 /* No-rewind entry */
3915 devfs_mk_cdev(MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, 1)),
3916 S_IFCHR | S_IRUGO | S_IWUGO,
3917 "%s/mt%sn", SDp->devfs_name, st_formats[i]);
3919 disk->number = devfs_register_tape(SDp->devfs_name);
3922 "Attached scsi tape %s at scsi%d, channel %d, id %d, lun %d\n",
3923 tape_name(tpnt), SDp->host->host_no, SDp->channel, SDp->id, SDp->lun);
3924 printk(KERN_WARNING "%s: try direct i/o: %s (alignment %d B), max page reachable by HBA %lu\n",
3925 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
3926 queue_dma_alignment(SDp->request_queue) + 1, tpnt->max_pfn);
3931 for (mode=0; mode < ST_NBR_MODES; mode++) {
3932 STm = &(tpnt->modes[mode]);
3933 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
3935 for (j=0; j < 2; j++) {
3936 if (STm->cdevs[j]) {
3937 if (cdev == STm->cdevs[j])
3939 class_simple_device_remove(MKDEV(SCSI_TAPE_MAJOR,
3940 TAPE_MINOR(i, mode, j)));
3941 cdev_del(STm->cdevs[j]);
3947 write_lock(&st_dev_arr_lock);
3948 scsi_tapes[dev_num] = NULL;
3950 write_unlock(&st_dev_arr_lock);
3962 static int st_remove(struct device *dev)
3964 Scsi_Device *SDp = to_scsi_device(dev);
3968 write_lock(&st_dev_arr_lock);
3969 for (i = 0; i < st_dev_max; i++) {
3970 tpnt = scsi_tapes[i];
3971 if (tpnt != NULL && tpnt->device == SDp) {
3972 scsi_tapes[i] = NULL;
3974 write_unlock(&st_dev_arr_lock);
3975 devfs_unregister_tape(tpnt->disk->number);
3976 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
3978 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
3979 j = mode << (4 - ST_NBR_MODE_BITS);
3980 devfs_remove("%s/mt%s", SDp->devfs_name, st_formats[j]);
3981 devfs_remove("%s/mt%sn", SDp->devfs_name, st_formats[j]);
3982 for (j=0; j < 2; j++) {
3983 class_simple_device_remove(MKDEV(SCSI_TAPE_MAJOR,
3984 TAPE_MINOR(i, mode, j)));
3985 cdev_del(tpnt->modes[mode].cdevs[j]);
3986 tpnt->modes[mode].cdevs[j] = NULL;
3989 tpnt->device = NULL;
3992 tpnt->buffer->orig_frp_segs = 0;
3993 normalize_buffer(tpnt->buffer);
3994 kfree(tpnt->buffer);
3996 put_disk(tpnt->disk);
4002 write_unlock(&st_dev_arr_lock);
4006 static void st_intr(struct scsi_cmnd *SCpnt)
4008 scsi_io_completion(SCpnt, (SCpnt->result ? 0: SCpnt->bufflen), 1);
4012 * st_init_command: only called via the scsi_cmd_ioctl (block SG_IO)
4013 * interface for REQ_BLOCK_PC commands.
4015 static int st_init_command(struct scsi_cmnd *SCpnt)
4019 if (!(SCpnt->request->flags & REQ_BLOCK_PC))
4022 rq = SCpnt->request;
4023 if (sizeof(rq->cmd) > sizeof(SCpnt->cmnd))
4026 memcpy(SCpnt->cmnd, rq->cmd, sizeof(SCpnt->cmnd));
4028 if (rq_data_dir(rq) == WRITE)
4029 SCpnt->sc_data_direction = DMA_TO_DEVICE;
4030 else if (rq->data_len)
4031 SCpnt->sc_data_direction = DMA_FROM_DEVICE;
4033 SCpnt->sc_data_direction = DMA_NONE;
4035 SCpnt->timeout_per_command = rq->timeout;
4036 SCpnt->transfersize = rq->data_len;
4037 SCpnt->done = st_intr;
4041 static int __init init_st(void)
4046 "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4047 verstr, st_fixed_buffer_size, st_max_sg_segs);
4049 st_sysfs_class = class_simple_create(THIS_MODULE, "scsi_tape");
4050 if (IS_ERR(st_sysfs_class)) {
4051 st_sysfs_class = NULL;
4052 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4056 if (!register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4057 ST_MAX_TAPE_ENTRIES, "st")) {
4058 if (scsi_register_driver(&st_template.gendrv) == 0) {
4059 do_create_driverfs_files();
4063 class_simple_destroy(st_sysfs_class);
4064 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4066 ST_MAX_TAPE_ENTRIES);
4069 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n", SCSI_TAPE_MAJOR);
4073 static void __exit exit_st(void)
4076 class_simple_destroy(st_sysfs_class);
4077 st_sysfs_class = NULL;
4078 do_remove_driverfs_files();
4079 scsi_unregister_driver(&st_template.gendrv);
4080 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4081 ST_MAX_TAPE_ENTRIES);
4083 printk(KERN_INFO "st: Unloaded.\n");
4086 module_init(init_st);
4087 module_exit(exit_st);
4090 /* The sysfs driver interface. Read-only at the moment */
4091 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4093 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4095 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4097 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4099 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4101 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4103 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4105 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4107 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4109 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4111 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4113 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4115 static void do_create_driverfs_files(void)
4117 struct device_driver *driverfs = &st_template.gendrv;
4119 driver_create_file(driverfs, &driver_attr_try_direct_io);
4120 driver_create_file(driverfs, &driver_attr_fixed_buffer_size);
4121 driver_create_file(driverfs, &driver_attr_max_sg_segs);
4122 driver_create_file(driverfs, &driver_attr_version);
4125 static void do_remove_driverfs_files(void)
4127 struct device_driver *driverfs = &st_template.gendrv;
4129 driver_remove_file(driverfs, &driver_attr_version);
4130 driver_remove_file(driverfs, &driver_attr_max_sg_segs);
4131 driver_remove_file(driverfs, &driver_attr_fixed_buffer_size);
4132 driver_remove_file(driverfs, &driver_attr_try_direct_io);
4136 /* The sysfs simple class interface */
4137 static ssize_t st_defined_show(struct class_device *class_dev, char *buf)
4139 ST_mode *STm = (ST_mode *)class_get_devdata(class_dev);
4142 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4146 CLASS_DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4148 static ssize_t st_defblk_show(struct class_device *class_dev, char *buf)
4150 ST_mode *STm = (ST_mode *)class_get_devdata(class_dev);
4153 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4157 CLASS_DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4159 static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf)
4161 ST_mode *STm = (ST_mode *)class_get_devdata(class_dev);
4165 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4166 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4170 CLASS_DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4172 static ssize_t st_defcompression_show(struct class_device *class_dev, char *buf)
4174 ST_mode *STm = (ST_mode *)class_get_devdata(class_dev);
4177 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4181 CLASS_DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4183 static void do_create_class_files(Scsi_Tape *STp, int dev_num, int mode)
4187 struct class_device *st_class_member;
4189 if (!st_sysfs_class)
4192 for (rew=0; rew < 2; rew++) {
4193 /* Make sure that the minor numbers corresponding to the four
4194 first modes always get the same names */
4195 i = mode << (4 - ST_NBR_MODE_BITS);
4196 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4197 STp->disk->disk_name, st_formats[i]);
4199 class_simple_device_add(st_sysfs_class,
4200 MKDEV(SCSI_TAPE_MAJOR,
4201 TAPE_MINOR(dev_num, mode, rew)),
4202 &STp->device->sdev_gendev, "%s", name);
4203 if (IS_ERR(st_class_member)) {
4204 printk(KERN_WARNING "st%d: class_simple_device_add failed\n",
4208 class_set_devdata(st_class_member, &STp->modes[mode]);
4210 class_device_create_file(st_class_member,
4211 &class_device_attr_defined);
4212 class_device_create_file(st_class_member,
4213 &class_device_attr_default_blksize);
4214 class_device_create_file(st_class_member,
4215 &class_device_attr_default_density);
4216 class_device_create_file(st_class_member,
4217 &class_device_attr_default_compression);
4218 if (mode == 0 && rew == 0) {
4219 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4220 &st_class_member->kobj,
4224 "st%d: Can't create sysfs link from SCSI device.\n",
4234 /* Pin down user pages and put them into a scatter gather list. Returns <= 0 if
4235 - mapping of all pages not successful
4236 - any page is above max_pfn
4237 (i.e., either completely successful or fails)
4239 static int st_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4240 unsigned long uaddr, size_t count, int rw,
4241 unsigned long max_pfn)
4245 nr_pages = sgl_map_user_pages(sgl, max_pages, uaddr, count, rw);
4249 for (i=0; i < nr_pages; i++) {
4250 if (page_to_pfn(sgl[i].page) > max_pfn)
4256 sgl_unmap_user_pages(sgl, nr_pages, FALSE);
4261 /* The following functions may be useful for a larger audience. */
4262 static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4263 unsigned long uaddr, size_t count, int rw)
4266 unsigned int nr_pages;
4267 struct page **pages;
4269 nr_pages = ((uaddr & ~PAGE_MASK) + count + ~PAGE_MASK) >> PAGE_SHIFT;
4271 /* User attempted Overflow! */
4272 if ((uaddr + count) < uaddr)
4276 if (nr_pages > max_pages)
4283 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4286 /* Try to fault in all of the necessary pages */
4287 down_read(¤t->mm->mmap_sem);
4288 /* rw==READ means read from drive, write into memory area */
4289 res = get_user_pages(
4295 0, /* don't force */
4298 up_read(¤t->mm->mmap_sem);
4300 /* Errors and no page mapped should return here */
4304 for (i=0; i < nr_pages; i++) {
4305 /* FIXME: flush superflous for rw==READ,
4306 * probably wrong function for rw==WRITE
4308 flush_dcache_page(pages[i]);
4311 /* Populate the scatter/gather list */
4312 sgl[0].page = pages[0];
4313 sgl[0].offset = uaddr & ~PAGE_MASK;
4315 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4316 count -= sgl[0].length;
4317 for (i=1; i < nr_pages ; i++) {
4319 sgl[i].page = pages[i];
4320 sgl[i].length = count < PAGE_SIZE ? count : PAGE_SIZE;
4325 sgl[0].length = count;
4333 for (j=0; j < res; j++)
4334 page_cache_release(pages[j]);
4341 /* And unmap them... */
4342 static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4347 for (i=0; i < nr_pages; i++) {
4348 if (dirtied && !PageReserved(sgl[i].page))
4349 SetPageDirty(sgl[i].page);
4350 /* FIXME: cache flush missing for rw==READ
4351 * FIXME: call the correct reference counting function
4353 page_cache_release(sgl[i].page);