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 - 2005 Kai Makisara
13 email Kai.Makisara@kolumbus.fi
15 Some small formal changes - aeb, 950809
17 Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
20 static const char *verstr
= "20050830";
22 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/sched.h>
28 #include <linux/init.h>
29 #include <linux/string.h>
30 #include <linux/errno.h>
31 #include <linux/mtio.h>
32 #include <linux/cdrom.h>
33 #include <linux/ioctl.h>
34 #include <linux/fcntl.h>
35 #include <linux/spinlock.h>
36 #include <linux/blkdev.h>
37 #include <linux/moduleparam.h>
38 #include <linux/devfs_fs_kernel.h>
39 #include <linux/cdev.h>
40 #include <linux/delay.h>
41 #include <linux/mutex.h>
43 #include <asm/uaccess.h>
45 #include <asm/system.h>
47 #include <scsi/scsi.h>
48 #include <scsi/scsi_dbg.h>
49 #include <scsi/scsi_device.h>
50 #include <scsi/scsi_driver.h>
51 #include <scsi/scsi_eh.h>
52 #include <scsi/scsi_host.h>
53 #include <scsi/scsi_ioctl.h>
57 /* The driver prints some debugging information on the console if DEBUG
58 is defined and non-zero. */
62 /* The message level for the debug messages is currently set to KERN_NOTICE
63 so that people can easily see the messages. Later when the debugging messages
64 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
65 #define ST_DEB_MSG KERN_NOTICE
67 #define DEBC(a) if (debugging) { a ; }
73 #define ST_KILOBYTE 1024
75 #include "st_options.h"
78 static int buffer_kbs
;
79 static int max_sg_segs
;
80 static int try_direct_io
= TRY_DIRECT_IO
;
81 static int try_rdio
= 1;
82 static int try_wdio
= 1;
84 static int st_dev_max
;
87 static struct class *st_sysfs_class
;
89 MODULE_AUTHOR("Kai Makisara");
90 MODULE_DESCRIPTION("SCSI Tape Driver");
91 MODULE_LICENSE("GPL");
93 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
94 * of sysfs parameters (which module_param doesn't yet support).
95 * Sysfs parameters defined explicitly later.
97 module_param_named(buffer_kbs
, buffer_kbs
, int, 0);
98 MODULE_PARM_DESC(buffer_kbs
, "Default driver buffer size for fixed block mode (KB; 32)");
99 module_param_named(max_sg_segs
, max_sg_segs
, int, 0);
100 MODULE_PARM_DESC(max_sg_segs
, "Maximum number of scatter/gather segments to use (256)");
101 module_param_named(try_direct_io
, try_direct_io
, int, 0);
102 MODULE_PARM_DESC(try_direct_io
, "Try direct I/O between user buffer and tape drive (1)");
104 /* Extra parameters for testing */
105 module_param_named(try_rdio
, try_rdio
, int, 0);
106 MODULE_PARM_DESC(try_rdio
, "Try direct read i/o when possible");
107 module_param_named(try_wdio
, try_wdio
, int, 0);
108 MODULE_PARM_DESC(try_wdio
, "Try direct write i/o when possible");
111 static int write_threshold_kbs
; /* retained for compatibility */
112 static struct st_dev_parm
{
115 } parms
[] __initdata
= {
117 "buffer_kbs", &buffer_kbs
119 { /* Retained for compatibility with 2.4 */
120 "write_threshold_kbs", &write_threshold_kbs
126 "try_direct_io", &try_direct_io
131 /* Restrict the number of modes so that names for all are assigned */
132 #if ST_NBR_MODES > 16
133 #error "Maximum number of modes is 16"
135 /* Bit reversed order to get same names for same minors with all
137 static const char *st_formats
[] = {
138 "", "r", "k", "s", "l", "t", "o", "u",
139 "m", "v", "p", "x", "a", "y", "q", "z"};
141 /* The default definitions have been moved to st_options.h */
143 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
145 /* The buffer size should fit into the 24 bits for length in the
146 6-byte SCSI read and write commands. */
147 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
148 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
151 static int debugging
= DEBUG
;
153 #define MAX_RETRIES 0
154 #define MAX_WRITE_RETRIES 0
155 #define MAX_READY_RETRIES 0
156 #define NO_TAPE NOT_READY
158 #define ST_TIMEOUT (900 * HZ)
159 #define ST_LONG_TIMEOUT (14000 * HZ)
161 /* Remove mode bits and auto-rewind bit (7) */
162 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
163 (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
164 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
166 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
167 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
168 (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
170 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
172 #define SET_DENS_AND_BLK 0x10001
174 static DEFINE_RWLOCK(st_dev_arr_lock
);
176 static int st_fixed_buffer_size
= ST_FIXED_BUFFER_SIZE
;
177 static int st_max_sg_segs
= ST_MAX_SG
;
179 static struct scsi_tape
**scsi_tapes
= NULL
;
181 static int modes_defined
;
183 static struct st_buffer
*new_tape_buffer(int, int, int);
184 static int enlarge_buffer(struct st_buffer
*, int, int);
185 static void normalize_buffer(struct st_buffer
*);
186 static int append_to_buffer(const char __user
*, struct st_buffer
*, int);
187 static int from_buffer(struct st_buffer
*, char __user
*, int);
188 static void move_buffer_data(struct st_buffer
*, int);
189 static void buf_to_sg(struct st_buffer
*, unsigned int);
191 static int sgl_map_user_pages(struct scatterlist
*, const unsigned int,
192 unsigned long, size_t, int);
193 static int sgl_unmap_user_pages(struct scatterlist
*, const unsigned int, int);
195 static int st_probe(struct device
*);
196 static int st_remove(struct device
*);
198 static void do_create_driverfs_files(void);
199 static void do_remove_driverfs_files(void);
200 static void do_create_class_files(struct scsi_tape
*, int, int);
202 static struct scsi_driver st_template
= {
203 .owner
= THIS_MODULE
,
211 static int st_compression(struct scsi_tape
*, int);
213 static int find_partition(struct scsi_tape
*);
214 static int switch_partition(struct scsi_tape
*);
216 static int st_int_ioctl(struct scsi_tape
*, unsigned int, unsigned long);
218 static void scsi_tape_release(struct kref
*);
220 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
222 static DEFINE_MUTEX(st_ref_mutex
);
225 #include "osst_detect.h"
226 #ifndef SIGS_FROM_OSST
227 #define SIGS_FROM_OSST \
228 {"OnStream", "SC-", "", "osst"}, \
229 {"OnStream", "DI-", "", "osst"}, \
230 {"OnStream", "DP-", "", "osst"}, \
231 {"OnStream", "USB", "", "osst"}, \
232 {"OnStream", "FW-", "", "osst"}
235 static struct scsi_tape
*scsi_tape_get(int dev
)
237 struct scsi_tape
*STp
= NULL
;
239 mutex_lock(&st_ref_mutex
);
240 write_lock(&st_dev_arr_lock
);
242 if (dev
< st_dev_max
&& scsi_tapes
!= NULL
)
243 STp
= scsi_tapes
[dev
];
246 kref_get(&STp
->kref
);
251 if (scsi_device_get(STp
->device
))
257 kref_put(&STp
->kref
, scsi_tape_release
);
260 write_unlock(&st_dev_arr_lock
);
261 mutex_unlock(&st_ref_mutex
);
265 static void scsi_tape_put(struct scsi_tape
*STp
)
267 struct scsi_device
*sdev
= STp
->device
;
269 mutex_lock(&st_ref_mutex
);
270 kref_put(&STp
->kref
, scsi_tape_release
);
271 scsi_device_put(sdev
);
272 mutex_unlock(&st_ref_mutex
);
275 struct st_reject_data
{
279 char *driver_hint
; /* Name of the correct driver, NULL if unknown */
282 static struct st_reject_data reject_list
[] = {
283 /* {"XXX", "Yy-", "", NULL}, example */
287 /* If the device signature is on the list of incompatible drives, the
288 function returns a pointer to the name of the correct driver (if known) */
289 static char * st_incompatible(struct scsi_device
* SDp
)
291 struct st_reject_data
*rp
;
293 for (rp
=&(reject_list
[0]); rp
->vendor
!= NULL
; rp
++)
294 if (!strncmp(rp
->vendor
, SDp
->vendor
, strlen(rp
->vendor
)) &&
295 !strncmp(rp
->model
, SDp
->model
, strlen(rp
->model
)) &&
296 !strncmp(rp
->rev
, SDp
->rev
, strlen(rp
->rev
))) {
298 return rp
->driver_hint
;
306 static inline char *tape_name(struct scsi_tape
*tape
)
308 return tape
->disk
->disk_name
;
312 static void st_analyze_sense(struct st_request
*SRpnt
, struct st_cmdstatus
*s
)
315 const u8
*sense
= SRpnt
->sense
;
317 s
->have_sense
= scsi_normalize_sense(SRpnt
->sense
,
318 SCSI_SENSE_BUFFERSIZE
, &s
->sense_hdr
);
324 scsi_get_sense_info_fld(sense
, SCSI_SENSE_BUFFERSIZE
, &s
->uremainder64
);
325 switch (sense
[0] & 0x7f) {
330 s
->flags
= sense
[2] & 0xe0;
336 ucp
= scsi_sense_desc_find(sense
, SCSI_SENSE_BUFFERSIZE
, 4);
337 s
->flags
= ucp
? (ucp
[3] & 0xe0) : 0;
344 /* Convert the result to success code */
345 static int st_chk_result(struct scsi_tape
*STp
, struct st_request
* SRpnt
)
347 int result
= SRpnt
->result
;
349 DEB(const char *stp
;)
350 char *name
= tape_name(STp
);
351 struct st_cmdstatus
*cmdstatp
;
356 cmdstatp
= &STp
->buffer
->cmdstat
;
357 st_analyze_sense(SRpnt
, cmdstatp
);
359 if (cmdstatp
->have_sense
)
360 scode
= STp
->buffer
->cmdstat
.sense_hdr
.sense_key
;
366 printk(ST_DEB_MSG
"%s: Error: %x, cmd: %x %x %x %x %x %x\n",
368 SRpnt
->cmd
[0], SRpnt
->cmd
[1], SRpnt
->cmd
[2],
369 SRpnt
->cmd
[3], SRpnt
->cmd
[4], SRpnt
->cmd
[5]);
370 if (cmdstatp
->have_sense
)
371 __scsi_print_sense("st", SRpnt
->sense
, SCSI_SENSE_BUFFERSIZE
);
373 if (!debugging
) { /* Abnormal conditions for tape */
374 if (!cmdstatp
->have_sense
)
376 "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
377 name
, result
, suggestion(result
),
378 driver_byte(result
) & DRIVER_MASK
, host_byte(result
));
379 else if (cmdstatp
->have_sense
&&
381 scode
!= RECOVERED_ERROR
&&
382 /* scode != UNIT_ATTENTION && */
383 scode
!= BLANK_CHECK
&&
384 scode
!= VOLUME_OVERFLOW
&&
385 SRpnt
->cmd
[0] != MODE_SENSE
&&
386 SRpnt
->cmd
[0] != TEST_UNIT_READY
) {
387 printk(KERN_WARNING
"%s: Error with sense data: ", name
);
388 __scsi_print_sense("st", SRpnt
->sense
,
389 SCSI_SENSE_BUFFERSIZE
);
393 if (cmdstatp
->fixed_format
&&
394 STp
->cln_mode
>= EXTENDED_SENSE_START
) { /* Only fixed format sense */
395 if (STp
->cln_sense_value
)
396 STp
->cleaning_req
|= ((SRpnt
->sense
[STp
->cln_mode
] &
397 STp
->cln_sense_mask
) == STp
->cln_sense_value
);
399 STp
->cleaning_req
|= ((SRpnt
->sense
[STp
->cln_mode
] &
400 STp
->cln_sense_mask
) != 0);
402 if (cmdstatp
->have_sense
&&
403 cmdstatp
->sense_hdr
.asc
== 0 && cmdstatp
->sense_hdr
.ascq
== 0x17)
404 STp
->cleaning_req
= 1; /* ASC and ASCQ => cleaning requested */
406 STp
->pos_unknown
|= STp
->device
->was_reset
;
408 if (cmdstatp
->have_sense
&&
409 scode
== RECOVERED_ERROR
410 #if ST_RECOVERED_WRITE_FATAL
411 && SRpnt
->cmd
[0] != WRITE_6
412 && SRpnt
->cmd
[0] != WRITE_FILEMARKS
415 STp
->recover_count
++;
420 if (SRpnt
->cmd
[0] == READ_6
)
422 else if (SRpnt
->cmd
[0] == WRITE_6
)
426 printk(ST_DEB_MSG
"%s: Recovered %s error (%d).\n", name
, stp
,
430 if (cmdstatp
->flags
== 0)
437 /* Wakeup from interrupt */
438 static void st_sleep_done(void *data
, char *sense
, int result
, int resid
)
440 struct st_request
*SRpnt
= data
;
441 struct scsi_tape
*STp
= SRpnt
->stp
;
443 memcpy(SRpnt
->sense
, sense
, SCSI_SENSE_BUFFERSIZE
);
444 (STp
->buffer
)->cmdstat
.midlevel_result
= SRpnt
->result
= result
;
445 DEB( STp
->write_pending
= 0; )
448 complete(SRpnt
->waiting
);
451 static struct st_request
*st_allocate_request(void)
453 return kzalloc(sizeof(struct st_request
), GFP_KERNEL
);
456 static void st_release_request(struct st_request
*streq
)
461 /* Do the scsi command. Waits until command performed if do_wait is true.
462 Otherwise write_behind_check() is used to check that the command
464 static struct st_request
*
465 st_do_scsi(struct st_request
* SRpnt
, struct scsi_tape
* STp
, unsigned char *cmd
,
466 int bytes
, int direction
, int timeout
, int retries
, int do_wait
)
468 struct completion
*waiting
;
470 /* if async, make sure there's no command outstanding */
471 if (!do_wait
&& ((STp
->buffer
)->last_SRpnt
)) {
472 printk(KERN_ERR
"%s: Async command already active.\n",
474 if (signal_pending(current
))
475 (STp
->buffer
)->syscall_result
= (-EINTR
);
477 (STp
->buffer
)->syscall_result
= (-EBUSY
);
482 SRpnt
= st_allocate_request();
484 DEBC( printk(KERN_ERR
"%s: Can't get SCSI request.\n",
486 if (signal_pending(current
))
487 (STp
->buffer
)->syscall_result
= (-EINTR
);
489 (STp
->buffer
)->syscall_result
= (-EBUSY
);
495 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
496 which IO is outstanding. It's nulled out when the IO completes. */
498 (STp
->buffer
)->last_SRpnt
= SRpnt
;
500 waiting
= &STp
->wait
;
501 init_completion(waiting
);
502 SRpnt
->waiting
= waiting
;
504 if (!STp
->buffer
->do_dio
)
505 buf_to_sg(STp
->buffer
, bytes
);
507 memcpy(SRpnt
->cmd
, cmd
, sizeof(SRpnt
->cmd
));
508 STp
->buffer
->cmdstat
.have_sense
= 0;
509 STp
->buffer
->syscall_result
= 0;
511 if (scsi_execute_async(STp
->device
, cmd
, direction
,
512 &((STp
->buffer
)->sg
[0]), bytes
, (STp
->buffer
)->sg_segs
,
513 timeout
, retries
, SRpnt
, st_sleep_done
, GFP_KERNEL
)) {
514 /* could not allocate the buffer or request was too large */
515 (STp
->buffer
)->syscall_result
= (-EBUSY
);
516 (STp
->buffer
)->last_SRpnt
= NULL
;
519 wait_for_completion(waiting
);
520 SRpnt
->waiting
= NULL
;
521 (STp
->buffer
)->syscall_result
= st_chk_result(STp
, SRpnt
);
528 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
529 write has been correct but EOM early warning reached, -EIO if write ended in
530 error or zero if write successful. Asynchronous writes are used only in
531 variable block mode. */
532 static int write_behind_check(struct scsi_tape
* STp
)
535 struct st_buffer
*STbuffer
;
536 struct st_partstat
*STps
;
537 struct st_cmdstatus
*cmdstatp
;
538 struct st_request
*SRpnt
;
540 STbuffer
= STp
->buffer
;
541 if (!STbuffer
->writing
)
545 if (STp
->write_pending
)
551 wait_for_completion(&(STp
->wait
));
552 SRpnt
= STbuffer
->last_SRpnt
;
553 STbuffer
->last_SRpnt
= NULL
;
554 SRpnt
->waiting
= NULL
;
556 (STp
->buffer
)->syscall_result
= st_chk_result(STp
, SRpnt
);
557 st_release_request(SRpnt
);
559 STbuffer
->buffer_bytes
-= STbuffer
->writing
;
560 STps
= &(STp
->ps
[STp
->partition
]);
561 if (STps
->drv_block
>= 0) {
562 if (STp
->block_size
== 0)
565 STps
->drv_block
+= STbuffer
->writing
/ STp
->block_size
;
568 cmdstatp
= &STbuffer
->cmdstat
;
569 if (STbuffer
->syscall_result
) {
571 if (cmdstatp
->have_sense
&& !cmdstatp
->deferred
&&
572 (cmdstatp
->flags
& SENSE_EOM
) &&
573 (cmdstatp
->sense_hdr
.sense_key
== NO_SENSE
||
574 cmdstatp
->sense_hdr
.sense_key
== RECOVERED_ERROR
)) {
575 /* EOM at write-behind, has all data been written? */
576 if (!cmdstatp
->remainder_valid
||
577 cmdstatp
->uremainder64
== 0)
581 STps
->drv_block
= -1;
583 STbuffer
->writing
= 0;
585 DEB(if (debugging
&& retval
)
586 printk(ST_DEB_MSG
"%s: Async write error %x, return value %d.\n",
587 tape_name(STp
), STbuffer
->cmdstat
.midlevel_result
, retval
);) /* end DEB */
593 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
594 it messes up the block number). */
595 static int cross_eof(struct scsi_tape
* STp
, int forward
)
597 struct st_request
*SRpnt
;
598 unsigned char cmd
[MAX_COMMAND_SIZE
];
601 cmd
[1] = 0x01; /* Space FileMarks */
606 cmd
[2] = cmd
[3] = cmd
[4] = 0xff; /* -1 filemarks */
609 DEBC(printk(ST_DEB_MSG
"%s: Stepping over filemark %s.\n",
610 tape_name(STp
), forward
? "forward" : "backward"));
612 SRpnt
= st_do_scsi(NULL
, STp
, cmd
, 0, DMA_NONE
,
613 STp
->device
->timeout
, MAX_RETRIES
, 1);
615 return (STp
->buffer
)->syscall_result
;
617 st_release_request(SRpnt
);
620 if ((STp
->buffer
)->cmdstat
.midlevel_result
!= 0)
621 printk(KERN_ERR
"%s: Stepping over filemark %s failed.\n",
622 tape_name(STp
), forward
? "forward" : "backward");
624 return (STp
->buffer
)->syscall_result
;
628 /* Flush the write buffer (never need to write if variable blocksize). */
629 static int flush_write_buffer(struct scsi_tape
* STp
)
631 int offset
, transfer
, blks
;
633 unsigned char cmd
[MAX_COMMAND_SIZE
];
634 struct st_request
*SRpnt
;
635 struct st_partstat
*STps
;
637 result
= write_behind_check(STp
);
642 if (STp
->dirty
== 1) {
644 offset
= (STp
->buffer
)->buffer_bytes
;
645 transfer
= ((offset
+ STp
->block_size
- 1) /
646 STp
->block_size
) * STp
->block_size
;
647 DEBC(printk(ST_DEB_MSG
"%s: Flushing %d bytes.\n",
648 tape_name(STp
), transfer
));
650 memset((STp
->buffer
)->b_data
+ offset
, 0, transfer
- offset
);
652 memset(cmd
, 0, MAX_COMMAND_SIZE
);
655 blks
= transfer
/ STp
->block_size
;
660 SRpnt
= st_do_scsi(NULL
, STp
, cmd
, transfer
, DMA_TO_DEVICE
,
661 STp
->device
->timeout
, MAX_WRITE_RETRIES
, 1);
663 return (STp
->buffer
)->syscall_result
;
665 STps
= &(STp
->ps
[STp
->partition
]);
666 if ((STp
->buffer
)->syscall_result
!= 0) {
667 struct st_cmdstatus
*cmdstatp
= &STp
->buffer
->cmdstat
;
669 if (cmdstatp
->have_sense
&& !cmdstatp
->deferred
&&
670 (cmdstatp
->flags
& SENSE_EOM
) &&
671 (cmdstatp
->sense_hdr
.sense_key
== NO_SENSE
||
672 cmdstatp
->sense_hdr
.sense_key
== RECOVERED_ERROR
) &&
673 (!cmdstatp
->remainder_valid
||
674 cmdstatp
->uremainder64
== 0)) { /* All written at EOM early warning */
676 (STp
->buffer
)->buffer_bytes
= 0;
677 if (STps
->drv_block
>= 0)
678 STps
->drv_block
+= blks
;
681 printk(KERN_ERR
"%s: Error on flush.\n",
683 STps
->drv_block
= (-1);
687 if (STps
->drv_block
>= 0)
688 STps
->drv_block
+= blks
;
690 (STp
->buffer
)->buffer_bytes
= 0;
692 st_release_request(SRpnt
);
699 /* Flush the tape buffer. The tape will be positioned correctly unless
700 seek_next is true. */
701 static int flush_buffer(struct scsi_tape
*STp
, int seek_next
)
703 int backspace
, result
;
704 struct st_buffer
*STbuffer
;
705 struct st_partstat
*STps
;
707 STbuffer
= STp
->buffer
;
710 * If there was a bus reset, block further access
713 if (STp
->pos_unknown
)
716 if (STp
->ready
!= ST_READY
)
718 STps
= &(STp
->ps
[STp
->partition
]);
719 if (STps
->rw
== ST_WRITING
) /* Writing */
720 return flush_write_buffer(STp
);
722 if (STp
->block_size
== 0)
725 backspace
= ((STp
->buffer
)->buffer_bytes
+
726 (STp
->buffer
)->read_pointer
) / STp
->block_size
-
727 ((STp
->buffer
)->read_pointer
+ STp
->block_size
- 1) /
729 (STp
->buffer
)->buffer_bytes
= 0;
730 (STp
->buffer
)->read_pointer
= 0;
733 if (STps
->eof
== ST_FM_HIT
) {
734 result
= cross_eof(STp
, 0); /* Back over the EOF hit */
736 STps
->eof
= ST_NOEOF
;
738 if (STps
->drv_file
>= 0)
743 if (!result
&& backspace
> 0)
744 result
= st_int_ioctl(STp
, MTBSR
, backspace
);
745 } else if (STps
->eof
== ST_FM_HIT
) {
746 if (STps
->drv_file
>= 0)
749 STps
->eof
= ST_NOEOF
;
755 /* Set the mode parameters */
756 static int set_mode_densblk(struct scsi_tape
* STp
, struct st_modedef
* STm
)
760 char *name
= tape_name(STp
);
762 if (!STp
->density_changed
&&
763 STm
->default_density
>= 0 &&
764 STm
->default_density
!= STp
->density
) {
765 arg
= STm
->default_density
;
769 arg
<<= MT_ST_DENSITY_SHIFT
;
770 if (!STp
->blksize_changed
&&
771 STm
->default_blksize
>= 0 &&
772 STm
->default_blksize
!= STp
->block_size
) {
773 arg
|= STm
->default_blksize
;
776 arg
|= STp
->block_size
;
778 st_int_ioctl(STp
, SET_DENS_AND_BLK
, arg
)) {
780 "%s: Can't set default block size to %d bytes and density %x.\n",
781 name
, STm
->default_blksize
, STm
->default_density
);
789 /* Lock or unlock the drive door. Don't use when st_request allocated. */
790 static int do_door_lock(struct scsi_tape
* STp
, int do_lock
)
793 DEB(char *name
= tape_name(STp
);)
796 cmd
= do_lock
? SCSI_IOCTL_DOORLOCK
: SCSI_IOCTL_DOORUNLOCK
;
797 DEBC(printk(ST_DEB_MSG
"%s: %socking drive door.\n", name
,
798 do_lock
? "L" : "Unl"));
799 retval
= scsi_ioctl(STp
->device
, cmd
, NULL
);
801 STp
->door_locked
= do_lock
? ST_LOCKED_EXPLICIT
: ST_UNLOCKED
;
804 STp
->door_locked
= ST_LOCK_FAILS
;
810 /* Set the internal state after reset */
811 static void reset_state(struct scsi_tape
*STp
)
814 struct st_partstat
*STps
;
816 STp
->pos_unknown
= 0;
817 for (i
= 0; i
< ST_NBR_PARTITIONS
; i
++) {
818 STps
= &(STp
->ps
[i
]);
820 STps
->eof
= ST_NOEOF
;
822 STps
->last_block_valid
= 0;
823 STps
->drv_block
= -1;
826 if (STp
->can_partitions
) {
827 STp
->partition
= find_partition(STp
);
828 if (STp
->partition
< 0)
830 STp
->new_partition
= STp
->partition
;
834 /* Test if the drive is ready. Returns either one of the codes below or a negative system
836 #define CHKRES_READY 0
837 #define CHKRES_NEW_SESSION 1
838 #define CHKRES_NOT_READY 2
839 #define CHKRES_NO_TAPE 3
841 #define MAX_ATTENTIONS 10
843 static int test_ready(struct scsi_tape
*STp
, int do_wait
)
845 int attentions
, waits
, max_wait
, scode
;
846 int retval
= CHKRES_READY
, new_session
= 0;
847 unsigned char cmd
[MAX_COMMAND_SIZE
];
848 struct st_request
*SRpnt
= NULL
;
849 struct st_cmdstatus
*cmdstatp
= &STp
->buffer
->cmdstat
;
851 max_wait
= do_wait
? ST_BLOCK_SECONDS
: 0;
853 for (attentions
=waits
=0; ; ) {
854 memset((void *) &cmd
[0], 0, MAX_COMMAND_SIZE
);
855 cmd
[0] = TEST_UNIT_READY
;
856 SRpnt
= st_do_scsi(SRpnt
, STp
, cmd
, 0, DMA_NONE
,
857 STp
->long_timeout
, MAX_READY_RETRIES
, 1);
860 retval
= (STp
->buffer
)->syscall_result
;
864 if (cmdstatp
->have_sense
) {
866 scode
= cmdstatp
->sense_hdr
.sense_key
;
868 if (scode
== UNIT_ATTENTION
) { /* New media? */
870 if (attentions
< MAX_ATTENTIONS
) {
880 if (scode
== NOT_READY
) {
881 if (waits
< max_wait
) {
882 if (msleep_interruptible(1000)) {
890 if ((STp
->device
)->scsi_level
>= SCSI_2
&&
891 cmdstatp
->sense_hdr
.asc
== 0x3a) /* Check ASC */
892 retval
= CHKRES_NO_TAPE
;
894 retval
= CHKRES_NOT_READY
;
900 retval
= (STp
->buffer
)->syscall_result
;
902 retval
= new_session
? CHKRES_NEW_SESSION
: CHKRES_READY
;
907 st_release_request(SRpnt
);
912 /* See if the drive is ready and gather information about the tape. Return values:
913 < 0 negative error code from errno.h
915 1 drive not ready (possibly no tape)
917 static int check_tape(struct scsi_tape
*STp
, struct file
*filp
)
919 int i
, retval
, new_session
= 0, do_wait
;
920 unsigned char cmd
[MAX_COMMAND_SIZE
], saved_cleaning
;
921 unsigned short st_flags
= filp
->f_flags
;
922 struct st_request
*SRpnt
= NULL
;
923 struct st_modedef
*STm
;
924 struct st_partstat
*STps
;
925 char *name
= tape_name(STp
);
926 struct inode
*inode
= filp
->f_dentry
->d_inode
;
927 int mode
= TAPE_MODE(inode
);
929 STp
->ready
= ST_READY
;
931 if (mode
!= STp
->current_mode
) {
932 DEBC(printk(ST_DEB_MSG
"%s: Mode change from %d to %d.\n",
933 name
, STp
->current_mode
, mode
));
935 STp
->current_mode
= mode
;
937 STm
= &(STp
->modes
[STp
->current_mode
]);
939 saved_cleaning
= STp
->cleaning_req
;
940 STp
->cleaning_req
= 0;
942 do_wait
= ((filp
->f_flags
& O_NONBLOCK
) == 0);
943 retval
= test_ready(STp
, do_wait
);
948 if (retval
== CHKRES_NEW_SESSION
) {
949 STp
->pos_unknown
= 0;
950 STp
->partition
= STp
->new_partition
= 0;
951 if (STp
->can_partitions
)
952 STp
->nbr_partitions
= 1; /* This guess will be updated later
954 for (i
= 0; i
< ST_NBR_PARTITIONS
; i
++) {
955 STps
= &(STp
->ps
[i
]);
957 STps
->eof
= ST_NOEOF
;
959 STps
->last_block_valid
= 0;
966 STp
->cleaning_req
|= saved_cleaning
;
968 if (retval
== CHKRES_NOT_READY
|| retval
== CHKRES_NO_TAPE
) {
969 if (retval
== CHKRES_NO_TAPE
)
970 STp
->ready
= ST_NO_TAPE
;
972 STp
->ready
= ST_NOT_READY
;
974 STp
->density
= 0; /* Clear the erroneous "residue" */
977 STp
->ps
[0].drv_file
= STp
->ps
[0].drv_block
= (-1);
978 STp
->partition
= STp
->new_partition
= 0;
979 STp
->door_locked
= ST_UNLOCKED
;
980 return CHKRES_NOT_READY
;
984 if (STp
->omit_blklims
)
985 STp
->min_block
= STp
->max_block
= (-1);
987 memset((void *) &cmd
[0], 0, MAX_COMMAND_SIZE
);
988 cmd
[0] = READ_BLOCK_LIMITS
;
990 SRpnt
= st_do_scsi(SRpnt
, STp
, cmd
, 6, DMA_FROM_DEVICE
,
991 STp
->device
->timeout
, MAX_READY_RETRIES
, 1);
993 retval
= (STp
->buffer
)->syscall_result
;
997 if (!SRpnt
->result
&& !STp
->buffer
->cmdstat
.have_sense
) {
998 STp
->max_block
= ((STp
->buffer
)->b_data
[1] << 16) |
999 ((STp
->buffer
)->b_data
[2] << 8) | (STp
->buffer
)->b_data
[3];
1000 STp
->min_block
= ((STp
->buffer
)->b_data
[4] << 8) |
1001 (STp
->buffer
)->b_data
[5];
1002 if ( DEB( debugging
|| ) !STp
->inited
)
1004 "%s: Block limits %d - %d bytes.\n", name
,
1005 STp
->min_block
, STp
->max_block
);
1007 STp
->min_block
= STp
->max_block
= (-1);
1008 DEBC(printk(ST_DEB_MSG
"%s: Can't read block limits.\n",
1013 memset((void *) &cmd
[0], 0, MAX_COMMAND_SIZE
);
1014 cmd
[0] = MODE_SENSE
;
1017 SRpnt
= st_do_scsi(SRpnt
, STp
, cmd
, 12, DMA_FROM_DEVICE
,
1018 STp
->device
->timeout
, MAX_READY_RETRIES
, 1);
1020 retval
= (STp
->buffer
)->syscall_result
;
1024 if ((STp
->buffer
)->syscall_result
!= 0) {
1025 DEBC(printk(ST_DEB_MSG
"%s: No Mode Sense.\n", name
));
1026 STp
->block_size
= ST_DEFAULT_BLOCK
; /* Educated guess (?) */
1027 (STp
->buffer
)->syscall_result
= 0; /* Prevent error propagation */
1028 STp
->drv_write_prot
= 0;
1030 DEBC(printk(ST_DEB_MSG
1031 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1033 (STp
->buffer
)->b_data
[0], (STp
->buffer
)->b_data
[1],
1034 (STp
->buffer
)->b_data
[2], (STp
->buffer
)->b_data
[3]));
1036 if ((STp
->buffer
)->b_data
[3] >= 8) {
1037 STp
->drv_buffer
= ((STp
->buffer
)->b_data
[2] >> 4) & 7;
1038 STp
->density
= (STp
->buffer
)->b_data
[4];
1039 STp
->block_size
= (STp
->buffer
)->b_data
[9] * 65536 +
1040 (STp
->buffer
)->b_data
[10] * 256 + (STp
->buffer
)->b_data
[11];
1041 DEBC(printk(ST_DEB_MSG
1042 "%s: Density %x, tape length: %x, drv buffer: %d\n",
1043 name
, STp
->density
, (STp
->buffer
)->b_data
[5] * 65536 +
1044 (STp
->buffer
)->b_data
[6] * 256 + (STp
->buffer
)->b_data
[7],
1047 STp
->drv_write_prot
= ((STp
->buffer
)->b_data
[2] & 0x80) != 0;
1049 st_release_request(SRpnt
);
1053 if (STp
->block_size
> 0)
1054 (STp
->buffer
)->buffer_blocks
=
1055 (STp
->buffer
)->buffer_size
/ STp
->block_size
;
1057 (STp
->buffer
)->buffer_blocks
= 1;
1058 (STp
->buffer
)->buffer_bytes
= (STp
->buffer
)->read_pointer
= 0;
1060 DEBC(printk(ST_DEB_MSG
1061 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name
,
1062 STp
->block_size
, (STp
->buffer
)->buffer_size
,
1063 (STp
->buffer
)->buffer_blocks
));
1065 if (STp
->drv_write_prot
) {
1066 STp
->write_prot
= 1;
1068 DEBC(printk(ST_DEB_MSG
"%s: Write protected\n", name
));
1071 ((st_flags
& O_ACCMODE
) == O_WRONLY
||
1072 (st_flags
& O_ACCMODE
) == O_RDWR
)) {
1078 if (STp
->can_partitions
&& STp
->nbr_partitions
< 1) {
1079 /* This code is reached when the device is opened for the first time
1080 after the driver has been initialized with tape in the drive and the
1081 partition support has been enabled. */
1082 DEBC(printk(ST_DEB_MSG
1083 "%s: Updating partition number in status.\n", name
));
1084 if ((STp
->partition
= find_partition(STp
)) < 0) {
1085 retval
= STp
->partition
;
1088 STp
->new_partition
= STp
->partition
;
1089 STp
->nbr_partitions
= 1; /* This guess will be updated when necessary */
1092 if (new_session
) { /* Change the drive parameters for the new mode */
1093 STp
->density_changed
= STp
->blksize_changed
= 0;
1094 STp
->compression_changed
= 0;
1095 if (!(STm
->defaults_for_writes
) &&
1096 (retval
= set_mode_densblk(STp
, STm
)) < 0)
1099 if (STp
->default_drvbuffer
!= 0xff) {
1100 if (st_int_ioctl(STp
, MTSETDRVBUFFER
, STp
->default_drvbuffer
))
1102 "%s: Can't set default drive buffering to %d.\n",
1103 name
, STp
->default_drvbuffer
);
1107 return CHKRES_READY
;
1114 \f/* Open the device. Needs to be called with BKL only because of incrementing the SCSI host
1116 static int st_open(struct inode
*inode
, struct file
*filp
)
1118 int i
, retval
= (-EIO
);
1119 struct scsi_tape
*STp
;
1120 struct st_partstat
*STps
;
1121 int dev
= TAPE_NR(inode
);
1125 * We really want to do nonseekable_open(inode, filp); here, but some
1126 * versions of tar incorrectly call lseek on tapes and bail out if that
1127 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1129 filp
->f_mode
&= ~(FMODE_PREAD
| FMODE_PWRITE
);
1131 if (!(STp
= scsi_tape_get(dev
)))
1134 write_lock(&st_dev_arr_lock
);
1135 filp
->private_data
= STp
;
1136 name
= tape_name(STp
);
1139 write_unlock(&st_dev_arr_lock
);
1141 DEB( printk(ST_DEB_MSG
"%s: Device already in use.\n", name
); )
1146 write_unlock(&st_dev_arr_lock
);
1147 STp
->rew_at_close
= STp
->autorew_dev
= (iminor(inode
) & 0x80) == 0;
1149 if (!scsi_block_when_processing_errors(STp
->device
)) {
1154 /* See that we have at least a one page buffer available */
1155 if (!enlarge_buffer(STp
->buffer
, PAGE_SIZE
, STp
->restr_dma
)) {
1156 printk(KERN_WARNING
"%s: Can't allocate one page tape buffer.\n",
1158 retval
= (-EOVERFLOW
);
1162 (STp
->buffer
)->writing
= 0;
1163 (STp
->buffer
)->syscall_result
= 0;
1165 STp
->write_prot
= ((filp
->f_flags
& O_ACCMODE
) == O_RDONLY
);
1168 for (i
= 0; i
< ST_NBR_PARTITIONS
; i
++) {
1169 STps
= &(STp
->ps
[i
]);
1172 STp
->recover_count
= 0;
1173 DEB( STp
->nbr_waits
= STp
->nbr_finished
= 0;
1174 STp
->nbr_requests
= STp
->nbr_dio
= STp
->nbr_pages
= STp
->nbr_combinable
= 0; )
1176 retval
= check_tape(STp
, filp
);
1179 if ((filp
->f_flags
& O_NONBLOCK
) == 0 &&
1180 retval
!= CHKRES_READY
) {
1187 normalize_buffer(STp
->buffer
);
1195 /* Flush the tape buffer before close */
1196 static int st_flush(struct file
*filp
)
1198 int result
= 0, result2
;
1199 unsigned char cmd
[MAX_COMMAND_SIZE
];
1200 struct st_request
*SRpnt
;
1201 struct scsi_tape
*STp
= filp
->private_data
;
1202 struct st_modedef
*STm
= &(STp
->modes
[STp
->current_mode
]);
1203 struct st_partstat
*STps
= &(STp
->ps
[STp
->partition
]);
1204 char *name
= tape_name(STp
);
1206 if (file_count(filp
) > 1)
1209 if (STps
->rw
== ST_WRITING
&& !STp
->pos_unknown
) {
1210 result
= flush_write_buffer(STp
);
1211 if (result
!= 0 && result
!= (-ENOSPC
))
1215 if (STp
->can_partitions
&&
1216 (result2
= switch_partition(STp
)) < 0) {
1217 DEBC(printk(ST_DEB_MSG
1218 "%s: switch_partition at close failed.\n", name
));
1224 DEBC( if (STp
->nbr_requests
)
1225 printk(KERN_WARNING
"%s: Number of r/w requests %d, dio used in %d, pages %d (%d).\n",
1226 name
, STp
->nbr_requests
, STp
->nbr_dio
, STp
->nbr_pages
, STp
->nbr_combinable
));
1228 if (STps
->rw
== ST_WRITING
&& !STp
->pos_unknown
) {
1229 struct st_cmdstatus
*cmdstatp
= &STp
->buffer
->cmdstat
;
1231 DEBC(printk(ST_DEB_MSG
"%s: Async write waits %d, finished %d.\n",
1232 name
, STp
->nbr_waits
, STp
->nbr_finished
);
1235 memset(cmd
, 0, MAX_COMMAND_SIZE
);
1236 cmd
[0] = WRITE_FILEMARKS
;
1237 cmd
[4] = 1 + STp
->two_fm
;
1239 SRpnt
= st_do_scsi(NULL
, STp
, cmd
, 0, DMA_NONE
,
1240 STp
->device
->timeout
, MAX_WRITE_RETRIES
, 1);
1242 result
= (STp
->buffer
)->syscall_result
;
1246 if (STp
->buffer
->syscall_result
== 0 ||
1247 (cmdstatp
->have_sense
&& !cmdstatp
->deferred
&&
1248 (cmdstatp
->flags
& SENSE_EOM
) &&
1249 (cmdstatp
->sense_hdr
.sense_key
== NO_SENSE
||
1250 cmdstatp
->sense_hdr
.sense_key
== RECOVERED_ERROR
) &&
1251 (!cmdstatp
->remainder_valid
|| cmdstatp
->uremainder64
== 0))) {
1252 /* Write successful at EOM */
1253 st_release_request(SRpnt
);
1255 if (STps
->drv_file
>= 0)
1257 STps
->drv_block
= 0;
1262 else { /* Write error */
1263 st_release_request(SRpnt
);
1265 printk(KERN_ERR
"%s: Error on write filemark.\n", name
);
1270 DEBC(printk(ST_DEB_MSG
"%s: Buffer flushed, %d EOF(s) written\n",
1272 } else if (!STp
->rew_at_close
) {
1273 STps
= &(STp
->ps
[STp
->partition
]);
1274 if (!STm
->sysv
|| STps
->rw
!= ST_READING
) {
1276 result
= flush_buffer(STp
, 0);
1277 else if (STps
->eof
== ST_FM_HIT
) {
1278 result
= cross_eof(STp
, 0);
1280 if (STps
->drv_file
>= 0)
1282 STps
->drv_block
= 0;
1285 STps
->eof
= ST_NOEOF
;
1287 } else if ((STps
->eof
== ST_NOEOF
&&
1288 !(result
= cross_eof(STp
, 1))) ||
1289 STps
->eof
== ST_FM_HIT
) {
1290 if (STps
->drv_file
>= 0)
1292 STps
->drv_block
= 0;
1298 if (STp
->rew_at_close
) {
1299 result2
= st_int_ioctl(STp
, MTREW
, 1);
1307 /* Close the device and release it. BKL is not needed: this is the only thread
1308 accessing this tape. */
1309 static int st_release(struct inode
*inode
, struct file
*filp
)
1312 struct scsi_tape
*STp
= filp
->private_data
;
1314 if (STp
->door_locked
== ST_LOCKED_AUTO
)
1315 do_door_lock(STp
, 0);
1317 normalize_buffer(STp
->buffer
);
1318 write_lock(&st_dev_arr_lock
);
1320 write_unlock(&st_dev_arr_lock
);
1326 /* The checks common to both reading and writing */
1327 static ssize_t
rw_checks(struct scsi_tape
*STp
, struct file
*filp
, size_t count
)
1332 * If we are in the middle of error recovery, don't let anyone
1333 * else try and use this device. Also, if error recovery fails, it
1334 * may try and take the device offline, in which case all further
1335 * access to the device is prohibited.
1337 if (!scsi_block_when_processing_errors(STp
->device
)) {
1342 if (STp
->ready
!= ST_READY
) {
1343 if (STp
->ready
== ST_NO_TAPE
)
1344 retval
= (-ENOMEDIUM
);
1350 if (! STp
->modes
[STp
->current_mode
].defined
) {
1357 * If there was a bus reset, block further access
1360 if (STp
->pos_unknown
) {
1370 printk(ST_DEB_MSG
"%s: Incorrect device.\n", tape_name(STp
));
1375 if (STp
->can_partitions
&&
1376 (retval
= switch_partition(STp
)) < 0)
1379 if (STp
->block_size
== 0 && STp
->max_block
> 0 &&
1380 (count
< STp
->min_block
|| count
> STp
->max_block
)) {
1385 if (STp
->do_auto_lock
&& STp
->door_locked
== ST_UNLOCKED
&&
1386 !do_door_lock(STp
, 1))
1387 STp
->door_locked
= ST_LOCKED_AUTO
;
1394 static int setup_buffering(struct scsi_tape
*STp
, const char __user
*buf
,
1395 size_t count
, int is_read
)
1397 int i
, bufsize
, retval
= 0;
1398 struct st_buffer
*STbp
= STp
->buffer
;
1401 i
= STp
->try_dio
&& try_rdio
;
1403 i
= STp
->try_dio
&& try_wdio
;
1405 if (i
&& ((unsigned long)buf
& queue_dma_alignment(
1406 STp
->device
->request_queue
)) == 0) {
1407 i
= sgl_map_user_pages(&(STbp
->sg
[0]), STbp
->use_sg
,
1408 (unsigned long)buf
, count
, (is_read
? READ
: WRITE
));
1411 STbp
->buffer_bytes
= 0; /* can be used as transfer counter */
1414 STbp
->do_dio
= 0; /* fall back to buffering with any error */
1415 STbp
->sg_segs
= STbp
->do_dio
;
1416 STbp
->frp_sg_current
= 0;
1420 STp
->nbr_pages
+= STbp
->do_dio
;
1421 for (i
=1; i
< STbp
->do_dio
; i
++)
1422 if (page_to_pfn(STbp
->sg
[i
].page
) == page_to_pfn(STbp
->sg
[i
-1].page
) + 1)
1423 STp
->nbr_combinable
++;
1428 DEB( STp
->nbr_requests
++; )
1430 if (!STbp
->do_dio
) {
1431 if (STp
->block_size
)
1432 bufsize
= STp
->block_size
> st_fixed_buffer_size
?
1433 STp
->block_size
: st_fixed_buffer_size
;
1436 if (bufsize
> STbp
->buffer_size
&&
1437 !enlarge_buffer(STbp
, bufsize
, STp
->restr_dma
)) {
1438 printk(KERN_WARNING
"%s: Can't allocate %d byte tape buffer.\n",
1439 tape_name(STp
), bufsize
);
1440 retval
= (-EOVERFLOW
);
1443 if (STp
->block_size
)
1444 STbp
->buffer_blocks
= bufsize
/ STp
->block_size
;
1452 /* Can be called more than once after each setup_buffer() */
1453 static void release_buffering(struct scsi_tape
*STp
, int is_read
)
1455 struct st_buffer
*STbp
;
1459 sgl_unmap_user_pages(&(STbp
->sg
[0]), STbp
->do_dio
, is_read
);
1468 st_write(struct file
*filp
, const char __user
*buf
, size_t count
, loff_t
* ppos
)
1471 ssize_t i
, do_count
, blks
, transfer
;
1473 int undone
, retry_eot
= 0, scode
;
1475 unsigned char cmd
[MAX_COMMAND_SIZE
];
1476 const char __user
*b_point
;
1477 struct st_request
*SRpnt
= NULL
;
1478 struct scsi_tape
*STp
= filp
->private_data
;
1479 struct st_modedef
*STm
;
1480 struct st_partstat
*STps
;
1481 struct st_buffer
*STbp
;
1482 char *name
= tape_name(STp
);
1484 if (down_interruptible(&STp
->lock
))
1485 return -ERESTARTSYS
;
1487 retval
= rw_checks(STp
, filp
, count
);
1488 if (retval
|| count
== 0)
1491 /* Write must be integral number of blocks */
1492 if (STp
->block_size
!= 0 && (count
% STp
->block_size
) != 0) {
1493 printk(KERN_WARNING
"%s: Write not multiple of tape block size.\n",
1499 STm
= &(STp
->modes
[STp
->current_mode
]);
1500 STps
= &(STp
->ps
[STp
->partition
]);
1502 if (STp
->write_prot
) {
1508 if (STps
->rw
== ST_READING
) {
1509 retval
= flush_buffer(STp
, 0);
1512 STps
->rw
= ST_WRITING
;
1513 } else if (STps
->rw
!= ST_WRITING
&&
1514 STps
->drv_file
== 0 && STps
->drv_block
== 0) {
1515 if ((retval
= set_mode_densblk(STp
, STm
)) < 0)
1517 if (STm
->default_compression
!= ST_DONT_TOUCH
&&
1518 !(STp
->compression_changed
)) {
1519 if (st_compression(STp
, (STm
->default_compression
== ST_YES
))) {
1520 printk(KERN_WARNING
"%s: Can't set default compression.\n",
1522 if (modes_defined
) {
1531 i
= write_behind_check(STp
);
1534 STps
->eof
= ST_EOM_OK
;
1536 STps
->eof
= ST_EOM_ERROR
;
1539 if (STps
->eof
== ST_EOM_OK
) {
1540 STps
->eof
= ST_EOD_1
; /* allow next write */
1544 else if (STps
->eof
== ST_EOM_ERROR
) {
1549 /* Check the buffer readability in cases where copy_user might catch
1550 the problems after some tape movement. */
1551 if (STp
->block_size
!= 0 &&
1553 (copy_from_user(&i
, buf
, 1) != 0 ||
1554 copy_from_user(&i
, buf
+ count
- 1, 1) != 0)) {
1559 retval
= setup_buffering(STp
, buf
, count
, 0);
1565 memset(cmd
, 0, MAX_COMMAND_SIZE
);
1567 cmd
[1] = (STp
->block_size
!= 0);
1569 STps
->rw
= ST_WRITING
;
1572 while (count
> 0 && !retry_eot
) {
1578 if (STp
->block_size
== 0)
1581 do_count
= STbp
->buffer_blocks
* STp
->block_size
-
1583 if (do_count
> count
)
1587 i
= append_to_buffer(b_point
, STbp
, do_count
);
1594 b_point
+= do_count
;
1596 async_write
= STp
->block_size
== 0 && !STbp
->do_dio
&&
1597 STm
->do_async_writes
&& STps
->eof
< ST_EOM_OK
;
1599 if (STp
->block_size
!= 0 && STm
->do_buffer_writes
&&
1600 !(STp
->try_dio
&& try_wdio
) && STps
->eof
< ST_EOM_OK
&&
1601 STbp
->buffer_bytes
< STbp
->buffer_size
) {
1603 /* Don't write a buffer that is not full enough. */
1604 if (!async_write
&& count
== 0)
1609 if (STp
->block_size
== 0)
1610 blks
= transfer
= do_count
;
1613 blks
= STbp
->buffer_bytes
;
1616 blks
/= STp
->block_size
;
1617 transfer
= blks
* STp
->block_size
;
1619 cmd
[2] = blks
>> 16;
1623 SRpnt
= st_do_scsi(SRpnt
, STp
, cmd
, transfer
, DMA_TO_DEVICE
,
1624 STp
->device
->timeout
, MAX_WRITE_RETRIES
, !async_write
);
1626 retval
= STbp
->syscall_result
;
1629 if (async_write
&& !STbp
->syscall_result
) {
1630 STbp
->writing
= transfer
;
1631 STp
->dirty
= !(STbp
->writing
==
1632 STbp
->buffer_bytes
);
1633 SRpnt
= NULL
; /* Prevent releasing this request! */
1634 DEB( STp
->write_pending
= 1; )
1638 if (STbp
->syscall_result
!= 0) {
1639 struct st_cmdstatus
*cmdstatp
= &STp
->buffer
->cmdstat
;
1641 DEBC(printk(ST_DEB_MSG
"%s: Error on write:\n", name
));
1642 if (cmdstatp
->have_sense
&& (cmdstatp
->flags
& SENSE_EOM
)) {
1643 scode
= cmdstatp
->sense_hdr
.sense_key
;
1644 if (cmdstatp
->remainder_valid
)
1645 undone
= (int)cmdstatp
->uremainder64
;
1646 else if (STp
->block_size
== 0 &&
1647 scode
== VOLUME_OVERFLOW
)
1651 if (STp
->block_size
!= 0)
1652 undone
*= STp
->block_size
;
1653 if (undone
<= do_count
) {
1654 /* Only data from this write is not written */
1657 if (STp
->block_size
)
1658 blks
= (transfer
- undone
) / STp
->block_size
;
1659 STps
->eof
= ST_EOM_OK
;
1660 /* Continue in fixed block mode if all written
1661 in this request but still something left to write
1662 (retval left to zero)
1664 if (STp
->block_size
== 0 ||
1665 undone
> 0 || count
== 0)
1666 retval
= (-ENOSPC
); /* EOM within current request */
1667 DEBC(printk(ST_DEB_MSG
1668 "%s: EOM with %d bytes unwritten.\n",
1671 /* EOT within data buffered earlier (possible only
1672 in fixed block mode without direct i/o) */
1673 if (!retry_eot
&& !cmdstatp
->deferred
&&
1674 (scode
== NO_SENSE
|| scode
== RECOVERED_ERROR
)) {
1675 move_buffer_data(STp
->buffer
, transfer
- undone
);
1677 if (STps
->drv_block
>= 0) {
1678 STps
->drv_block
+= (transfer
- undone
) /
1681 STps
->eof
= ST_EOM_OK
;
1682 DEBC(printk(ST_DEB_MSG
1683 "%s: Retry write of %d bytes at EOM.\n",
1684 name
, STp
->buffer
->buffer_bytes
));
1688 /* Either error within data buffered by driver or
1691 blks
= do_count
= 0;
1692 STps
->eof
= ST_EOM_ERROR
;
1693 STps
->drv_block
= (-1); /* Too cautious? */
1694 retval
= (-EIO
); /* EOM for old data */
1695 DEBC(printk(ST_DEB_MSG
1696 "%s: EOM with lost data.\n",
1702 STps
->drv_block
= (-1); /* Too cautious? */
1703 retval
= STbp
->syscall_result
;
1708 if (STps
->drv_block
>= 0) {
1709 if (STp
->block_size
== 0)
1710 STps
->drv_block
+= (do_count
> 0);
1712 STps
->drv_block
+= blks
;
1715 STbp
->buffer_bytes
= 0;
1718 if (retval
|| retry_eot
) {
1720 retval
= total
- count
;
1725 if (STps
->eof
== ST_EOD_1
)
1726 STps
->eof
= ST_EOM_OK
;
1727 else if (STps
->eof
!= ST_EOM_OK
)
1728 STps
->eof
= ST_NOEOF
;
1729 retval
= total
- count
;
1733 st_release_request(SRpnt
);
1734 release_buffering(STp
, 0);
1740 /* Read data from the tape. Returns zero in the normal case, one if the
1741 eof status has changed, and the negative error code in case of a
1742 fatal error. Otherwise updates the buffer and the eof state.
1744 Does release user buffer mapping if it is set.
1746 static long read_tape(struct scsi_tape
*STp
, long count
,
1747 struct st_request
** aSRpnt
)
1749 int transfer
, blks
, bytes
;
1750 unsigned char cmd
[MAX_COMMAND_SIZE
];
1751 struct st_request
*SRpnt
;
1752 struct st_modedef
*STm
;
1753 struct st_partstat
*STps
;
1754 struct st_buffer
*STbp
;
1756 char *name
= tape_name(STp
);
1761 STm
= &(STp
->modes
[STp
->current_mode
]);
1762 STps
= &(STp
->ps
[STp
->partition
]);
1763 if (STps
->eof
== ST_FM_HIT
)
1767 if (STp
->block_size
== 0)
1768 blks
= bytes
= count
;
1770 if (!(STp
->try_dio
&& try_rdio
) && STm
->do_read_ahead
) {
1771 blks
= (STp
->buffer
)->buffer_blocks
;
1772 bytes
= blks
* STp
->block_size
;
1775 if (!STbp
->do_dio
&& bytes
> (STp
->buffer
)->buffer_size
)
1776 bytes
= (STp
->buffer
)->buffer_size
;
1777 blks
= bytes
/ STp
->block_size
;
1778 bytes
= blks
* STp
->block_size
;
1782 memset(cmd
, 0, MAX_COMMAND_SIZE
);
1784 cmd
[1] = (STp
->block_size
!= 0);
1785 cmd
[2] = blks
>> 16;
1790 SRpnt
= st_do_scsi(SRpnt
, STp
, cmd
, bytes
, DMA_FROM_DEVICE
,
1791 STp
->device
->timeout
, MAX_RETRIES
, 1);
1792 release_buffering(STp
, 1);
1795 return STbp
->syscall_result
;
1797 STbp
->read_pointer
= 0;
1800 /* Something to check */
1801 if (STbp
->syscall_result
) {
1802 struct st_cmdstatus
*cmdstatp
= &STp
->buffer
->cmdstat
;
1805 DEBC(printk(ST_DEB_MSG
"%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1807 SRpnt
->sense
[0], SRpnt
->sense
[1],
1808 SRpnt
->sense
[2], SRpnt
->sense
[3],
1809 SRpnt
->sense
[4], SRpnt
->sense
[5],
1810 SRpnt
->sense
[6], SRpnt
->sense
[7]));
1811 if (cmdstatp
->have_sense
) {
1813 if (cmdstatp
->sense_hdr
.sense_key
== BLANK_CHECK
)
1814 cmdstatp
->flags
&= 0xcf; /* No need for EOM in this case */
1816 if (cmdstatp
->flags
!= 0) { /* EOF, EOM, or ILI */
1817 /* Compute the residual count */
1818 if (cmdstatp
->remainder_valid
)
1819 transfer
= (int)cmdstatp
->uremainder64
;
1822 if (STp
->block_size
== 0 &&
1823 cmdstatp
->sense_hdr
.sense_key
== MEDIUM_ERROR
)
1826 if (cmdstatp
->flags
& SENSE_ILI
) { /* ILI */
1827 if (STp
->block_size
== 0) {
1828 if (transfer
<= 0) {
1831 "%s: Failed to read %d byte block with %d byte transfer.\n",
1832 name
, bytes
- transfer
, bytes
);
1833 if (STps
->drv_block
>= 0)
1834 STps
->drv_block
+= 1;
1835 STbp
->buffer_bytes
= 0;
1838 STbp
->buffer_bytes
= bytes
- transfer
;
1840 st_release_request(SRpnt
);
1841 SRpnt
= *aSRpnt
= NULL
;
1842 if (transfer
== blks
) { /* We did not get anything, error */
1843 printk(KERN_NOTICE
"%s: Incorrect block size.\n", name
);
1844 if (STps
->drv_block
>= 0)
1845 STps
->drv_block
+= blks
- transfer
+ 1;
1846 st_int_ioctl(STp
, MTBSR
, 1);
1849 /* We have some data, deliver it */
1850 STbp
->buffer_bytes
= (blks
- transfer
) *
1852 DEBC(printk(ST_DEB_MSG
1853 "%s: ILI but enough data received %ld %d.\n",
1854 name
, count
, STbp
->buffer_bytes
));
1855 if (STps
->drv_block
>= 0)
1856 STps
->drv_block
+= 1;
1857 if (st_int_ioctl(STp
, MTBSR
, 1))
1860 } else if (cmdstatp
->flags
& SENSE_FMK
) { /* FM overrides EOM */
1861 if (STps
->eof
!= ST_FM_HIT
)
1862 STps
->eof
= ST_FM_HIT
;
1864 STps
->eof
= ST_EOD_2
;
1865 if (STp
->block_size
== 0)
1866 STbp
->buffer_bytes
= 0;
1868 STbp
->buffer_bytes
=
1869 bytes
- transfer
* STp
->block_size
;
1870 DEBC(printk(ST_DEB_MSG
1871 "%s: EOF detected (%d bytes read).\n",
1872 name
, STbp
->buffer_bytes
));
1873 } else if (cmdstatp
->flags
& SENSE_EOM
) {
1874 if (STps
->eof
== ST_FM
)
1875 STps
->eof
= ST_EOD_1
;
1877 STps
->eof
= ST_EOM_OK
;
1878 if (STp
->block_size
== 0)
1879 STbp
->buffer_bytes
= bytes
- transfer
;
1881 STbp
->buffer_bytes
=
1882 bytes
- transfer
* STp
->block_size
;
1884 DEBC(printk(ST_DEB_MSG
"%s: EOM detected (%d bytes read).\n",
1885 name
, STbp
->buffer_bytes
));
1888 /* end of EOF, EOM, ILI test */
1889 else { /* nonzero sense key */
1890 DEBC(printk(ST_DEB_MSG
1891 "%s: Tape error while reading.\n", name
));
1892 STps
->drv_block
= (-1);
1893 if (STps
->eof
== ST_FM
&&
1894 cmdstatp
->sense_hdr
.sense_key
== BLANK_CHECK
) {
1895 DEBC(printk(ST_DEB_MSG
1896 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1898 STps
->eof
= ST_EOD_2
; /* First BLANK_CHECK after FM */
1899 } else /* Some other extended sense code */
1903 if (STbp
->buffer_bytes
< 0) /* Caused by bogus sense data */
1904 STbp
->buffer_bytes
= 0;
1906 /* End of extended sense test */
1907 else { /* Non-extended sense */
1908 retval
= STbp
->syscall_result
;
1912 /* End of error handling */
1913 else /* Read successful */
1914 STbp
->buffer_bytes
= bytes
;
1916 if (STps
->drv_block
>= 0) {
1917 if (STp
->block_size
== 0)
1920 STps
->drv_block
+= STbp
->buffer_bytes
/ STp
->block_size
;
1928 st_read(struct file
*filp
, char __user
*buf
, size_t count
, loff_t
* ppos
)
1932 ssize_t i
, transfer
;
1933 int special
, do_dio
= 0;
1934 struct st_request
*SRpnt
= NULL
;
1935 struct scsi_tape
*STp
= filp
->private_data
;
1936 struct st_modedef
*STm
;
1937 struct st_partstat
*STps
;
1938 struct st_buffer
*STbp
= STp
->buffer
;
1939 DEB( char *name
= tape_name(STp
); )
1941 if (down_interruptible(&STp
->lock
))
1942 return -ERESTARTSYS
;
1944 retval
= rw_checks(STp
, filp
, count
);
1945 if (retval
|| count
== 0)
1948 STm
= &(STp
->modes
[STp
->current_mode
]);
1949 if (!(STm
->do_read_ahead
) && STp
->block_size
!= 0 &&
1950 (count
% STp
->block_size
) != 0) {
1951 retval
= (-EINVAL
); /* Read must be integral number of blocks */
1955 STps
= &(STp
->ps
[STp
->partition
]);
1956 if (STps
->rw
== ST_WRITING
) {
1957 retval
= flush_buffer(STp
, 0);
1960 STps
->rw
= ST_READING
;
1963 if (debugging
&& STps
->eof
!= ST_NOEOF
)
1964 printk(ST_DEB_MSG
"%s: EOF/EOM flag up (%d). Bytes %d\n", name
,
1965 STps
->eof
, STbp
->buffer_bytes
);
1968 retval
= setup_buffering(STp
, buf
, count
, 1);
1971 do_dio
= STbp
->do_dio
;
1973 if (STbp
->buffer_bytes
== 0 &&
1974 STps
->eof
>= ST_EOD_1
) {
1975 if (STps
->eof
< ST_EOD
) {
1980 retval
= (-EIO
); /* EOM or Blank Check */
1985 /* Check the buffer writability before any tape movement. Don't alter
1987 if (copy_from_user(&i
, buf
, 1) != 0 ||
1988 copy_to_user(buf
, &i
, 1) != 0 ||
1989 copy_from_user(&i
, buf
+ count
- 1, 1) != 0 ||
1990 copy_to_user(buf
+ count
- 1, &i
, 1) != 0) {
1996 STps
->rw
= ST_READING
;
1999 /* Loop until enough data in buffer or a special condition found */
2000 for (total
= 0, special
= 0; total
< count
&& !special
;) {
2002 /* Get new data if the buffer is empty */
2003 if (STbp
->buffer_bytes
== 0) {
2004 special
= read_tape(STp
, count
- total
, &SRpnt
);
2005 if (special
< 0) { /* No need to continue read */
2011 /* Move the data from driver buffer to user buffer */
2012 if (STbp
->buffer_bytes
> 0) {
2014 if (debugging
&& STps
->eof
!= ST_NOEOF
)
2016 "%s: EOF up (%d). Left %d, needed %d.\n", name
,
2017 STps
->eof
, STbp
->buffer_bytes
,
2018 (int)(count
- total
));
2020 transfer
= STbp
->buffer_bytes
< count
- total
?
2021 STbp
->buffer_bytes
: count
- total
;
2023 i
= from_buffer(STbp
, buf
, transfer
);
2033 if (STp
->block_size
== 0)
2034 break; /* Read only one variable length block */
2036 } /* for (total = 0, special = 0;
2037 total < count && !special; ) */
2039 /* Change the eof state if no data from tape or buffer */
2041 if (STps
->eof
== ST_FM_HIT
) {
2043 STps
->drv_block
= 0;
2044 if (STps
->drv_file
>= 0)
2046 } else if (STps
->eof
== ST_EOD_1
) {
2047 STps
->eof
= ST_EOD_2
;
2048 STps
->drv_block
= 0;
2049 if (STps
->drv_file
>= 0)
2051 } else if (STps
->eof
== ST_EOD_2
)
2053 } else if (STps
->eof
== ST_FM
)
2054 STps
->eof
= ST_NOEOF
;
2058 if (SRpnt
!= NULL
) {
2059 st_release_request(SRpnt
);
2063 release_buffering(STp
, 1);
2064 STbp
->buffer_bytes
= 0;
2074 /* Set the driver options */
2075 static void st_log_options(struct scsi_tape
* STp
, struct st_modedef
* STm
, char *name
)
2079 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2080 name
, STp
->current_mode
, STm
->do_buffer_writes
, STm
->do_async_writes
,
2081 STm
->do_read_ahead
);
2083 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2084 name
, STp
->can_bsr
, STp
->two_fm
, STp
->fast_mteom
, STp
->do_auto_lock
);
2086 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2087 name
, STm
->defaults_for_writes
, STp
->omit_blklims
, STp
->can_partitions
,
2088 STp
->scsi2_logical
);
2090 "%s: sysv: %d nowait: %d\n", name
, STm
->sysv
, STp
->immediate
);
2091 printk(KERN_INFO
"%s: debugging: %d\n",
2098 static int st_set_options(struct scsi_tape
*STp
, long options
)
2102 struct st_modedef
*STm
;
2103 char *name
= tape_name(STp
);
2104 struct cdev
*cd0
, *cd1
;
2106 STm
= &(STp
->modes
[STp
->current_mode
]);
2107 if (!STm
->defined
) {
2108 cd0
= STm
->cdevs
[0]; cd1
= STm
->cdevs
[1];
2109 memcpy(STm
, &(STp
->modes
[0]), sizeof(struct st_modedef
));
2110 STm
->cdevs
[0] = cd0
; STm
->cdevs
[1] = cd1
;
2112 DEBC(printk(ST_DEB_MSG
2113 "%s: Initialized mode %d definition from mode 0\n",
2114 name
, STp
->current_mode
));
2117 code
= options
& MT_ST_OPTIONS
;
2118 if (code
== MT_ST_BOOLEANS
) {
2119 STm
->do_buffer_writes
= (options
& MT_ST_BUFFER_WRITES
) != 0;
2120 STm
->do_async_writes
= (options
& MT_ST_ASYNC_WRITES
) != 0;
2121 STm
->defaults_for_writes
= (options
& MT_ST_DEF_WRITES
) != 0;
2122 STm
->do_read_ahead
= (options
& MT_ST_READ_AHEAD
) != 0;
2123 STp
->two_fm
= (options
& MT_ST_TWO_FM
) != 0;
2124 STp
->fast_mteom
= (options
& MT_ST_FAST_MTEOM
) != 0;
2125 STp
->do_auto_lock
= (options
& MT_ST_AUTO_LOCK
) != 0;
2126 STp
->can_bsr
= (options
& MT_ST_CAN_BSR
) != 0;
2127 STp
->omit_blklims
= (options
& MT_ST_NO_BLKLIMS
) != 0;
2128 if ((STp
->device
)->scsi_level
>= SCSI_2
)
2129 STp
->can_partitions
= (options
& MT_ST_CAN_PARTITIONS
) != 0;
2130 STp
->scsi2_logical
= (options
& MT_ST_SCSI2LOGICAL
) != 0;
2131 STp
->immediate
= (options
& MT_ST_NOWAIT
) != 0;
2132 STm
->sysv
= (options
& MT_ST_SYSV
) != 0;
2133 DEB( debugging
= (options
& MT_ST_DEBUGGING
) != 0;
2134 st_log_options(STp
, STm
, name
); )
2135 } else if (code
== MT_ST_SETBOOLEANS
|| code
== MT_ST_CLEARBOOLEANS
) {
2136 value
= (code
== MT_ST_SETBOOLEANS
);
2137 if ((options
& MT_ST_BUFFER_WRITES
) != 0)
2138 STm
->do_buffer_writes
= value
;
2139 if ((options
& MT_ST_ASYNC_WRITES
) != 0)
2140 STm
->do_async_writes
= value
;
2141 if ((options
& MT_ST_DEF_WRITES
) != 0)
2142 STm
->defaults_for_writes
= value
;
2143 if ((options
& MT_ST_READ_AHEAD
) != 0)
2144 STm
->do_read_ahead
= value
;
2145 if ((options
& MT_ST_TWO_FM
) != 0)
2146 STp
->two_fm
= value
;
2147 if ((options
& MT_ST_FAST_MTEOM
) != 0)
2148 STp
->fast_mteom
= value
;
2149 if ((options
& MT_ST_AUTO_LOCK
) != 0)
2150 STp
->do_auto_lock
= value
;
2151 if ((options
& MT_ST_CAN_BSR
) != 0)
2152 STp
->can_bsr
= value
;
2153 if ((options
& MT_ST_NO_BLKLIMS
) != 0)
2154 STp
->omit_blklims
= value
;
2155 if ((STp
->device
)->scsi_level
>= SCSI_2
&&
2156 (options
& MT_ST_CAN_PARTITIONS
) != 0)
2157 STp
->can_partitions
= value
;
2158 if ((options
& MT_ST_SCSI2LOGICAL
) != 0)
2159 STp
->scsi2_logical
= value
;
2160 if ((options
& MT_ST_NOWAIT
) != 0)
2161 STp
->immediate
= value
;
2162 if ((options
& MT_ST_SYSV
) != 0)
2165 if ((options
& MT_ST_DEBUGGING
) != 0)
2167 st_log_options(STp
, STm
, name
); )
2168 } else if (code
== MT_ST_WRITE_THRESHOLD
) {
2169 /* Retained for compatibility */
2170 } else if (code
== MT_ST_DEF_BLKSIZE
) {
2171 value
= (options
& ~MT_ST_OPTIONS
);
2172 if (value
== ~MT_ST_OPTIONS
) {
2173 STm
->default_blksize
= (-1);
2174 DEBC( printk(KERN_INFO
"%s: Default block size disabled.\n", name
));
2176 STm
->default_blksize
= value
;
2177 DEBC( printk(KERN_INFO
"%s: Default block size set to %d bytes.\n",
2178 name
, STm
->default_blksize
));
2179 if (STp
->ready
== ST_READY
) {
2180 STp
->blksize_changed
= 0;
2181 set_mode_densblk(STp
, STm
);
2184 } else if (code
== MT_ST_TIMEOUTS
) {
2185 value
= (options
& ~MT_ST_OPTIONS
);
2186 if ((value
& MT_ST_SET_LONG_TIMEOUT
) != 0) {
2187 STp
->long_timeout
= (value
& ~MT_ST_SET_LONG_TIMEOUT
) * HZ
;
2188 DEBC( printk(KERN_INFO
"%s: Long timeout set to %d seconds.\n", name
,
2189 (value
& ~MT_ST_SET_LONG_TIMEOUT
)));
2191 STp
->device
->timeout
= value
* HZ
;
2192 DEBC( printk(KERN_INFO
"%s: Normal timeout set to %d seconds.\n",
2195 } else if (code
== MT_ST_SET_CLN
) {
2196 value
= (options
& ~MT_ST_OPTIONS
) & 0xff;
2198 value
< EXTENDED_SENSE_START
&& value
>= SCSI_SENSE_BUFFERSIZE
)
2200 STp
->cln_mode
= value
;
2201 STp
->cln_sense_mask
= (options
>> 8) & 0xff;
2202 STp
->cln_sense_value
= (options
>> 16) & 0xff;
2204 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2205 name
, value
, STp
->cln_sense_mask
, STp
->cln_sense_value
);
2206 } else if (code
== MT_ST_DEF_OPTIONS
) {
2207 code
= (options
& ~MT_ST_CLEAR_DEFAULT
);
2208 value
= (options
& MT_ST_CLEAR_DEFAULT
);
2209 if (code
== MT_ST_DEF_DENSITY
) {
2210 if (value
== MT_ST_CLEAR_DEFAULT
) {
2211 STm
->default_density
= (-1);
2212 DEBC( printk(KERN_INFO
"%s: Density default disabled.\n",
2215 STm
->default_density
= value
& 0xff;
2216 DEBC( printk(KERN_INFO
"%s: Density default set to %x\n",
2217 name
, STm
->default_density
));
2218 if (STp
->ready
== ST_READY
) {
2219 STp
->density_changed
= 0;
2220 set_mode_densblk(STp
, STm
);
2223 } else if (code
== MT_ST_DEF_DRVBUFFER
) {
2224 if (value
== MT_ST_CLEAR_DEFAULT
) {
2225 STp
->default_drvbuffer
= 0xff;
2226 DEBC( printk(KERN_INFO
2227 "%s: Drive buffer default disabled.\n", name
));
2229 STp
->default_drvbuffer
= value
& 7;
2230 DEBC( printk(KERN_INFO
2231 "%s: Drive buffer default set to %x\n",
2232 name
, STp
->default_drvbuffer
));
2233 if (STp
->ready
== ST_READY
)
2234 st_int_ioctl(STp
, MTSETDRVBUFFER
, STp
->default_drvbuffer
);
2236 } else if (code
== MT_ST_DEF_COMPRESSION
) {
2237 if (value
== MT_ST_CLEAR_DEFAULT
) {
2238 STm
->default_compression
= ST_DONT_TOUCH
;
2239 DEBC( printk(KERN_INFO
2240 "%s: Compression default disabled.\n", name
));
2242 if ((value
& 0xff00) != 0) {
2243 STp
->c_algo
= (value
& 0xff00) >> 8;
2244 DEBC( printk(KERN_INFO
"%s: Compression algorithm set to 0x%x.\n",
2245 name
, STp
->c_algo
));
2247 if ((value
& 0xff) != 0xff) {
2248 STm
->default_compression
= (value
& 1 ? ST_YES
: ST_NO
);
2249 DEBC( printk(KERN_INFO
"%s: Compression default set to %x\n",
2250 name
, (value
& 1)));
2251 if (STp
->ready
== ST_READY
) {
2252 STp
->compression_changed
= 0;
2253 st_compression(STp
, (STm
->default_compression
== ST_YES
));
2264 #define MODE_HEADER_LENGTH 4
2266 /* Mode header and page byte offsets */
2267 #define MH_OFF_DATA_LENGTH 0
2268 #define MH_OFF_MEDIUM_TYPE 1
2269 #define MH_OFF_DEV_SPECIFIC 2
2270 #define MH_OFF_BDESCS_LENGTH 3
2271 #define MP_OFF_PAGE_NBR 0
2272 #define MP_OFF_PAGE_LENGTH 1
2274 /* Mode header and page bit masks */
2275 #define MH_BIT_WP 0x80
2276 #define MP_MSK_PAGE_NBR 0x3f
2278 /* Don't return block descriptors */
2279 #define MODE_SENSE_OMIT_BDESCS 0x08
2281 #define MODE_SELECT_PAGE_FORMAT 0x10
2283 /* Read a mode page into the tape buffer. The block descriptors are included
2284 if incl_block_descs is true. The page control is ored to the page number
2285 parameter, if necessary. */
2286 static int read_mode_page(struct scsi_tape
*STp
, int page
, int omit_block_descs
)
2288 unsigned char cmd
[MAX_COMMAND_SIZE
];
2289 struct st_request
*SRpnt
= NULL
;
2291 memset(cmd
, 0, MAX_COMMAND_SIZE
);
2292 cmd
[0] = MODE_SENSE
;
2293 if (omit_block_descs
)
2294 cmd
[1] = MODE_SENSE_OMIT_BDESCS
;
2298 SRpnt
= st_do_scsi(SRpnt
, STp
, cmd
, cmd
[4], DMA_FROM_DEVICE
,
2299 STp
->device
->timeout
, 0, 1);
2301 return (STp
->buffer
)->syscall_result
;
2303 st_release_request(SRpnt
);
2305 return (STp
->buffer
)->syscall_result
;
2309 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2310 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2311 static int write_mode_page(struct scsi_tape
*STp
, int page
, int slow
)
2314 unsigned char cmd
[MAX_COMMAND_SIZE
];
2315 struct st_request
*SRpnt
= NULL
;
2317 memset(cmd
, 0, MAX_COMMAND_SIZE
);
2318 cmd
[0] = MODE_SELECT
;
2319 cmd
[1] = MODE_SELECT_PAGE_FORMAT
;
2320 pgo
= MODE_HEADER_LENGTH
+ (STp
->buffer
)->b_data
[MH_OFF_BDESCS_LENGTH
];
2321 cmd
[4] = pgo
+ (STp
->buffer
)->b_data
[pgo
+ MP_OFF_PAGE_LENGTH
] + 2;
2323 /* Clear reserved fields */
2324 (STp
->buffer
)->b_data
[MH_OFF_DATA_LENGTH
] = 0;
2325 (STp
->buffer
)->b_data
[MH_OFF_MEDIUM_TYPE
] = 0;
2326 (STp
->buffer
)->b_data
[MH_OFF_DEV_SPECIFIC
] &= ~MH_BIT_WP
;
2327 (STp
->buffer
)->b_data
[pgo
+ MP_OFF_PAGE_NBR
] &= MP_MSK_PAGE_NBR
;
2329 SRpnt
= st_do_scsi(SRpnt
, STp
, cmd
, cmd
[4], DMA_TO_DEVICE
,
2330 (slow
? STp
->long_timeout
: STp
->device
->timeout
), 0, 1);
2332 return (STp
->buffer
)->syscall_result
;
2334 st_release_request(SRpnt
);
2336 return (STp
->buffer
)->syscall_result
;
2340 #define COMPRESSION_PAGE 0x0f
2341 #define COMPRESSION_PAGE_LENGTH 16
2343 #define CP_OFF_DCE_DCC 2
2344 #define CP_OFF_C_ALGO 7
2346 #define DCE_MASK 0x80
2347 #define DCC_MASK 0x40
2348 #define RED_MASK 0x60
2351 /* Control the compression with mode page 15. Algorithm not changed if zero.
2353 The block descriptors are read and written because Sony SDT-7000 does not
2354 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2355 Including block descriptors should not cause any harm to other drives. */
2357 static int st_compression(struct scsi_tape
* STp
, int state
)
2360 int mpoffs
; /* Offset to mode page start */
2361 unsigned char *b_data
= (STp
->buffer
)->b_data
;
2362 DEB( char *name
= tape_name(STp
); )
2364 if (STp
->ready
!= ST_READY
)
2367 /* Read the current page contents */
2368 retval
= read_mode_page(STp
, COMPRESSION_PAGE
, 0);
2370 DEBC(printk(ST_DEB_MSG
"%s: Compression mode page not supported.\n",
2375 mpoffs
= MODE_HEADER_LENGTH
+ b_data
[MH_OFF_BDESCS_LENGTH
];
2376 DEBC(printk(ST_DEB_MSG
"%s: Compression state is %d.\n", name
,
2377 (b_data
[mpoffs
+ CP_OFF_DCE_DCC
] & DCE_MASK
? 1 : 0)));
2379 /* Check if compression can be changed */
2380 if ((b_data
[mpoffs
+ CP_OFF_DCE_DCC
] & DCC_MASK
) == 0) {
2381 DEBC(printk(ST_DEB_MSG
"%s: Compression not supported.\n", name
));
2387 b_data
[mpoffs
+ CP_OFF_DCE_DCC
] |= DCE_MASK
;
2388 if (STp
->c_algo
!= 0)
2389 b_data
[mpoffs
+ CP_OFF_C_ALGO
] = STp
->c_algo
;
2392 b_data
[mpoffs
+ CP_OFF_DCE_DCC
] &= ~DCE_MASK
;
2393 if (STp
->c_algo
!= 0)
2394 b_data
[mpoffs
+ CP_OFF_C_ALGO
] = 0; /* no compression */
2397 retval
= write_mode_page(STp
, COMPRESSION_PAGE
, 0);
2399 DEBC(printk(ST_DEB_MSG
"%s: Compression change failed.\n", name
));
2402 DEBC(printk(ST_DEB_MSG
"%s: Compression state changed to %d.\n",
2405 STp
->compression_changed
= 1;
2410 /* Process the load and unload commands (does unload if the load code is zero) */
2411 static int do_load_unload(struct scsi_tape
*STp
, struct file
*filp
, int load_code
)
2413 int retval
= (-EIO
), timeout
;
2414 DEB( char *name
= tape_name(STp
); )
2415 unsigned char cmd
[MAX_COMMAND_SIZE
];
2416 struct st_partstat
*STps
;
2417 struct st_request
*SRpnt
;
2419 if (STp
->ready
!= ST_READY
&& !load_code
) {
2420 if (STp
->ready
== ST_NO_TAPE
)
2421 return (-ENOMEDIUM
);
2426 memset(cmd
, 0, MAX_COMMAND_SIZE
);
2427 cmd
[0] = START_STOP
;
2431 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2433 if (load_code
>= 1 + MT_ST_HPLOADER_OFFSET
2434 && load_code
<= 6 + MT_ST_HPLOADER_OFFSET
) {
2435 DEBC(printk(ST_DEB_MSG
"%s: Enhanced %sload slot %2d.\n",
2436 name
, (cmd
[4]) ? "" : "un",
2437 load_code
- MT_ST_HPLOADER_OFFSET
));
2438 cmd
[3] = load_code
- MT_ST_HPLOADER_OFFSET
; /* MediaID field of C1553A */
2440 if (STp
->immediate
) {
2441 cmd
[1] = 1; /* Don't wait for completion */
2442 timeout
= STp
->device
->timeout
;
2445 timeout
= STp
->long_timeout
;
2449 printk(ST_DEB_MSG
"%s: Unloading tape.\n", name
);
2451 printk(ST_DEB_MSG
"%s: Loading tape.\n", name
);
2454 SRpnt
= st_do_scsi(NULL
, STp
, cmd
, 0, DMA_NONE
,
2455 timeout
, MAX_RETRIES
, 1);
2457 return (STp
->buffer
)->syscall_result
;
2459 retval
= (STp
->buffer
)->syscall_result
;
2460 st_release_request(SRpnt
);
2462 if (!retval
) { /* SCSI command successful */
2465 STp
->rew_at_close
= 0;
2466 STp
->ready
= ST_NO_TAPE
;
2469 STp
->rew_at_close
= STp
->autorew_dev
;
2470 retval
= check_tape(STp
, filp
);
2476 STps
= &(STp
->ps
[STp
->partition
]);
2477 STps
->drv_file
= STps
->drv_block
= (-1);
2484 #define ST_DEB_FORWARD 0
2485 #define ST_DEB_BACKWARD 1
2486 static void deb_space_print(char *name
, int direction
, char *units
, unsigned char *cmd
)
2490 sc
= cmd
[2] & 0x80 ? 0xff000000 : 0;
2491 sc
|= (cmd
[2] << 16) | (cmd
[3] << 8) | cmd
[4];
2494 printk(ST_DEB_MSG
"%s: Spacing tape %s over %d %s.\n", name
,
2495 direction
? "backward" : "forward", sc
, units
);
2500 /* Internal ioctl function */
2501 static int st_int_ioctl(struct scsi_tape
*STp
, unsigned int cmd_in
, unsigned long arg
)
2507 unsigned char cmd
[MAX_COMMAND_SIZE
];
2508 struct st_request
*SRpnt
;
2509 struct st_partstat
*STps
;
2510 int fileno
, blkno
, at_sm
, undone
;
2511 int datalen
= 0, direction
= DMA_NONE
;
2512 char *name
= tape_name(STp
);
2514 WARN_ON(STp
->buffer
->do_dio
!= 0);
2515 if (STp
->ready
!= ST_READY
) {
2516 if (STp
->ready
== ST_NO_TAPE
)
2517 return (-ENOMEDIUM
);
2521 timeout
= STp
->long_timeout
;
2522 STps
= &(STp
->ps
[STp
->partition
]);
2523 fileno
= STps
->drv_file
;
2524 blkno
= STps
->drv_block
;
2525 at_sm
= STps
->at_sm
;
2527 memset(cmd
, 0, MAX_COMMAND_SIZE
);
2530 chg_eof
= 0; /* Changed from the FSF after this */
2533 cmd
[1] = 0x01; /* Space FileMarks */
2534 cmd
[2] = (arg
>> 16);
2535 cmd
[3] = (arg
>> 8);
2537 DEBC(deb_space_print(name
, ST_DEB_FORWARD
, "filemarks", cmd
);)
2541 at_sm
&= (arg
== 0);
2544 chg_eof
= 0; /* Changed from the FSF after this */
2547 cmd
[1] = 0x01; /* Space FileMarks */
2549 cmd
[2] = (ltmp
>> 16);
2550 cmd
[3] = (ltmp
>> 8);
2552 DEBC(deb_space_print(name
, ST_DEB_BACKWARD
, "filemarks", cmd
);)
2555 blkno
= (-1); /* We can't know the block number */
2556 at_sm
&= (arg
== 0);
2560 cmd
[1] = 0x00; /* Space Blocks */
2561 cmd
[2] = (arg
>> 16);
2562 cmd
[3] = (arg
>> 8);
2564 DEBC(deb_space_print(name
, ST_DEB_FORWARD
, "blocks", cmd
);)
2567 at_sm
&= (arg
== 0);
2571 cmd
[1] = 0x00; /* Space Blocks */
2573 cmd
[2] = (ltmp
>> 16);
2574 cmd
[3] = (ltmp
>> 8);
2576 DEBC(deb_space_print(name
, ST_DEB_BACKWARD
, "blocks", cmd
);)
2579 at_sm
&= (arg
== 0);
2583 cmd
[1] = 0x04; /* Space Setmarks */
2584 cmd
[2] = (arg
>> 16);
2585 cmd
[3] = (arg
>> 8);
2587 DEBC(deb_space_print(name
, ST_DEB_FORWARD
, "setmarks", cmd
);)
2589 blkno
= fileno
= (-1);
2595 cmd
[1] = 0x04; /* Space Setmarks */
2597 cmd
[2] = (ltmp
>> 16);
2598 cmd
[3] = (ltmp
>> 8);
2600 DEBC(deb_space_print(name
, ST_DEB_BACKWARD
, "setmarks", cmd
);)
2602 blkno
= fileno
= (-1);
2608 if (STp
->write_prot
)
2610 cmd
[0] = WRITE_FILEMARKS
;
2611 if (cmd_in
== MTWSM
)
2613 cmd
[2] = (arg
>> 16);
2614 cmd
[3] = (arg
>> 8);
2616 timeout
= STp
->device
->timeout
;
2618 if (cmd_in
== MTWEOF
)
2619 printk(ST_DEB_MSG
"%s: Writing %d filemarks.\n", name
,
2620 cmd
[2] * 65536 + cmd
[3] * 256 + cmd
[4]);
2622 printk(ST_DEB_MSG
"%s: Writing %d setmarks.\n", name
,
2623 cmd
[2] * 65536 + cmd
[3] * 256 + cmd
[4]);
2628 at_sm
= (cmd_in
== MTWSM
);
2631 cmd
[0] = REZERO_UNIT
;
2632 if (STp
->immediate
) {
2633 cmd
[1] = 1; /* Don't wait for completion */
2634 timeout
= STp
->device
->timeout
;
2636 DEBC(printk(ST_DEB_MSG
"%s: Rewinding tape.\n", name
));
2637 fileno
= blkno
= at_sm
= 0;
2640 DEBC(printk(ST_DEB_MSG
"%s: No op on tape.\n", name
));
2641 return 0; /* Should do something ? */
2644 cmd
[0] = START_STOP
;
2645 if (STp
->immediate
) {
2646 cmd
[1] = 1; /* Don't wait for completion */
2647 timeout
= STp
->device
->timeout
;
2650 DEBC(printk(ST_DEB_MSG
"%s: Retensioning tape.\n", name
));
2651 fileno
= blkno
= at_sm
= 0;
2654 if (!STp
->fast_mteom
) {
2655 /* space to the end of tape */
2656 ioctl_result
= st_int_ioctl(STp
, MTFSF
, 0x7fffff);
2657 fileno
= STps
->drv_file
;
2658 if (STps
->eof
>= ST_EOD_1
)
2660 /* The next lines would hide the number of spaced FileMarks
2661 That's why I inserted the previous lines. I had no luck
2662 with detecting EOM with FSF, so we go now to EOM.
2668 DEBC(printk(ST_DEB_MSG
"%s: Spacing to end of recorded medium.\n",
2674 if (STp
->write_prot
)
2677 cmd
[1] = (arg
? 1 : 0); /* Long erase with non-zero argument */
2678 if (STp
->immediate
) {
2679 cmd
[1] |= 2; /* Don't wait for completion */
2680 timeout
= STp
->device
->timeout
;
2683 timeout
= STp
->long_timeout
* 8;
2685 DEBC(printk(ST_DEB_MSG
"%s: Erasing tape.\n", name
));
2686 fileno
= blkno
= at_sm
= 0;
2688 case MTSETBLK
: /* Set block length */
2689 case MTSETDENSITY
: /* Set tape density */
2690 case MTSETDRVBUFFER
: /* Set drive buffering */
2691 case SET_DENS_AND_BLK
: /* Set density and block size */
2693 if (STp
->dirty
|| (STp
->buffer
)->buffer_bytes
!= 0)
2694 return (-EIO
); /* Not allowed if data in buffer */
2695 if ((cmd_in
== MTSETBLK
|| cmd_in
== SET_DENS_AND_BLK
) &&
2696 (arg
& MT_ST_BLKSIZE_MASK
) != 0 &&
2697 STp
->max_block
> 0 &&
2698 ((arg
& MT_ST_BLKSIZE_MASK
) < STp
->min_block
||
2699 (arg
& MT_ST_BLKSIZE_MASK
) > STp
->max_block
)) {
2700 printk(KERN_WARNING
"%s: Illegal block size.\n", name
);
2703 cmd
[0] = MODE_SELECT
;
2704 if ((STp
->use_pf
& USE_PF
))
2705 cmd
[1] = MODE_SELECT_PAGE_FORMAT
;
2706 cmd
[4] = datalen
= 12;
2707 direction
= DMA_TO_DEVICE
;
2709 memset((STp
->buffer
)->b_data
, 0, 12);
2710 if (cmd_in
== MTSETDRVBUFFER
)
2711 (STp
->buffer
)->b_data
[2] = (arg
& 7) << 4;
2713 (STp
->buffer
)->b_data
[2] =
2714 STp
->drv_buffer
<< 4;
2715 (STp
->buffer
)->b_data
[3] = 8; /* block descriptor length */
2716 if (cmd_in
== MTSETDENSITY
) {
2717 (STp
->buffer
)->b_data
[4] = arg
;
2718 STp
->density_changed
= 1; /* At least we tried ;-) */
2719 } else if (cmd_in
== SET_DENS_AND_BLK
)
2720 (STp
->buffer
)->b_data
[4] = arg
>> 24;
2722 (STp
->buffer
)->b_data
[4] = STp
->density
;
2723 if (cmd_in
== MTSETBLK
|| cmd_in
== SET_DENS_AND_BLK
) {
2724 ltmp
= arg
& MT_ST_BLKSIZE_MASK
;
2725 if (cmd_in
== MTSETBLK
)
2726 STp
->blksize_changed
= 1; /* At least we tried ;-) */
2728 ltmp
= STp
->block_size
;
2729 (STp
->buffer
)->b_data
[9] = (ltmp
>> 16);
2730 (STp
->buffer
)->b_data
[10] = (ltmp
>> 8);
2731 (STp
->buffer
)->b_data
[11] = ltmp
;
2732 timeout
= STp
->device
->timeout
;
2734 if (cmd_in
== MTSETBLK
|| cmd_in
== SET_DENS_AND_BLK
)
2736 "%s: Setting block size to %d bytes.\n", name
,
2737 (STp
->buffer
)->b_data
[9] * 65536 +
2738 (STp
->buffer
)->b_data
[10] * 256 +
2739 (STp
->buffer
)->b_data
[11]);
2740 if (cmd_in
== MTSETDENSITY
|| cmd_in
== SET_DENS_AND_BLK
)
2742 "%s: Setting density code to %x.\n", name
,
2743 (STp
->buffer
)->b_data
[4]);
2744 if (cmd_in
== MTSETDRVBUFFER
)
2746 "%s: Setting drive buffer code to %d.\n", name
,
2747 ((STp
->buffer
)->b_data
[2] >> 4) & 7);
2754 SRpnt
= st_do_scsi(NULL
, STp
, cmd
, datalen
, direction
,
2755 timeout
, MAX_RETRIES
, 1);
2757 return (STp
->buffer
)->syscall_result
;
2759 ioctl_result
= (STp
->buffer
)->syscall_result
;
2761 if (!ioctl_result
) { /* SCSI command successful */
2762 st_release_request(SRpnt
);
2764 STps
->drv_block
= blkno
;
2765 STps
->drv_file
= fileno
;
2766 STps
->at_sm
= at_sm
;
2768 if (cmd_in
== MTBSFM
)
2769 ioctl_result
= st_int_ioctl(STp
, MTFSF
, 1);
2770 else if (cmd_in
== MTFSFM
)
2771 ioctl_result
= st_int_ioctl(STp
, MTBSF
, 1);
2773 if (cmd_in
== MTSETBLK
|| cmd_in
== SET_DENS_AND_BLK
) {
2774 int old_block_size
= STp
->block_size
;
2775 STp
->block_size
= arg
& MT_ST_BLKSIZE_MASK
;
2776 if (STp
->block_size
!= 0) {
2777 if (old_block_size
== 0)
2778 normalize_buffer(STp
->buffer
);
2779 (STp
->buffer
)->buffer_blocks
=
2780 (STp
->buffer
)->buffer_size
/ STp
->block_size
;
2782 (STp
->buffer
)->buffer_bytes
= (STp
->buffer
)->read_pointer
= 0;
2783 if (cmd_in
== SET_DENS_AND_BLK
)
2784 STp
->density
= arg
>> MT_ST_DENSITY_SHIFT
;
2785 } else if (cmd_in
== MTSETDRVBUFFER
)
2786 STp
->drv_buffer
= (arg
& 7);
2787 else if (cmd_in
== MTSETDENSITY
)
2790 if (cmd_in
== MTEOM
)
2792 else if (cmd_in
== MTFSF
)
2795 STps
->eof
= ST_NOEOF
;
2797 if (cmd_in
== MTWEOF
)
2799 } else { /* SCSI command was not completely successful. Don't return
2800 from this block without releasing the SCSI command block! */
2801 struct st_cmdstatus
*cmdstatp
= &STp
->buffer
->cmdstat
;
2803 if (cmdstatp
->flags
& SENSE_EOM
) {
2804 if (cmd_in
!= MTBSF
&& cmd_in
!= MTBSFM
&&
2805 cmd_in
!= MTBSR
&& cmd_in
!= MTBSS
)
2806 STps
->eof
= ST_EOM_OK
;
2807 STps
->drv_block
= 0;
2810 if (cmdstatp
->remainder_valid
)
2811 undone
= (int)cmdstatp
->uremainder64
;
2815 if (cmd_in
== MTWEOF
&&
2816 cmdstatp
->have_sense
&&
2817 (cmdstatp
->flags
& SENSE_EOM
) &&
2818 (cmdstatp
->sense_hdr
.sense_key
== NO_SENSE
||
2819 cmdstatp
->sense_hdr
.sense_key
== RECOVERED_ERROR
) &&
2821 ioctl_result
= 0; /* EOF written succesfully at EOM */
2824 STps
->drv_file
= fileno
;
2825 STps
->eof
= ST_NOEOF
;
2826 } else if ((cmd_in
== MTFSF
) || (cmd_in
== MTFSFM
)) {
2828 STps
->drv_file
= fileno
- undone
;
2830 STps
->drv_file
= fileno
;
2831 STps
->drv_block
= -1;
2832 STps
->eof
= ST_NOEOF
;
2833 } else if ((cmd_in
== MTBSF
) || (cmd_in
== MTBSFM
)) {
2834 if (arg
> 0 && undone
< 0) /* Some drives get this wrong */
2836 if (STps
->drv_file
>= 0)
2837 STps
->drv_file
= fileno
+ undone
;
2838 STps
->drv_block
= 0;
2839 STps
->eof
= ST_NOEOF
;
2840 } else if (cmd_in
== MTFSR
) {
2841 if (cmdstatp
->flags
& SENSE_FMK
) { /* Hit filemark */
2842 if (STps
->drv_file
>= 0)
2844 STps
->drv_block
= 0;
2847 if (blkno
>= undone
)
2848 STps
->drv_block
= blkno
- undone
;
2850 STps
->drv_block
= (-1);
2851 STps
->eof
= ST_NOEOF
;
2853 } else if (cmd_in
== MTBSR
) {
2854 if (cmdstatp
->flags
& SENSE_FMK
) { /* Hit filemark */
2856 STps
->drv_block
= (-1);
2858 if (arg
> 0 && undone
< 0) /* Some drives get this wrong */
2860 if (STps
->drv_block
>= 0)
2861 STps
->drv_block
= blkno
+ undone
;
2863 STps
->eof
= ST_NOEOF
;
2864 } else if (cmd_in
== MTEOM
) {
2865 STps
->drv_file
= (-1);
2866 STps
->drv_block
= (-1);
2868 } else if (cmd_in
== MTSETBLK
||
2869 cmd_in
== MTSETDENSITY
||
2870 cmd_in
== MTSETDRVBUFFER
||
2871 cmd_in
== SET_DENS_AND_BLK
) {
2872 if (cmdstatp
->sense_hdr
.sense_key
== ILLEGAL_REQUEST
&&
2873 !(STp
->use_pf
& PF_TESTED
)) {
2874 /* Try the other possible state of Page Format if not
2876 STp
->use_pf
= !STp
->use_pf
| PF_TESTED
;
2877 st_release_request(SRpnt
);
2879 return st_int_ioctl(STp
, cmd_in
, arg
);
2882 STps
->eof
= ST_NOEOF
;
2884 if (cmdstatp
->sense_hdr
.sense_key
== BLANK_CHECK
)
2887 st_release_request(SRpnt
);
2891 return ioctl_result
;
2895 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2898 static int get_location(struct scsi_tape
*STp
, unsigned int *block
, int *partition
,
2902 unsigned char scmd
[MAX_COMMAND_SIZE
];
2903 struct st_request
*SRpnt
;
2904 DEB( char *name
= tape_name(STp
); )
2906 if (STp
->ready
!= ST_READY
)
2909 memset(scmd
, 0, MAX_COMMAND_SIZE
);
2910 if ((STp
->device
)->scsi_level
< SCSI_2
) {
2911 scmd
[0] = QFA_REQUEST_BLOCK
;
2914 scmd
[0] = READ_POSITION
;
2915 if (!logical
&& !STp
->scsi2_logical
)
2918 SRpnt
= st_do_scsi(NULL
, STp
, scmd
, 20, DMA_FROM_DEVICE
,
2919 STp
->device
->timeout
, MAX_READY_RETRIES
, 1);
2921 return (STp
->buffer
)->syscall_result
;
2923 if ((STp
->buffer
)->syscall_result
!= 0 ||
2924 (STp
->device
->scsi_level
>= SCSI_2
&&
2925 ((STp
->buffer
)->b_data
[0] & 4) != 0)) {
2926 *block
= *partition
= 0;
2927 DEBC(printk(ST_DEB_MSG
"%s: Can't read tape position.\n", name
));
2931 if ((STp
->device
)->scsi_level
< SCSI_2
) {
2932 *block
= ((STp
->buffer
)->b_data
[0] << 16)
2933 + ((STp
->buffer
)->b_data
[1] << 8)
2934 + (STp
->buffer
)->b_data
[2];
2937 *block
= ((STp
->buffer
)->b_data
[4] << 24)
2938 + ((STp
->buffer
)->b_data
[5] << 16)
2939 + ((STp
->buffer
)->b_data
[6] << 8)
2940 + (STp
->buffer
)->b_data
[7];
2941 *partition
= (STp
->buffer
)->b_data
[1];
2942 if (((STp
->buffer
)->b_data
[0] & 0x80) &&
2943 (STp
->buffer
)->b_data
[1] == 0) /* BOP of partition 0 */
2944 STp
->ps
[0].drv_block
= STp
->ps
[0].drv_file
= 0;
2946 DEBC(printk(ST_DEB_MSG
"%s: Got tape pos. blk %d part %d.\n", name
,
2947 *block
, *partition
));
2949 st_release_request(SRpnt
);
2956 /* Set the tape block and partition. Negative partition means that only the
2957 block should be set in vendor specific way. */
2958 static int set_location(struct scsi_tape
*STp
, unsigned int block
, int partition
,
2961 struct st_partstat
*STps
;
2965 unsigned char scmd
[MAX_COMMAND_SIZE
];
2966 struct st_request
*SRpnt
;
2967 DEB( char *name
= tape_name(STp
); )
2969 if (STp
->ready
!= ST_READY
)
2971 timeout
= STp
->long_timeout
;
2972 STps
= &(STp
->ps
[STp
->partition
]);
2974 DEBC(printk(ST_DEB_MSG
"%s: Setting block to %d and partition to %d.\n",
2975 name
, block
, partition
));
2976 DEB(if (partition
< 0)
2979 /* Update the location at the partition we are leaving */
2980 if ((!STp
->can_partitions
&& partition
!= 0) ||
2981 partition
>= ST_NBR_PARTITIONS
)
2983 if (partition
!= STp
->partition
) {
2984 if (get_location(STp
, &blk
, &p
, 1))
2985 STps
->last_block_valid
= 0;
2987 STps
->last_block_valid
= 1;
2988 STps
->last_block_visited
= blk
;
2989 DEBC(printk(ST_DEB_MSG
2990 "%s: Visited block %d for partition %d saved.\n",
2991 name
, blk
, STp
->partition
));
2995 memset(scmd
, 0, MAX_COMMAND_SIZE
);
2996 if ((STp
->device
)->scsi_level
< SCSI_2
) {
2997 scmd
[0] = QFA_SEEK_BLOCK
;
2998 scmd
[2] = (block
>> 16);
2999 scmd
[3] = (block
>> 8);
3004 scmd
[3] = (block
>> 24);
3005 scmd
[4] = (block
>> 16);
3006 scmd
[5] = (block
>> 8);
3008 if (!logical
&& !STp
->scsi2_logical
)
3010 if (STp
->partition
!= partition
) {
3012 scmd
[8] = partition
;
3013 DEBC(printk(ST_DEB_MSG
3014 "%s: Trying to change partition from %d to %d\n",
3015 name
, STp
->partition
, partition
));
3018 if (STp
->immediate
) {
3019 scmd
[1] |= 1; /* Don't wait for completion */
3020 timeout
= STp
->device
->timeout
;
3023 SRpnt
= st_do_scsi(NULL
, STp
, scmd
, 0, DMA_NONE
,
3024 timeout
, MAX_READY_RETRIES
, 1);
3026 return (STp
->buffer
)->syscall_result
;
3028 STps
->drv_block
= STps
->drv_file
= (-1);
3029 STps
->eof
= ST_NOEOF
;
3030 if ((STp
->buffer
)->syscall_result
!= 0) {
3032 if (STp
->can_partitions
&&
3033 (STp
->device
)->scsi_level
>= SCSI_2
&&
3034 (p
= find_partition(STp
)) >= 0)
3037 if (STp
->can_partitions
) {
3038 STp
->partition
= partition
;
3039 STps
= &(STp
->ps
[partition
]);
3040 if (!STps
->last_block_valid
||
3041 STps
->last_block_visited
!= block
) {
3048 STps
->drv_block
= STps
->drv_file
= 0;
3052 st_release_request(SRpnt
);
3059 /* Find the current partition number for the drive status. Called from open and
3060 returns either partition number of negative error code. */
3061 static int find_partition(struct scsi_tape
*STp
)
3066 if ((i
= get_location(STp
, &block
, &partition
, 1)) < 0)
3068 if (partition
>= ST_NBR_PARTITIONS
)
3074 /* Change the partition if necessary */
3075 static int switch_partition(struct scsi_tape
*STp
)
3077 struct st_partstat
*STps
;
3079 if (STp
->partition
== STp
->new_partition
)
3081 STps
= &(STp
->ps
[STp
->new_partition
]);
3082 if (!STps
->last_block_valid
)
3083 STps
->last_block_visited
= 0;
3084 return set_location(STp
, STps
->last_block_visited
, STp
->new_partition
, 1);
3087 /* Functions for reading and writing the medium partition mode page. */
3089 #define PART_PAGE 0x11
3090 #define PART_PAGE_FIXED_LENGTH 8
3092 #define PP_OFF_MAX_ADD_PARTS 2
3093 #define PP_OFF_NBR_ADD_PARTS 3
3094 #define PP_OFF_FLAGS 4
3095 #define PP_OFF_PART_UNITS 6
3096 #define PP_OFF_RESERVED 7
3098 #define PP_BIT_IDP 0x20
3099 #define PP_MSK_PSUM_MB 0x10
3101 /* Get the number of partitions on the tape. As a side effect reads the
3102 mode page into the tape buffer. */
3103 static int nbr_partitions(struct scsi_tape
*STp
)
3106 DEB( char *name
= tape_name(STp
); )
3108 if (STp
->ready
!= ST_READY
)
3111 result
= read_mode_page(STp
, PART_PAGE
, 1);
3114 DEBC(printk(ST_DEB_MSG
"%s: Can't read medium partition page.\n",
3118 result
= (STp
->buffer
)->b_data
[MODE_HEADER_LENGTH
+
3119 PP_OFF_NBR_ADD_PARTS
] + 1;
3120 DEBC(printk(ST_DEB_MSG
"%s: Number of partitions %d.\n", name
, result
));
3127 /* Partition the tape into two partitions if size > 0 or one partition if
3130 The block descriptors are read and written because Sony SDT-7000 does not
3131 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3133 My HP C1533A drive returns only one partition size field. This is used to
3134 set the size of partition 1. There is no size field for the default partition.
3135 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3136 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3137 The following algorithm is used to accommodate both drives: if the number of
3138 partition size fields is greater than the maximum number of additional partitions
3139 in the mode page, the second field is used. Otherwise the first field is used.
3141 For Seagate DDS drives the page length must be 8 when no partitions is defined
3142 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3143 is acceptable also to some other old drives and enforced if the first partition
3144 size field is used for the first additional partition size.
3146 static int partition_tape(struct scsi_tape
*STp
, int size
)
3148 char *name
= tape_name(STp
);
3150 int pgo
, psd_cnt
, psdo
;
3153 result
= read_mode_page(STp
, PART_PAGE
, 0);
3155 DEBC(printk(ST_DEB_MSG
"%s: Can't read partition mode page.\n", name
));
3158 /* The mode page is in the buffer. Let's modify it and write it. */
3159 bp
= (STp
->buffer
)->b_data
;
3160 pgo
= MODE_HEADER_LENGTH
+ bp
[MH_OFF_BDESCS_LENGTH
];
3161 DEBC(printk(ST_DEB_MSG
"%s: Partition page length is %d bytes.\n",
3162 name
, bp
[pgo
+ MP_OFF_PAGE_LENGTH
] + 2));
3164 psd_cnt
= (bp
[pgo
+ MP_OFF_PAGE_LENGTH
] + 2 - PART_PAGE_FIXED_LENGTH
) / 2;
3165 psdo
= pgo
+ PART_PAGE_FIXED_LENGTH
;
3166 if (psd_cnt
> bp
[pgo
+ PP_OFF_MAX_ADD_PARTS
]) {
3167 bp
[psdo
] = bp
[psdo
+ 1] = 0xff; /* Rest of the tape */
3170 memset(bp
+ psdo
, 0, bp
[pgo
+ PP_OFF_NBR_ADD_PARTS
] * 2);
3172 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name
,
3173 psd_cnt
, bp
[pgo
+ PP_OFF_MAX_ADD_PARTS
],
3174 bp
[pgo
+ PP_OFF_NBR_ADD_PARTS
]));
3177 bp
[pgo
+ PP_OFF_NBR_ADD_PARTS
] = 0;
3178 if (psd_cnt
<= bp
[pgo
+ PP_OFF_MAX_ADD_PARTS
])
3179 bp
[pgo
+ MP_OFF_PAGE_LENGTH
] = 6;
3180 DEBC(printk(ST_DEB_MSG
"%s: Formatting tape with one partition.\n",
3183 bp
[psdo
] = (size
>> 8) & 0xff;
3184 bp
[psdo
+ 1] = size
& 0xff;
3186 if (bp
[pgo
+ MP_OFF_PAGE_LENGTH
] < 8)
3187 bp
[pgo
+ MP_OFF_PAGE_LENGTH
] = 8;
3188 DEBC(printk(ST_DEB_MSG
3189 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3192 bp
[pgo
+ PP_OFF_PART_UNITS
] = 0;
3193 bp
[pgo
+ PP_OFF_RESERVED
] = 0;
3194 bp
[pgo
+ PP_OFF_FLAGS
] = PP_BIT_IDP
| PP_MSK_PSUM_MB
;
3196 result
= write_mode_page(STp
, PART_PAGE
, 1);
3198 printk(KERN_INFO
"%s: Partitioning of tape failed.\n", name
);
3207 /* The ioctl command */
3208 static int st_ioctl(struct inode
*inode
, struct file
*file
,
3209 unsigned int cmd_in
, unsigned long arg
)
3211 int i
, cmd_nr
, cmd_type
, bt
;
3214 struct scsi_tape
*STp
= file
->private_data
;
3215 struct st_modedef
*STm
;
3216 struct st_partstat
*STps
;
3217 char *name
= tape_name(STp
);
3218 void __user
*p
= (void __user
*)arg
;
3220 if (down_interruptible(&STp
->lock
))
3221 return -ERESTARTSYS
;
3224 if (debugging
&& !STp
->in_use
) {
3225 printk(ST_DEB_MSG
"%s: Incorrect device.\n", name
);
3230 STm
= &(STp
->modes
[STp
->current_mode
]);
3231 STps
= &(STp
->ps
[STp
->partition
]);
3234 * If we are in the middle of error recovery, don't let anyone
3235 * else try and use this device. Also, if error recovery fails, it
3236 * may try and take the device offline, in which case all further
3237 * access to the device is prohibited.
3239 retval
= scsi_nonblockable_ioctl(STp
->device
, cmd_in
, p
, file
);
3240 if (!scsi_block_when_processing_errors(STp
->device
) || retval
!= -ENODEV
)
3244 cmd_type
= _IOC_TYPE(cmd_in
);
3245 cmd_nr
= _IOC_NR(cmd_in
);
3247 if (cmd_type
== _IOC_TYPE(MTIOCTOP
) && cmd_nr
== _IOC_NR(MTIOCTOP
)) {
3250 if (_IOC_SIZE(cmd_in
) != sizeof(mtc
)) {
3255 i
= copy_from_user(&mtc
, p
, sizeof(struct mtop
));
3261 if (mtc
.mt_op
== MTSETDRVBUFFER
&& !capable(CAP_SYS_ADMIN
)) {
3263 "%s: MTSETDRVBUFFER only allowed for root.\n", name
);
3267 if (!STm
->defined
&&
3268 (mtc
.mt_op
!= MTSETDRVBUFFER
&&
3269 (mtc
.mt_count
& MT_ST_OPTIONS
) == 0)) {
3274 if (!STp
->pos_unknown
) {
3276 if (STps
->eof
== ST_FM_HIT
) {
3277 if (mtc
.mt_op
== MTFSF
|| mtc
.mt_op
== MTFSFM
||
3278 mtc
.mt_op
== MTEOM
) {
3280 if (STps
->drv_file
>= 0)
3281 STps
->drv_file
+= 1;
3282 } else if (mtc
.mt_op
== MTBSF
|| mtc
.mt_op
== MTBSFM
) {
3284 if (STps
->drv_file
>= 0)
3285 STps
->drv_file
+= 1;
3289 if (mtc
.mt_op
== MTSEEK
) {
3290 /* Old position must be restored if partition will be
3292 i
= !STp
->can_partitions
||
3293 (STp
->new_partition
!= STp
->partition
);
3295 i
= mtc
.mt_op
== MTREW
|| mtc
.mt_op
== MTOFFL
||
3296 mtc
.mt_op
== MTRETEN
|| mtc
.mt_op
== MTEOM
||
3297 mtc
.mt_op
== MTLOCK
|| mtc
.mt_op
== MTLOAD
||
3298 mtc
.mt_op
== MTFSF
|| mtc
.mt_op
== MTFSFM
||
3299 mtc
.mt_op
== MTBSF
|| mtc
.mt_op
== MTBSFM
||
3300 mtc
.mt_op
== MTCOMPRESSION
;
3302 i
= flush_buffer(STp
, i
);
3307 if (STps
->rw
== ST_WRITING
&&
3308 (mtc
.mt_op
== MTREW
|| mtc
.mt_op
== MTOFFL
||
3309 mtc
.mt_op
== MTSEEK
||
3310 mtc
.mt_op
== MTBSF
|| mtc
.mt_op
== MTBSFM
)) {
3311 i
= st_int_ioctl(STp
, MTWEOF
, 1);
3316 if (mtc
.mt_op
== MTBSF
|| mtc
.mt_op
== MTBSFM
)
3323 * If there was a bus reset, block further access
3324 * to this device. If the user wants to rewind the tape,
3325 * then reset the flag and allow access again.
3327 if (mtc
.mt_op
!= MTREW
&&
3328 mtc
.mt_op
!= MTOFFL
&&
3329 mtc
.mt_op
!= MTRETEN
&&
3330 mtc
.mt_op
!= MTERASE
&&
3331 mtc
.mt_op
!= MTSEEK
&&
3332 mtc
.mt_op
!= MTEOM
) {
3337 /* remove this when the midlevel properly clears was_reset */
3338 STp
->device
->was_reset
= 0;
3341 if (mtc
.mt_op
!= MTNOP
&& mtc
.mt_op
!= MTSETBLK
&&
3342 mtc
.mt_op
!= MTSETDENSITY
&& mtc
.mt_op
!= MTWSM
&&
3343 mtc
.mt_op
!= MTSETDRVBUFFER
&& mtc
.mt_op
!= MTSETPART
)
3344 STps
->rw
= ST_IDLE
; /* Prevent automatic WEOF and fsf */
3346 if (mtc
.mt_op
== MTOFFL
&& STp
->door_locked
!= ST_UNLOCKED
)
3347 do_door_lock(STp
, 0); /* Ignore result! */
3349 if (mtc
.mt_op
== MTSETDRVBUFFER
&&
3350 (mtc
.mt_count
& MT_ST_OPTIONS
) != 0) {
3351 retval
= st_set_options(STp
, mtc
.mt_count
);
3355 if (mtc
.mt_op
== MTSETPART
) {
3356 if (!STp
->can_partitions
||
3357 mtc
.mt_count
< 0 || mtc
.mt_count
>= ST_NBR_PARTITIONS
) {
3361 if (mtc
.mt_count
>= STp
->nbr_partitions
&&
3362 (STp
->nbr_partitions
= nbr_partitions(STp
)) < 0) {
3366 if (mtc
.mt_count
>= STp
->nbr_partitions
) {
3370 STp
->new_partition
= mtc
.mt_count
;
3375 if (mtc
.mt_op
== MTMKPART
) {
3376 if (!STp
->can_partitions
) {
3380 if ((i
= st_int_ioctl(STp
, MTREW
, 0)) < 0 ||
3381 (i
= partition_tape(STp
, mtc
.mt_count
)) < 0) {
3385 for (i
= 0; i
< ST_NBR_PARTITIONS
; i
++) {
3386 STp
->ps
[i
].rw
= ST_IDLE
;
3387 STp
->ps
[i
].at_sm
= 0;
3388 STp
->ps
[i
].last_block_valid
= 0;
3390 STp
->partition
= STp
->new_partition
= 0;
3391 STp
->nbr_partitions
= 1; /* Bad guess ?-) */
3392 STps
->drv_block
= STps
->drv_file
= 0;
3397 if (mtc
.mt_op
== MTSEEK
) {
3398 i
= set_location(STp
, mtc
.mt_count
, STp
->new_partition
, 0);
3399 if (!STp
->can_partitions
)
3400 STp
->ps
[0].rw
= ST_IDLE
;
3405 if (mtc
.mt_op
== MTUNLOAD
|| mtc
.mt_op
== MTOFFL
) {
3406 retval
= do_load_unload(STp
, file
, 0);
3410 if (mtc
.mt_op
== MTLOAD
) {
3411 retval
= do_load_unload(STp
, file
, max(1, mtc
.mt_count
));
3415 if (mtc
.mt_op
== MTLOCK
|| mtc
.mt_op
== MTUNLOCK
) {
3416 retval
= do_door_lock(STp
, (mtc
.mt_op
== MTLOCK
));
3420 if (STp
->can_partitions
&& STp
->ready
== ST_READY
&&
3421 (i
= switch_partition(STp
)) < 0) {
3426 if (mtc
.mt_op
== MTCOMPRESSION
)
3427 retval
= st_compression(STp
, (mtc
.mt_count
& 1));
3429 retval
= st_int_ioctl(STp
, mtc
.mt_op
, mtc
.mt_count
);
3432 if (!STm
->defined
) {
3437 if ((i
= flush_buffer(STp
, 0)) < 0) {
3441 if (STp
->can_partitions
&&
3442 (i
= switch_partition(STp
)) < 0) {
3447 if (cmd_type
== _IOC_TYPE(MTIOCGET
) && cmd_nr
== _IOC_NR(MTIOCGET
)) {
3448 struct mtget mt_status
;
3450 if (_IOC_SIZE(cmd_in
) != sizeof(struct mtget
)) {
3455 mt_status
.mt_type
= STp
->tape_type
;
3456 mt_status
.mt_dsreg
=
3457 ((STp
->block_size
<< MT_ST_BLKSIZE_SHIFT
) & MT_ST_BLKSIZE_MASK
) |
3458 ((STp
->density
<< MT_ST_DENSITY_SHIFT
) & MT_ST_DENSITY_MASK
);
3459 mt_status
.mt_blkno
= STps
->drv_block
;
3460 mt_status
.mt_fileno
= STps
->drv_file
;
3461 if (STp
->block_size
!= 0) {
3462 if (STps
->rw
== ST_WRITING
)
3463 mt_status
.mt_blkno
+=
3464 (STp
->buffer
)->buffer_bytes
/ STp
->block_size
;
3465 else if (STps
->rw
== ST_READING
)
3466 mt_status
.mt_blkno
-=
3467 ((STp
->buffer
)->buffer_bytes
+
3468 STp
->block_size
- 1) / STp
->block_size
;
3471 mt_status
.mt_gstat
= 0;
3472 if (STp
->drv_write_prot
)
3473 mt_status
.mt_gstat
|= GMT_WR_PROT(0xffffffff);
3474 if (mt_status
.mt_blkno
== 0) {
3475 if (mt_status
.mt_fileno
== 0)
3476 mt_status
.mt_gstat
|= GMT_BOT(0xffffffff);
3478 mt_status
.mt_gstat
|= GMT_EOF(0xffffffff);
3480 mt_status
.mt_erreg
= (STp
->recover_reg
<< MT_ST_SOFTERR_SHIFT
);
3481 mt_status
.mt_resid
= STp
->partition
;
3482 if (STps
->eof
== ST_EOM_OK
|| STps
->eof
== ST_EOM_ERROR
)
3483 mt_status
.mt_gstat
|= GMT_EOT(0xffffffff);
3484 else if (STps
->eof
>= ST_EOM_OK
)
3485 mt_status
.mt_gstat
|= GMT_EOD(0xffffffff);
3486 if (STp
->density
== 1)
3487 mt_status
.mt_gstat
|= GMT_D_800(0xffffffff);
3488 else if (STp
->density
== 2)
3489 mt_status
.mt_gstat
|= GMT_D_1600(0xffffffff);
3490 else if (STp
->density
== 3)
3491 mt_status
.mt_gstat
|= GMT_D_6250(0xffffffff);
3492 if (STp
->ready
== ST_READY
)
3493 mt_status
.mt_gstat
|= GMT_ONLINE(0xffffffff);
3494 if (STp
->ready
== ST_NO_TAPE
)
3495 mt_status
.mt_gstat
|= GMT_DR_OPEN(0xffffffff);
3497 mt_status
.mt_gstat
|= GMT_SM(0xffffffff);
3498 if (STm
->do_async_writes
||
3499 (STm
->do_buffer_writes
&& STp
->block_size
!= 0) ||
3500 STp
->drv_buffer
!= 0)
3501 mt_status
.mt_gstat
|= GMT_IM_REP_EN(0xffffffff);
3502 if (STp
->cleaning_req
)
3503 mt_status
.mt_gstat
|= GMT_CLN(0xffffffff);
3505 i
= copy_to_user(p
, &mt_status
, sizeof(struct mtget
));
3511 STp
->recover_reg
= 0; /* Clear after read */
3514 } /* End of MTIOCGET */
3515 if (cmd_type
== _IOC_TYPE(MTIOCPOS
) && cmd_nr
== _IOC_NR(MTIOCPOS
)) {
3516 struct mtpos mt_pos
;
3517 if (_IOC_SIZE(cmd_in
) != sizeof(struct mtpos
)) {
3521 if ((i
= get_location(STp
, &blk
, &bt
, 0)) < 0) {
3525 mt_pos
.mt_blkno
= blk
;
3526 i
= copy_to_user(p
, &mt_pos
, sizeof(struct mtpos
));
3533 case SCSI_IOCTL_GET_IDLUN
:
3534 case SCSI_IOCTL_GET_BUS_NUMBER
:
3537 if ((cmd_in
== SG_IO
||
3538 cmd_in
== SCSI_IOCTL_SEND_COMMAND
||
3539 cmd_in
== CDROM_SEND_PACKET
) &&
3540 !capable(CAP_SYS_RAWIO
))
3543 i
= scsi_cmd_ioctl(file
, STp
->disk
, cmd_in
, p
);
3548 retval
= scsi_ioctl(STp
->device
, cmd_in
, p
);
3549 if (!retval
&& cmd_in
== SCSI_IOCTL_STOP_UNIT
) { /* unload */
3550 STp
->rew_at_close
= 0;
3551 STp
->ready
= ST_NO_TAPE
;
3560 #ifdef CONFIG_COMPAT
3561 static long st_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
3563 struct scsi_tape
*STp
= file
->private_data
;
3564 struct scsi_device
*sdev
= STp
->device
;
3565 int ret
= -ENOIOCTLCMD
;
3566 if (sdev
->host
->hostt
->compat_ioctl
) {
3568 ret
= sdev
->host
->hostt
->compat_ioctl(sdev
, cmd
, (void __user
*)arg
);
3577 /* Try to allocate a new tape buffer. Calling function must not hold
3579 static struct st_buffer
*
3580 new_tape_buffer(int from_initialization
, int need_dma
, int max_sg
)
3584 struct st_buffer
*tb
;
3586 if (from_initialization
)
3587 priority
= GFP_ATOMIC
;
3589 priority
= GFP_KERNEL
;
3591 i
= sizeof(struct st_buffer
) + (max_sg
- 1) * sizeof(struct scatterlist
) +
3592 max_sg
* sizeof(struct st_buf_fragment
);
3593 tb
= kmalloc(i
, priority
);
3595 printk(KERN_NOTICE
"st: Can't allocate new tape buffer.\n");
3599 tb
->frp_segs
= tb
->orig_frp_segs
= 0;
3600 tb
->use_sg
= max_sg
;
3601 tb
->frp
= (struct st_buf_fragment
*)(&(tb
->sg
[0]) + max_sg
);
3605 tb
->buffer_size
= got
;
3611 /* Try to allocate enough space in the tape buffer */
3612 static int enlarge_buffer(struct st_buffer
* STbuffer
, int new_size
, int need_dma
)
3614 int segs
, nbr
, max_segs
, b_size
, order
, got
;
3617 if (new_size
<= STbuffer
->buffer_size
)
3620 if (STbuffer
->buffer_size
<= PAGE_SIZE
)
3621 normalize_buffer(STbuffer
); /* Avoid extra segment */
3623 max_segs
= STbuffer
->use_sg
;
3624 nbr
= max_segs
- STbuffer
->frp_segs
;
3628 priority
= GFP_KERNEL
| __GFP_NOWARN
;
3630 priority
|= GFP_DMA
;
3631 for (b_size
= PAGE_SIZE
, order
=0; order
<= 6 &&
3632 b_size
< new_size
- STbuffer
->buffer_size
;
3633 order
++, b_size
*= 2)
3636 for (segs
= STbuffer
->frp_segs
, got
= STbuffer
->buffer_size
;
3637 segs
< max_segs
&& got
< new_size
;) {
3638 STbuffer
->frp
[segs
].page
= alloc_pages(priority
, order
);
3639 if (STbuffer
->frp
[segs
].page
== NULL
) {
3640 if (new_size
- got
<= (max_segs
- segs
) * b_size
/ 2) {
3641 b_size
/= 2; /* Large enough for the rest of the buffers */
3645 DEB(STbuffer
->buffer_size
= got
);
3646 normalize_buffer(STbuffer
);
3649 STbuffer
->frp
[segs
].length
= b_size
;
3650 STbuffer
->frp_segs
+= 1;
3652 STbuffer
->buffer_size
= got
;
3655 STbuffer
->b_data
= page_address(STbuffer
->frp
[0].page
);
3661 /* Release the extra buffer */
3662 static void normalize_buffer(struct st_buffer
* STbuffer
)
3666 for (i
= STbuffer
->orig_frp_segs
; i
< STbuffer
->frp_segs
; i
++) {
3667 order
= get_order(STbuffer
->frp
[i
].length
);
3668 __free_pages(STbuffer
->frp
[i
].page
, order
);
3669 STbuffer
->buffer_size
-= STbuffer
->frp
[i
].length
;
3671 STbuffer
->frp_segs
= STbuffer
->orig_frp_segs
;
3672 STbuffer
->frp_sg_current
= 0;
3673 STbuffer
->sg_segs
= 0;
3677 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3678 negative error code. */
3679 static int append_to_buffer(const char __user
*ubp
, struct st_buffer
* st_bp
, int do_count
)
3681 int i
, cnt
, res
, offset
;
3683 for (i
= 0, offset
= st_bp
->buffer_bytes
;
3684 i
< st_bp
->frp_segs
&& offset
>= st_bp
->frp
[i
].length
; i
++)
3685 offset
-= st_bp
->frp
[i
].length
;
3686 if (i
== st_bp
->frp_segs
) { /* Should never happen */
3687 printk(KERN_WARNING
"st: append_to_buffer offset overflow.\n");
3690 for (; i
< st_bp
->frp_segs
&& do_count
> 0; i
++) {
3691 cnt
= st_bp
->frp
[i
].length
- offset
< do_count
?
3692 st_bp
->frp
[i
].length
- offset
: do_count
;
3693 res
= copy_from_user(page_address(st_bp
->frp
[i
].page
) + offset
, ubp
, cnt
);
3697 st_bp
->buffer_bytes
+= cnt
;
3701 if (do_count
) /* Should never happen */
3708 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3709 negative error code. */
3710 static int from_buffer(struct st_buffer
* st_bp
, char __user
*ubp
, int do_count
)
3712 int i
, cnt
, res
, offset
;
3714 for (i
= 0, offset
= st_bp
->read_pointer
;
3715 i
< st_bp
->frp_segs
&& offset
>= st_bp
->frp
[i
].length
; i
++)
3716 offset
-= st_bp
->frp
[i
].length
;
3717 if (i
== st_bp
->frp_segs
) { /* Should never happen */
3718 printk(KERN_WARNING
"st: from_buffer offset overflow.\n");
3721 for (; i
< st_bp
->frp_segs
&& do_count
> 0; i
++) {
3722 cnt
= st_bp
->frp
[i
].length
- offset
< do_count
?
3723 st_bp
->frp
[i
].length
- offset
: do_count
;
3724 res
= copy_to_user(ubp
, page_address(st_bp
->frp
[i
].page
) + offset
, cnt
);
3728 st_bp
->buffer_bytes
-= cnt
;
3729 st_bp
->read_pointer
+= cnt
;
3733 if (do_count
) /* Should never happen */
3740 /* Move data towards start of buffer */
3741 static void move_buffer_data(struct st_buffer
* st_bp
, int offset
)
3743 int src_seg
, dst_seg
, src_offset
= 0, dst_offset
;
3749 total
=st_bp
->buffer_bytes
- offset
;
3750 for (src_seg
=0; src_seg
< st_bp
->frp_segs
; src_seg
++) {
3751 src_offset
= offset
;
3752 if (src_offset
< st_bp
->frp
[src_seg
].length
)
3754 offset
-= st_bp
->frp
[src_seg
].length
;
3757 st_bp
->buffer_bytes
= st_bp
->read_pointer
= total
;
3758 for (dst_seg
=dst_offset
=0; total
> 0; ) {
3759 count
= min(st_bp
->frp
[dst_seg
].length
- dst_offset
,
3760 st_bp
->frp
[src_seg
].length
- src_offset
);
3761 memmove(page_address(st_bp
->frp
[dst_seg
].page
) + dst_offset
,
3762 page_address(st_bp
->frp
[src_seg
].page
) + src_offset
, count
);
3763 src_offset
+= count
;
3764 if (src_offset
>= st_bp
->frp
[src_seg
].length
) {
3768 dst_offset
+= count
;
3769 if (dst_offset
>= st_bp
->frp
[dst_seg
].length
) {
3778 /* Fill the s/g list up to the length required for this transfer */
3779 static void buf_to_sg(struct st_buffer
*STbp
, unsigned int length
)
3783 struct scatterlist
*sg
;
3784 struct st_buf_fragment
*frp
;
3786 if (length
== STbp
->frp_sg_current
)
3787 return; /* work already done */
3789 sg
= &(STbp
->sg
[0]);
3791 for (i
=count
=0; count
< length
; i
++) {
3792 sg
[i
].page
= frp
[i
].page
;
3793 if (length
- count
> frp
[i
].length
)
3794 sg
[i
].length
= frp
[i
].length
;
3796 sg
[i
].length
= length
- count
;
3797 count
+= sg
[i
].length
;
3801 STbp
->frp_sg_current
= length
;
3805 /* Validate the options from command line or module parameters */
3806 static void validate_options(void)
3809 st_fixed_buffer_size
= buffer_kbs
* ST_KILOBYTE
;
3810 if (max_sg_segs
>= ST_FIRST_SG
)
3811 st_max_sg_segs
= max_sg_segs
;
3815 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3817 static int __init
st_setup(char *str
)
3819 int i
, len
, ints
[5];
3822 stp
= get_options(str
, ARRAY_SIZE(ints
), ints
);
3825 for (i
= 0; i
< ints
[0] && i
< ARRAY_SIZE(parms
); i
++)
3827 *parms
[i
].val
= ints
[i
+ 1];
3829 while (stp
!= NULL
) {
3830 for (i
= 0; i
< ARRAY_SIZE(parms
); i
++) {
3831 len
= strlen(parms
[i
].name
);
3832 if (!strncmp(stp
, parms
[i
].name
, len
) &&
3833 (*(stp
+ len
) == ':' || *(stp
+ len
) == '=')) {
3836 simple_strtoul(stp
+ len
+ 1, NULL
, 0);
3838 printk(KERN_WARNING
"st: Obsolete parameter %s\n",
3843 if (i
>= sizeof(parms
) / sizeof(struct st_dev_parm
))
3844 printk(KERN_WARNING
"st: invalid parameter in '%s'\n",
3846 stp
= strchr(stp
, ',');
3857 __setup("st=", st_setup
);
3861 static struct file_operations st_fops
=
3863 .owner
= THIS_MODULE
,
3867 #ifdef CONFIG_COMPAT
3868 .compat_ioctl
= st_compat_ioctl
,
3872 .release
= st_release
,
3875 static int st_probe(struct device
*dev
)
3877 struct scsi_device
*SDp
= to_scsi_device(dev
);
3878 struct gendisk
*disk
= NULL
;
3879 struct cdev
*cdev
= NULL
;
3880 struct scsi_tape
*tpnt
= NULL
;
3881 struct st_modedef
*STm
;
3882 struct st_partstat
*STps
;
3883 struct st_buffer
*buffer
;
3884 int i
, j
, mode
, dev_num
, error
;
3887 if (SDp
->type
!= TYPE_TAPE
)
3889 if ((stp
= st_incompatible(SDp
))) {
3890 sdev_printk(KERN_INFO
, SDp
, "Found incompatible tape\n");
3891 printk(KERN_INFO
"st: The suggested driver is %s.\n", stp
);
3895 i
= min(SDp
->request_queue
->max_hw_segments
,
3896 SDp
->request_queue
->max_phys_segments
);
3897 if (st_max_sg_segs
< i
)
3899 buffer
= new_tape_buffer(1, (SDp
->host
)->unchecked_isa_dma
, i
);
3900 if (buffer
== NULL
) {
3902 "st: Can't allocate new tape buffer. Device not attached.\n");
3906 disk
= alloc_disk(1);
3908 printk(KERN_ERR
"st: out of memory. Device not attached.\n");
3909 goto out_buffer_free
;
3912 write_lock(&st_dev_arr_lock
);
3913 if (st_nr_dev
>= st_dev_max
) {
3914 struct scsi_tape
**tmp_da
;
3917 tmp_dev_max
= max(st_nr_dev
* 2, 8);
3918 if (tmp_dev_max
> ST_MAX_TAPES
)
3919 tmp_dev_max
= ST_MAX_TAPES
;
3920 if (tmp_dev_max
<= st_nr_dev
) {
3921 write_unlock(&st_dev_arr_lock
);
3922 printk(KERN_ERR
"st: Too many tape devices (max. %d).\n",
3927 tmp_da
= kmalloc(tmp_dev_max
* sizeof(struct scsi_tape
*), GFP_ATOMIC
);
3928 if (tmp_da
== NULL
) {
3929 write_unlock(&st_dev_arr_lock
);
3930 printk(KERN_ERR
"st: Can't extend device array.\n");
3934 memset(tmp_da
, 0, tmp_dev_max
* sizeof(struct scsi_tape
*));
3935 if (scsi_tapes
!= NULL
) {
3936 memcpy(tmp_da
, scsi_tapes
,
3937 st_dev_max
* sizeof(struct scsi_tape
*));
3940 scsi_tapes
= tmp_da
;
3942 st_dev_max
= tmp_dev_max
;
3945 for (i
= 0; i
< st_dev_max
; i
++)
3946 if (scsi_tapes
[i
] == NULL
)
3948 if (i
>= st_dev_max
)
3949 panic("scsi_devices corrupt (st)");
3951 tpnt
= kmalloc(sizeof(struct scsi_tape
), GFP_ATOMIC
);
3953 write_unlock(&st_dev_arr_lock
);
3954 printk(KERN_ERR
"st: Can't allocate device descriptor.\n");
3957 memset(tpnt
, 0, sizeof(struct scsi_tape
));
3958 kref_init(&tpnt
->kref
);
3960 sprintf(disk
->disk_name
, "st%d", i
);
3961 disk
->private_data
= &tpnt
->driver
;
3962 disk
->queue
= SDp
->request_queue
;
3963 tpnt
->driver
= &st_template
;
3964 scsi_tapes
[i
] = tpnt
;
3968 if (SDp
->scsi_level
<= 2)
3969 tpnt
->tape_type
= MT_ISSCSI1
;
3971 tpnt
->tape_type
= MT_ISSCSI2
;
3973 tpnt
->buffer
= buffer
;
3974 tpnt
->buffer
->last_SRpnt
= NULL
;
3979 tpnt
->drv_buffer
= 1; /* Try buffering if no mode sense */
3980 tpnt
->restr_dma
= (SDp
->host
)->unchecked_isa_dma
;
3981 tpnt
->use_pf
= (SDp
->scsi_level
>= SCSI_2
);
3983 tpnt
->do_auto_lock
= ST_AUTO_LOCK
;
3984 tpnt
->can_bsr
= (SDp
->scsi_level
> 2 ? 1 : ST_IN_FILE_POS
); /* BSR mandatory in SCSI3 */
3985 tpnt
->can_partitions
= 0;
3986 tpnt
->two_fm
= ST_TWO_FM
;
3987 tpnt
->fast_mteom
= ST_FAST_MTEOM
;
3988 tpnt
->scsi2_logical
= ST_SCSI2LOGICAL
;
3989 tpnt
->immediate
= ST_NOWAIT
;
3990 tpnt
->default_drvbuffer
= 0xff; /* No forced buffering */
3991 tpnt
->partition
= 0;
3992 tpnt
->new_partition
= 0;
3993 tpnt
->nbr_partitions
= 0;
3994 tpnt
->device
->timeout
= ST_TIMEOUT
;
3995 tpnt
->long_timeout
= ST_LONG_TIMEOUT
;
3996 tpnt
->try_dio
= try_direct_io
&& !SDp
->host
->unchecked_isa_dma
;
3998 for (i
= 0; i
< ST_NBR_MODES
; i
++) {
3999 STm
= &(tpnt
->modes
[i
]);
4001 STm
->sysv
= ST_SYSV
;
4002 STm
->defaults_for_writes
= 0;
4003 STm
->do_async_writes
= ST_ASYNC_WRITES
;
4004 STm
->do_buffer_writes
= ST_BUFFER_WRITES
;
4005 STm
->do_read_ahead
= ST_READ_AHEAD
;
4006 STm
->default_compression
= ST_DONT_TOUCH
;
4007 STm
->default_blksize
= (-1); /* No forced size */
4008 STm
->default_density
= (-1); /* No forced density */
4011 for (i
= 0; i
< ST_NBR_PARTITIONS
; i
++) {
4012 STps
= &(tpnt
->ps
[i
]);
4014 STps
->eof
= ST_NOEOF
;
4016 STps
->last_block_valid
= 0;
4017 STps
->drv_block
= (-1);
4018 STps
->drv_file
= (-1);
4021 tpnt
->current_mode
= 0;
4022 tpnt
->modes
[0].defined
= 1;
4024 tpnt
->density_changed
= tpnt
->compression_changed
=
4025 tpnt
->blksize_changed
= 0;
4026 init_MUTEX(&tpnt
->lock
);
4029 write_unlock(&st_dev_arr_lock
);
4031 for (mode
= 0; mode
< ST_NBR_MODES
; ++mode
) {
4032 STm
= &(tpnt
->modes
[mode
]);
4033 for (j
=0; j
< 2; j
++) {
4034 cdev
= cdev_alloc();
4037 "st%d: out of memory. Device not attached.\n",
4041 cdev
->owner
= THIS_MODULE
;
4042 cdev
->ops
= &st_fops
;
4044 error
= cdev_add(cdev
,
4045 MKDEV(SCSI_TAPE_MAJOR
, TAPE_MINOR(dev_num
, mode
, j
)),
4048 printk(KERN_ERR
"st%d: Can't add %s-rewind mode %d\n",
4049 dev_num
, j
? "non" : "auto", mode
);
4050 printk(KERN_ERR
"st%d: Device not attached.\n", dev_num
);
4053 STm
->cdevs
[j
] = cdev
;
4056 do_create_class_files(tpnt
, dev_num
, mode
);
4059 for (mode
= 0; mode
< ST_NBR_MODES
; ++mode
) {
4060 /* Make sure that the minor numbers corresponding to the four
4061 first modes always get the same names */
4062 i
= mode
<< (4 - ST_NBR_MODE_BITS
);
4064 devfs_mk_cdev(MKDEV(SCSI_TAPE_MAJOR
, TAPE_MINOR(dev_num
, mode
, 0)),
4065 S_IFCHR
| S_IRUGO
| S_IWUGO
,
4066 "%s/mt%s", SDp
->devfs_name
, st_formats
[i
]);
4067 /* No-rewind entry */
4068 devfs_mk_cdev(MKDEV(SCSI_TAPE_MAJOR
, TAPE_MINOR(dev_num
, mode
, 1)),
4069 S_IFCHR
| S_IRUGO
| S_IWUGO
,
4070 "%s/mt%sn", SDp
->devfs_name
, st_formats
[i
]);
4072 disk
->number
= devfs_register_tape(SDp
->devfs_name
);
4074 sdev_printk(KERN_WARNING
, SDp
,
4075 "Attached scsi tape %s", tape_name(tpnt
));
4076 printk(KERN_WARNING
"%s: try direct i/o: %s (alignment %d B)\n",
4077 tape_name(tpnt
), tpnt
->try_dio
? "yes" : "no",
4078 queue_dma_alignment(SDp
->request_queue
) + 1);
4083 for (mode
=0; mode
< ST_NBR_MODES
; mode
++) {
4084 STm
= &(tpnt
->modes
[mode
]);
4085 sysfs_remove_link(&tpnt
->device
->sdev_gendev
.kobj
,
4087 for (j
=0; j
< 2; j
++) {
4088 if (STm
->cdevs
[j
]) {
4089 if (cdev
== STm
->cdevs
[j
])
4091 class_device_destroy(st_sysfs_class
,
4092 MKDEV(SCSI_TAPE_MAJOR
,
4093 TAPE_MINOR(i
, mode
, j
)));
4094 cdev_del(STm
->cdevs
[j
]);
4100 write_lock(&st_dev_arr_lock
);
4101 scsi_tapes
[dev_num
] = NULL
;
4103 write_unlock(&st_dev_arr_lock
);
4114 static int st_remove(struct device
*dev
)
4116 struct scsi_device
*SDp
= to_scsi_device(dev
);
4117 struct scsi_tape
*tpnt
;
4120 write_lock(&st_dev_arr_lock
);
4121 for (i
= 0; i
< st_dev_max
; i
++) {
4122 tpnt
= scsi_tapes
[i
];
4123 if (tpnt
!= NULL
&& tpnt
->device
== SDp
) {
4124 scsi_tapes
[i
] = NULL
;
4126 write_unlock(&st_dev_arr_lock
);
4127 devfs_unregister_tape(tpnt
->disk
->number
);
4128 sysfs_remove_link(&tpnt
->device
->sdev_gendev
.kobj
,
4130 for (mode
= 0; mode
< ST_NBR_MODES
; ++mode
) {
4131 j
= mode
<< (4 - ST_NBR_MODE_BITS
);
4132 devfs_remove("%s/mt%s", SDp
->devfs_name
, st_formats
[j
]);
4133 devfs_remove("%s/mt%sn", SDp
->devfs_name
, st_formats
[j
]);
4134 for (j
=0; j
< 2; j
++) {
4135 class_device_destroy(st_sysfs_class
,
4136 MKDEV(SCSI_TAPE_MAJOR
,
4137 TAPE_MINOR(i
, mode
, j
)));
4138 cdev_del(tpnt
->modes
[mode
].cdevs
[j
]);
4139 tpnt
->modes
[mode
].cdevs
[j
] = NULL
;
4143 mutex_lock(&st_ref_mutex
);
4144 kref_put(&tpnt
->kref
, scsi_tape_release
);
4145 mutex_unlock(&st_ref_mutex
);
4150 write_unlock(&st_dev_arr_lock
);
4155 * scsi_tape_release - Called to free the Scsi_Tape structure
4156 * @kref: pointer to embedded kref
4158 * st_ref_mutex must be held entering this routine. Because it is
4159 * called on last put, you should always use the scsi_tape_get()
4160 * scsi_tape_put() helpers which manipulate the semaphore directly
4161 * and never do a direct kref_put().
4163 static void scsi_tape_release(struct kref
*kref
)
4165 struct scsi_tape
*tpnt
= to_scsi_tape(kref
);
4166 struct gendisk
*disk
= tpnt
->disk
;
4168 tpnt
->device
= NULL
;
4171 tpnt
->buffer
->orig_frp_segs
= 0;
4172 normalize_buffer(tpnt
->buffer
);
4173 kfree(tpnt
->buffer
);
4176 disk
->private_data
= NULL
;
4182 static int __init
init_st(void)
4187 "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4188 verstr
, st_fixed_buffer_size
, st_max_sg_segs
);
4190 st_sysfs_class
= class_create(THIS_MODULE
, "scsi_tape");
4191 if (IS_ERR(st_sysfs_class
)) {
4192 st_sysfs_class
= NULL
;
4193 printk(KERN_ERR
"Unable create sysfs class for SCSI tapes\n");
4197 if (!register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR
, 0),
4198 ST_MAX_TAPE_ENTRIES
, "st")) {
4199 if (scsi_register_driver(&st_template
.gendrv
) == 0) {
4200 do_create_driverfs_files();
4203 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR
, 0),
4204 ST_MAX_TAPE_ENTRIES
);
4206 class_destroy(st_sysfs_class
);
4208 printk(KERN_ERR
"Unable to get major %d for SCSI tapes\n", SCSI_TAPE_MAJOR
);
4212 static void __exit
exit_st(void)
4214 do_remove_driverfs_files();
4215 scsi_unregister_driver(&st_template
.gendrv
);
4216 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR
, 0),
4217 ST_MAX_TAPE_ENTRIES
);
4218 class_destroy(st_sysfs_class
);
4220 printk(KERN_INFO
"st: Unloaded.\n");
4223 module_init(init_st
);
4224 module_exit(exit_st
);
4227 /* The sysfs driver interface. Read-only at the moment */
4228 static ssize_t
st_try_direct_io_show(struct device_driver
*ddp
, char *buf
)
4230 return snprintf(buf
, PAGE_SIZE
, "%d\n", try_direct_io
);
4232 static DRIVER_ATTR(try_direct_io
, S_IRUGO
, st_try_direct_io_show
, NULL
);
4234 static ssize_t
st_fixed_buffer_size_show(struct device_driver
*ddp
, char *buf
)
4236 return snprintf(buf
, PAGE_SIZE
, "%d\n", st_fixed_buffer_size
);
4238 static DRIVER_ATTR(fixed_buffer_size
, S_IRUGO
, st_fixed_buffer_size_show
, NULL
);
4240 static ssize_t
st_max_sg_segs_show(struct device_driver
*ddp
, char *buf
)
4242 return snprintf(buf
, PAGE_SIZE
, "%d\n", st_max_sg_segs
);
4244 static DRIVER_ATTR(max_sg_segs
, S_IRUGO
, st_max_sg_segs_show
, NULL
);
4246 static ssize_t
st_version_show(struct device_driver
*ddd
, char *buf
)
4248 return snprintf(buf
, PAGE_SIZE
, "[%s]\n", verstr
);
4250 static DRIVER_ATTR(version
, S_IRUGO
, st_version_show
, NULL
);
4252 static void do_create_driverfs_files(void)
4254 struct device_driver
*driverfs
= &st_template
.gendrv
;
4256 driver_create_file(driverfs
, &driver_attr_try_direct_io
);
4257 driver_create_file(driverfs
, &driver_attr_fixed_buffer_size
);
4258 driver_create_file(driverfs
, &driver_attr_max_sg_segs
);
4259 driver_create_file(driverfs
, &driver_attr_version
);
4262 static void do_remove_driverfs_files(void)
4264 struct device_driver
*driverfs
= &st_template
.gendrv
;
4266 driver_remove_file(driverfs
, &driver_attr_version
);
4267 driver_remove_file(driverfs
, &driver_attr_max_sg_segs
);
4268 driver_remove_file(driverfs
, &driver_attr_fixed_buffer_size
);
4269 driver_remove_file(driverfs
, &driver_attr_try_direct_io
);
4273 /* The sysfs simple class interface */
4274 static ssize_t
st_defined_show(struct class_device
*class_dev
, char *buf
)
4276 struct st_modedef
*STm
= (struct st_modedef
*)class_get_devdata(class_dev
);
4279 l
= snprintf(buf
, PAGE_SIZE
, "%d\n", STm
->defined
);
4283 CLASS_DEVICE_ATTR(defined
, S_IRUGO
, st_defined_show
, NULL
);
4285 static ssize_t
st_defblk_show(struct class_device
*class_dev
, char *buf
)
4287 struct st_modedef
*STm
= (struct st_modedef
*)class_get_devdata(class_dev
);
4290 l
= snprintf(buf
, PAGE_SIZE
, "%d\n", STm
->default_blksize
);
4294 CLASS_DEVICE_ATTR(default_blksize
, S_IRUGO
, st_defblk_show
, NULL
);
4296 static ssize_t
st_defdensity_show(struct class_device
*class_dev
, char *buf
)
4298 struct st_modedef
*STm
= (struct st_modedef
*)class_get_devdata(class_dev
);
4302 fmt
= STm
->default_density
>= 0 ? "0x%02x\n" : "%d\n";
4303 l
= snprintf(buf
, PAGE_SIZE
, fmt
, STm
->default_density
);
4307 CLASS_DEVICE_ATTR(default_density
, S_IRUGO
, st_defdensity_show
, NULL
);
4309 static ssize_t
st_defcompression_show(struct class_device
*class_dev
, char *buf
)
4311 struct st_modedef
*STm
= (struct st_modedef
*)class_get_devdata(class_dev
);
4314 l
= snprintf(buf
, PAGE_SIZE
, "%d\n", STm
->default_compression
- 1);
4318 CLASS_DEVICE_ATTR(default_compression
, S_IRUGO
, st_defcompression_show
, NULL
);
4320 static void do_create_class_files(struct scsi_tape
*STp
, int dev_num
, int mode
)
4324 struct class_device
*st_class_member
;
4326 if (!st_sysfs_class
)
4329 for (rew
=0; rew
< 2; rew
++) {
4330 /* Make sure that the minor numbers corresponding to the four
4331 first modes always get the same names */
4332 i
= mode
<< (4 - ST_NBR_MODE_BITS
);
4333 snprintf(name
, 10, "%s%s%s", rew
? "n" : "",
4334 STp
->disk
->disk_name
, st_formats
[i
]);
4336 class_device_create(st_sysfs_class
, NULL
,
4337 MKDEV(SCSI_TAPE_MAJOR
,
4338 TAPE_MINOR(dev_num
, mode
, rew
)),
4339 &STp
->device
->sdev_gendev
, "%s", name
);
4340 if (IS_ERR(st_class_member
)) {
4341 printk(KERN_WARNING
"st%d: class_device_create failed\n",
4345 class_set_devdata(st_class_member
, &STp
->modes
[mode
]);
4347 class_device_create_file(st_class_member
,
4348 &class_device_attr_defined
);
4349 class_device_create_file(st_class_member
,
4350 &class_device_attr_default_blksize
);
4351 class_device_create_file(st_class_member
,
4352 &class_device_attr_default_density
);
4353 class_device_create_file(st_class_member
,
4354 &class_device_attr_default_compression
);
4355 if (mode
== 0 && rew
== 0) {
4356 error
= sysfs_create_link(&STp
->device
->sdev_gendev
.kobj
,
4357 &st_class_member
->kobj
,
4361 "st%d: Can't create sysfs link from SCSI device.\n",
4370 /* The following functions may be useful for a larger audience. */
4371 static int sgl_map_user_pages(struct scatterlist
*sgl
, const unsigned int max_pages
,
4372 unsigned long uaddr
, size_t count
, int rw
)
4374 unsigned long end
= (uaddr
+ count
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
4375 unsigned long start
= uaddr
>> PAGE_SHIFT
;
4376 const int nr_pages
= end
- start
;
4378 struct page
**pages
;
4380 /* User attempted Overflow! */
4381 if ((uaddr
+ count
) < uaddr
)
4385 if (nr_pages
> max_pages
)
4392 if ((pages
= kmalloc(max_pages
* sizeof(*pages
), GFP_KERNEL
)) == NULL
)
4395 /* Try to fault in all of the necessary pages */
4396 down_read(¤t
->mm
->mmap_sem
);
4397 /* rw==READ means read from drive, write into memory area */
4398 res
= get_user_pages(
4404 0, /* don't force */
4407 up_read(¤t
->mm
->mmap_sem
);
4409 /* Errors and no page mapped should return here */
4413 for (i
=0; i
< nr_pages
; i
++) {
4414 /* FIXME: flush superflous for rw==READ,
4415 * probably wrong function for rw==WRITE
4417 flush_dcache_page(pages
[i
]);
4420 /* Populate the scatter/gather list */
4421 sgl
[0].page
= pages
[0];
4422 sgl
[0].offset
= uaddr
& ~PAGE_MASK
;
4424 sgl
[0].length
= PAGE_SIZE
- sgl
[0].offset
;
4425 count
-= sgl
[0].length
;
4426 for (i
=1; i
< nr_pages
; i
++) {
4428 sgl
[i
].page
= pages
[i
];
4429 sgl
[i
].length
= count
< PAGE_SIZE
? count
: PAGE_SIZE
;
4434 sgl
[0].length
= count
;
4442 for (j
=0; j
< res
; j
++)
4443 page_cache_release(pages
[j
]);
4451 /* And unmap them... */
4452 static int sgl_unmap_user_pages(struct scatterlist
*sgl
, const unsigned int nr_pages
,
4457 for (i
=0; i
< nr_pages
; i
++) {
4458 struct page
*page
= sgl
[i
].page
;
4462 /* FIXME: cache flush missing for rw==READ
4463 * FIXME: call the correct reference counting function
4465 page_cache_release(page
);