11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying 31da177e4SLinus Torvalds file Documentation/scsi/st.txt for more information. 41da177e4SLinus Torvalds 51da177e4SLinus Torvalds History: 61da177e4SLinus Torvalds Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara. 71da177e4SLinus Torvalds Contribution and ideas from several people including (in alphabetical 81da177e4SLinus Torvalds order) Klaus Ehrenfried, Eugene Exarevsky, Eric Lee Green, Wolfgang Denk, 91da177e4SLinus Torvalds Steve Hirsch, Andreas Koppenh"ofer, Michael Leodolter, Eyal Lebedinsky, 101da177e4SLinus Torvalds Michael Schaefer, J"org Weule, and Eric Youngdale. 111da177e4SLinus Torvalds 123e51d3c9SKai Makisara Copyright 1992 - 2010 Kai Makisara 131da177e4SLinus Torvalds email Kai.Makisara@kolumbus.fi 141da177e4SLinus Torvalds 151da177e4SLinus Torvalds Some small formal changes - aeb, 950809 161da177e4SLinus Torvalds 171da177e4SLinus Torvalds Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support 181da177e4SLinus Torvalds */ 191da177e4SLinus Torvalds 20373daacfSKai Makisara static const char *verstr = "20101219"; 211da177e4SLinus Torvalds 221da177e4SLinus Torvalds #include <linux/module.h> 231da177e4SLinus Torvalds 241da177e4SLinus Torvalds #include <linux/fs.h> 251da177e4SLinus Torvalds #include <linux/kernel.h> 261da177e4SLinus Torvalds #include <linux/sched.h> 271da177e4SLinus Torvalds #include <linux/mm.h> 281da177e4SLinus Torvalds #include <linux/init.h> 291da177e4SLinus Torvalds #include <linux/string.h> 305a0e3ad6STejun Heo #include <linux/slab.h> 311da177e4SLinus Torvalds #include <linux/errno.h> 321da177e4SLinus Torvalds #include <linux/mtio.h> 3316c4b3e2SKai Makisara #include <linux/cdrom.h> 341da177e4SLinus Torvalds #include <linux/ioctl.h> 351da177e4SLinus Torvalds #include <linux/fcntl.h> 361da177e4SLinus Torvalds #include <linux/spinlock.h> 371da177e4SLinus Torvalds #include <linux/blkdev.h> 381da177e4SLinus Torvalds #include <linux/moduleparam.h> 391da177e4SLinus Torvalds #include <linux/cdev.h> 406c648d95SJeff Mahoney #include <linux/idr.h> 411da177e4SLinus Torvalds #include <linux/delay.h> 420b950672SArjan van de Ven #include <linux/mutex.h> 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds #include <asm/uaccess.h> 451da177e4SLinus Torvalds #include <asm/dma.h> 461da177e4SLinus Torvalds 471da177e4SLinus Torvalds #include <scsi/scsi.h> 481da177e4SLinus Torvalds #include <scsi/scsi_dbg.h> 491da177e4SLinus Torvalds #include <scsi/scsi_device.h> 501da177e4SLinus Torvalds #include <scsi/scsi_driver.h> 511da177e4SLinus Torvalds #include <scsi/scsi_eh.h> 521da177e4SLinus Torvalds #include <scsi/scsi_host.h> 531da177e4SLinus Torvalds #include <scsi/scsi_ioctl.h> 5416c4b3e2SKai Makisara #include <scsi/sg.h> 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds 571da177e4SLinus Torvalds /* The driver prints some debugging information on the console if DEBUG 581da177e4SLinus Torvalds is defined and non-zero. */ 592bec708aSLaurence Oberman #define DEBUG 1 602bec708aSLaurence Oberman #define NO_DEBUG 0 611da177e4SLinus Torvalds 62b30d8bcaSHannes Reinecke #define ST_DEB_MSG KERN_NOTICE 631da177e4SLinus Torvalds #if DEBUG 641da177e4SLinus Torvalds /* The message level for the debug messages is currently set to KERN_NOTICE 651da177e4SLinus Torvalds so that people can easily see the messages. Later when the debugging messages 661da177e4SLinus Torvalds in the drivers are more widely classified, this may be changed to KERN_DEBUG. */ 671da177e4SLinus Torvalds #define DEB(a) a 681da177e4SLinus Torvalds #define DEBC(a) if (debugging) { a ; } 691da177e4SLinus Torvalds #else 701da177e4SLinus Torvalds #define DEB(a) 711da177e4SLinus Torvalds #define DEBC(a) 721da177e4SLinus Torvalds #endif 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds #define ST_KILOBYTE 1024 751da177e4SLinus Torvalds 761da177e4SLinus Torvalds #include "st_options.h" 771da177e4SLinus Torvalds #include "st.h" 781da177e4SLinus Torvalds 791da177e4SLinus Torvalds static int buffer_kbs; 801da177e4SLinus Torvalds static int max_sg_segs; 811da177e4SLinus Torvalds static int try_direct_io = TRY_DIRECT_IO; 821da177e4SLinus Torvalds static int try_rdio = 1; 831da177e4SLinus Torvalds static int try_wdio = 1; 842bec708aSLaurence Oberman static int debug_flag; 851da177e4SLinus Torvalds 86af23782bSJeff Mahoney static struct class st_sysfs_class; 87c69c6be5SGreg Kroah-Hartman static const struct attribute_group *st_dev_groups[]; 881da177e4SLinus Torvalds 891da177e4SLinus Torvalds MODULE_AUTHOR("Kai Makisara"); 90f018fa55SRene Herman MODULE_DESCRIPTION("SCSI tape (st) driver"); 911da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 92f018fa55SRene Herman MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR); 93d7b8bcb0SMichael Tokarev MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE); 941da177e4SLinus Torvalds 951da177e4SLinus Torvalds /* Set 'perm' (4th argument) to 0 to disable module_param's definition 961da177e4SLinus Torvalds * of sysfs parameters (which module_param doesn't yet support). 971da177e4SLinus Torvalds * Sysfs parameters defined explicitly later. 981da177e4SLinus Torvalds */ 991da177e4SLinus Torvalds module_param_named(buffer_kbs, buffer_kbs, int, 0); 1001da177e4SLinus Torvalds MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)"); 1011da177e4SLinus Torvalds module_param_named(max_sg_segs, max_sg_segs, int, 0); 1021da177e4SLinus Torvalds MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)"); 1031da177e4SLinus Torvalds module_param_named(try_direct_io, try_direct_io, int, 0); 1041da177e4SLinus Torvalds MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)"); 1052bec708aSLaurence Oberman module_param_named(debug_flag, debug_flag, int, 0); 1062bec708aSLaurence Oberman MODULE_PARM_DESC(debug_flag, "Enable DEBUG, same as setting debugging=1"); 1072bec708aSLaurence Oberman 1081da177e4SLinus Torvalds 1091da177e4SLinus Torvalds /* Extra parameters for testing */ 1101da177e4SLinus Torvalds module_param_named(try_rdio, try_rdio, int, 0); 1111da177e4SLinus Torvalds MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible"); 1121da177e4SLinus Torvalds module_param_named(try_wdio, try_wdio, int, 0); 1131da177e4SLinus Torvalds MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible"); 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds #ifndef MODULE 1161da177e4SLinus Torvalds static int write_threshold_kbs; /* retained for compatibility */ 1171da177e4SLinus Torvalds static struct st_dev_parm { 1181da177e4SLinus Torvalds char *name; 1191da177e4SLinus Torvalds int *val; 1201da177e4SLinus Torvalds } parms[] __initdata = { 1211da177e4SLinus Torvalds { 1221da177e4SLinus Torvalds "buffer_kbs", &buffer_kbs 1231da177e4SLinus Torvalds }, 1241da177e4SLinus Torvalds { /* Retained for compatibility with 2.4 */ 1251da177e4SLinus Torvalds "write_threshold_kbs", &write_threshold_kbs 1261da177e4SLinus Torvalds }, 1271da177e4SLinus Torvalds { 1281da177e4SLinus Torvalds "max_sg_segs", NULL 1291da177e4SLinus Torvalds }, 1301da177e4SLinus Torvalds { 1311da177e4SLinus Torvalds "try_direct_io", &try_direct_io 1322bec708aSLaurence Oberman }, 1332bec708aSLaurence Oberman { 1342bec708aSLaurence Oberman "debug_flag", &debug_flag 1351da177e4SLinus Torvalds } 1361da177e4SLinus Torvalds }; 1371da177e4SLinus Torvalds #endif 1381da177e4SLinus Torvalds 1391da177e4SLinus Torvalds /* Restrict the number of modes so that names for all are assigned */ 1401da177e4SLinus Torvalds #if ST_NBR_MODES > 16 1411da177e4SLinus Torvalds #error "Maximum number of modes is 16" 1421da177e4SLinus Torvalds #endif 1431da177e4SLinus Torvalds /* Bit reversed order to get same names for same minors with all 1441da177e4SLinus Torvalds mode counts */ 1450ad78200SArjan van de Ven static const char *st_formats[] = { 1461da177e4SLinus Torvalds "", "r", "k", "s", "l", "t", "o", "u", 1471da177e4SLinus Torvalds "m", "v", "p", "x", "a", "y", "q", "z"}; 1481da177e4SLinus Torvalds 1491da177e4SLinus Torvalds /* The default definitions have been moved to st_options.h */ 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE) 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds /* The buffer size should fit into the 24 bits for length in the 1541da177e4SLinus Torvalds 6-byte SCSI read and write commands. */ 1551da177e4SLinus Torvalds #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1) 1561da177e4SLinus Torvalds #error "Buffer size should not exceed (2 << 24 - 1) bytes!" 1571da177e4SLinus Torvalds #endif 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds static int debugging = DEBUG; 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds #define MAX_RETRIES 0 1621da177e4SLinus Torvalds #define MAX_WRITE_RETRIES 0 1631da177e4SLinus Torvalds #define MAX_READY_RETRIES 0 1641da177e4SLinus Torvalds #define NO_TAPE NOT_READY 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds #define ST_TIMEOUT (900 * HZ) 1671da177e4SLinus Torvalds #define ST_LONG_TIMEOUT (14000 * HZ) 1681da177e4SLinus Torvalds 1691da177e4SLinus Torvalds /* Remove mode bits and auto-rewind bit (7) */ 1701da177e4SLinus Torvalds #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \ 1711da177e4SLinus Torvalds (iminor(x) & ~(-1 << ST_MODE_SHIFT)) ) 1721da177e4SLinus Torvalds #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT) 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */ 1751da177e4SLinus Torvalds #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \ 1761da177e4SLinus Torvalds (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) ) 1771da177e4SLinus Torvalds 1781da177e4SLinus Torvalds /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower 1791da177e4SLinus Torvalds 24 bits) */ 1801da177e4SLinus Torvalds #define SET_DENS_AND_BLK 0x10001 1811da177e4SLinus Torvalds 1821da177e4SLinus Torvalds static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE; 1831da177e4SLinus Torvalds static int st_max_sg_segs = ST_MAX_SG; 1841da177e4SLinus Torvalds 1851da177e4SLinus Torvalds static int modes_defined; 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds static int enlarge_buffer(struct st_buffer *, int, int); 18840f6b36cSKai Makisara static void clear_buffer(struct st_buffer *); 1891da177e4SLinus Torvalds static void normalize_buffer(struct st_buffer *); 1901da177e4SLinus Torvalds static int append_to_buffer(const char __user *, struct st_buffer *, int); 1911da177e4SLinus Torvalds static int from_buffer(struct st_buffer *, char __user *, int); 1921da177e4SLinus Torvalds static void move_buffer_data(struct st_buffer *, int); 1931da177e4SLinus Torvalds 1946620742fSFUJITA Tomonori static int sgl_map_user_pages(struct st_buffer *, const unsigned int, 1951da177e4SLinus Torvalds unsigned long, size_t, int); 1966620742fSFUJITA Tomonori static int sgl_unmap_user_pages(struct st_buffer *, const unsigned int, int); 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds static int st_probe(struct device *); 1991da177e4SLinus Torvalds static int st_remove(struct device *); 2001da177e4SLinus Torvalds 201405ae7d3SRobert P. J. Day static int do_create_sysfs_files(void); 202405ae7d3SRobert P. J. Day static void do_remove_sysfs_files(void); 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds static struct scsi_driver st_template = { 2051da177e4SLinus Torvalds .owner = THIS_MODULE, 2061da177e4SLinus Torvalds .gendrv = { 2071da177e4SLinus Torvalds .name = "st", 2081da177e4SLinus Torvalds .probe = st_probe, 2091da177e4SLinus Torvalds .remove = st_remove, 2101da177e4SLinus Torvalds }, 2111da177e4SLinus Torvalds }; 2121da177e4SLinus Torvalds 2131da177e4SLinus Torvalds static int st_compression(struct scsi_tape *, int); 2141da177e4SLinus Torvalds 2151da177e4SLinus Torvalds static int find_partition(struct scsi_tape *); 2161da177e4SLinus Torvalds static int switch_partition(struct scsi_tape *); 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long); 2191da177e4SLinus Torvalds 220f03a5670SKai Makisara static void scsi_tape_release(struct kref *); 221f03a5670SKai Makisara 222f03a5670SKai Makisara #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref) 223f03a5670SKai Makisara 2240b950672SArjan van de Ven static DEFINE_MUTEX(st_ref_mutex); 2256c648d95SJeff Mahoney static DEFINE_SPINLOCK(st_index_lock); 2266c648d95SJeff Mahoney static DEFINE_SPINLOCK(st_use_lock); 2276c648d95SJeff Mahoney static DEFINE_IDR(st_index_idr); 2286c648d95SJeff Mahoney 229f03a5670SKai Makisara 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds #include "osst_detect.h" 2321da177e4SLinus Torvalds #ifndef SIGS_FROM_OSST 2331da177e4SLinus Torvalds #define SIGS_FROM_OSST \ 2341da177e4SLinus Torvalds {"OnStream", "SC-", "", "osst"}, \ 2351da177e4SLinus Torvalds {"OnStream", "DI-", "", "osst"}, \ 2361da177e4SLinus Torvalds {"OnStream", "DP-", "", "osst"}, \ 2371da177e4SLinus Torvalds {"OnStream", "USB", "", "osst"}, \ 2381da177e4SLinus Torvalds {"OnStream", "FW-", "", "osst"} 2391da177e4SLinus Torvalds #endif 2401da177e4SLinus Torvalds 241f03a5670SKai Makisara static struct scsi_tape *scsi_tape_get(int dev) 242f03a5670SKai Makisara { 243f03a5670SKai Makisara struct scsi_tape *STp = NULL; 244f03a5670SKai Makisara 2450b950672SArjan van de Ven mutex_lock(&st_ref_mutex); 2466c648d95SJeff Mahoney spin_lock(&st_index_lock); 247f03a5670SKai Makisara 2486c648d95SJeff Mahoney STp = idr_find(&st_index_idr, dev); 249f03a5670SKai Makisara if (!STp) goto out; 250f03a5670SKai Makisara 251f03a5670SKai Makisara kref_get(&STp->kref); 252f03a5670SKai Makisara 253f03a5670SKai Makisara if (!STp->device) 254f03a5670SKai Makisara goto out_put; 255f03a5670SKai Makisara 256f03a5670SKai Makisara if (scsi_device_get(STp->device)) 257f03a5670SKai Makisara goto out_put; 258f03a5670SKai Makisara 259f03a5670SKai Makisara goto out; 260f03a5670SKai Makisara 261f03a5670SKai Makisara out_put: 262f03a5670SKai Makisara kref_put(&STp->kref, scsi_tape_release); 263f03a5670SKai Makisara STp = NULL; 264f03a5670SKai Makisara out: 2656c648d95SJeff Mahoney spin_unlock(&st_index_lock); 2660b950672SArjan van de Ven mutex_unlock(&st_ref_mutex); 267f03a5670SKai Makisara return STp; 268f03a5670SKai Makisara } 269f03a5670SKai Makisara 270f03a5670SKai Makisara static void scsi_tape_put(struct scsi_tape *STp) 271f03a5670SKai Makisara { 272f03a5670SKai Makisara struct scsi_device *sdev = STp->device; 273f03a5670SKai Makisara 2740b950672SArjan van de Ven mutex_lock(&st_ref_mutex); 275f03a5670SKai Makisara kref_put(&STp->kref, scsi_tape_release); 276f03a5670SKai Makisara scsi_device_put(sdev); 2770b950672SArjan van de Ven mutex_unlock(&st_ref_mutex); 278f03a5670SKai Makisara } 279f03a5670SKai Makisara 2801da177e4SLinus Torvalds struct st_reject_data { 2811da177e4SLinus Torvalds char *vendor; 2821da177e4SLinus Torvalds char *model; 2831da177e4SLinus Torvalds char *rev; 2841da177e4SLinus Torvalds char *driver_hint; /* Name of the correct driver, NULL if unknown */ 2851da177e4SLinus Torvalds }; 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds static struct st_reject_data reject_list[] = { 2881da177e4SLinus Torvalds /* {"XXX", "Yy-", "", NULL}, example */ 2891da177e4SLinus Torvalds SIGS_FROM_OSST, 2901da177e4SLinus Torvalds {NULL, }}; 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds /* If the device signature is on the list of incompatible drives, the 2931da177e4SLinus Torvalds function returns a pointer to the name of the correct driver (if known) */ 2941da177e4SLinus Torvalds static char * st_incompatible(struct scsi_device* SDp) 2951da177e4SLinus Torvalds { 2961da177e4SLinus Torvalds struct st_reject_data *rp; 2971da177e4SLinus Torvalds 2981da177e4SLinus Torvalds for (rp=&(reject_list[0]); rp->vendor != NULL; rp++) 2991da177e4SLinus Torvalds if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) && 3001da177e4SLinus Torvalds !strncmp(rp->model, SDp->model, strlen(rp->model)) && 3011da177e4SLinus Torvalds !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) { 3021da177e4SLinus Torvalds if (rp->driver_hint) 3031da177e4SLinus Torvalds return rp->driver_hint; 3041da177e4SLinus Torvalds else 3051da177e4SLinus Torvalds return "unknown"; 3061da177e4SLinus Torvalds } 3071da177e4SLinus Torvalds return NULL; 3081da177e4SLinus Torvalds } 3091da177e4SLinus Torvalds 3101da177e4SLinus Torvalds 3111da177e4SLinus Torvalds static inline char *tape_name(struct scsi_tape *tape) 3121da177e4SLinus Torvalds { 3131da177e4SLinus Torvalds return tape->disk->disk_name; 3141da177e4SLinus Torvalds } 3151da177e4SLinus Torvalds 316b30d8bcaSHannes Reinecke #define st_printk(prefix, t, fmt, a...) \ 31722e0d994SHannes Reinecke sdev_prefix_printk(prefix, (t)->device, tape_name(t), fmt, ##a) 318b30d8bcaSHannes Reinecke #ifdef DEBUG 319b30d8bcaSHannes Reinecke #define DEBC_printk(t, fmt, a...) \ 320b30d8bcaSHannes Reinecke if (debugging) { st_printk(ST_DEB_MSG, t, fmt, ##a ); } 321b30d8bcaSHannes Reinecke #else 322b30d8bcaSHannes Reinecke #define DEBC_printk(t, fmt, a...) 323b30d8bcaSHannes Reinecke #endif 3241da177e4SLinus Torvalds 3258b05b773SMike Christie static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s) 3261da177e4SLinus Torvalds { 3271da177e4SLinus Torvalds const u8 *ucp; 3288b05b773SMike Christie const u8 *sense = SRpnt->sense; 3291da177e4SLinus Torvalds 3308b05b773SMike Christie s->have_sense = scsi_normalize_sense(SRpnt->sense, 3318b05b773SMike Christie SCSI_SENSE_BUFFERSIZE, &s->sense_hdr); 3321da177e4SLinus Torvalds s->flags = 0; 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds if (s->have_sense) { 3351da177e4SLinus Torvalds s->deferred = 0; 3361da177e4SLinus Torvalds s->remainder_valid = 3371da177e4SLinus Torvalds scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64); 3381da177e4SLinus Torvalds switch (sense[0] & 0x7f) { 3391da177e4SLinus Torvalds case 0x71: 3401da177e4SLinus Torvalds s->deferred = 1; 3411da177e4SLinus Torvalds case 0x70: 3421da177e4SLinus Torvalds s->fixed_format = 1; 3431da177e4SLinus Torvalds s->flags = sense[2] & 0xe0; 3441da177e4SLinus Torvalds break; 3451da177e4SLinus Torvalds case 0x73: 3461da177e4SLinus Torvalds s->deferred = 1; 3471da177e4SLinus Torvalds case 0x72: 3481da177e4SLinus Torvalds s->fixed_format = 0; 3491da177e4SLinus Torvalds ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4); 3501da177e4SLinus Torvalds s->flags = ucp ? (ucp[3] & 0xe0) : 0; 3511da177e4SLinus Torvalds break; 3521da177e4SLinus Torvalds } 3531da177e4SLinus Torvalds } 3541da177e4SLinus Torvalds } 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds 3571da177e4SLinus Torvalds /* Convert the result to success code */ 3588b05b773SMike Christie static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt) 3591da177e4SLinus Torvalds { 3608b05b773SMike Christie int result = SRpnt->result; 3611da177e4SLinus Torvalds u8 scode; 3621da177e4SLinus Torvalds DEB(const char *stp;) 3631da177e4SLinus Torvalds char *name = tape_name(STp); 3641da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp; 3651da177e4SLinus Torvalds 3661da177e4SLinus Torvalds if (!result) 3671da177e4SLinus Torvalds return 0; 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds cmdstatp = &STp->buffer->cmdstat; 370f03a5670SKai Makisara st_analyze_sense(SRpnt, cmdstatp); 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds if (cmdstatp->have_sense) 3731da177e4SLinus Torvalds scode = STp->buffer->cmdstat.sense_hdr.sense_key; 3741da177e4SLinus Torvalds else 3751da177e4SLinus Torvalds scode = 0; 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds DEB( 3781da177e4SLinus Torvalds if (debugging) { 379b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, 380b30d8bcaSHannes Reinecke "Error: %x, cmd: %x %x %x %x %x %x\n", result, 3818b05b773SMike Christie SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2], 3828b05b773SMike Christie SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]); 3831da177e4SLinus Torvalds if (cmdstatp->have_sense) 384d811b848SHannes Reinecke __scsi_print_sense(STp->device, name, 385d811b848SHannes Reinecke SRpnt->sense, SCSI_SENSE_BUFFERSIZE); 3861da177e4SLinus Torvalds } ) /* end DEB */ 3871da177e4SLinus Torvalds if (!debugging) { /* Abnormal conditions for tape */ 3881da177e4SLinus Torvalds if (!cmdstatp->have_sense) 389b30d8bcaSHannes Reinecke st_printk(KERN_WARNING, STp, 390b30d8bcaSHannes Reinecke "Error %x (driver bt 0x%x, host bt 0x%x).\n", 391b30d8bcaSHannes Reinecke result, driver_byte(result), host_byte(result)); 3921da177e4SLinus Torvalds else if (cmdstatp->have_sense && 3931da177e4SLinus Torvalds scode != NO_SENSE && 3941da177e4SLinus Torvalds scode != RECOVERED_ERROR && 3951da177e4SLinus Torvalds /* scode != UNIT_ATTENTION && */ 3961da177e4SLinus Torvalds scode != BLANK_CHECK && 3971da177e4SLinus Torvalds scode != VOLUME_OVERFLOW && 3988b05b773SMike Christie SRpnt->cmd[0] != MODE_SENSE && 3998b05b773SMike Christie SRpnt->cmd[0] != TEST_UNIT_READY) { 4004e73ea7bSLuben Tuikov 401d811b848SHannes Reinecke __scsi_print_sense(STp->device, name, 402d811b848SHannes Reinecke SRpnt->sense, SCSI_SENSE_BUFFERSIZE); 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds } 4051da177e4SLinus Torvalds 4061da177e4SLinus Torvalds if (cmdstatp->fixed_format && 4071da177e4SLinus Torvalds STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */ 4081da177e4SLinus Torvalds if (STp->cln_sense_value) 4098b05b773SMike Christie STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] & 4101da177e4SLinus Torvalds STp->cln_sense_mask) == STp->cln_sense_value); 4111da177e4SLinus Torvalds else 4128b05b773SMike Christie STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] & 4131da177e4SLinus Torvalds STp->cln_sense_mask) != 0); 4141da177e4SLinus Torvalds } 4151da177e4SLinus Torvalds if (cmdstatp->have_sense && 4161da177e4SLinus Torvalds cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17) 4171da177e4SLinus Torvalds STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */ 4181da177e4SLinus Torvalds 4191da177e4SLinus Torvalds STp->pos_unknown |= STp->device->was_reset; 4201da177e4SLinus Torvalds 4211da177e4SLinus Torvalds if (cmdstatp->have_sense && 4221da177e4SLinus Torvalds scode == RECOVERED_ERROR 4231da177e4SLinus Torvalds #if ST_RECOVERED_WRITE_FATAL 4248b05b773SMike Christie && SRpnt->cmd[0] != WRITE_6 4258b05b773SMike Christie && SRpnt->cmd[0] != WRITE_FILEMARKS 4261da177e4SLinus Torvalds #endif 4271da177e4SLinus Torvalds ) { 4281da177e4SLinus Torvalds STp->recover_count++; 4291da177e4SLinus Torvalds STp->recover_reg++; 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds DEB( 4321da177e4SLinus Torvalds if (debugging) { 4338b05b773SMike Christie if (SRpnt->cmd[0] == READ_6) 4341da177e4SLinus Torvalds stp = "read"; 4358b05b773SMike Christie else if (SRpnt->cmd[0] == WRITE_6) 4361da177e4SLinus Torvalds stp = "write"; 4371da177e4SLinus Torvalds else 4381da177e4SLinus Torvalds stp = "ioctl"; 439b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, 440b30d8bcaSHannes Reinecke "Recovered %s error (%d).\n", 441b30d8bcaSHannes Reinecke stp, STp->recover_count); 4421da177e4SLinus Torvalds } ) /* end DEB */ 4431da177e4SLinus Torvalds 4441da177e4SLinus Torvalds if (cmdstatp->flags == 0) 4451da177e4SLinus Torvalds return 0; 4461da177e4SLinus Torvalds } 4471da177e4SLinus Torvalds return (-EIO); 4481da177e4SLinus Torvalds } 4491da177e4SLinus Torvalds 4504deba245SFUJITA Tomonori static struct st_request *st_allocate_request(struct scsi_tape *stp) 4518b05b773SMike Christie { 4524deba245SFUJITA Tomonori struct st_request *streq; 4534deba245SFUJITA Tomonori 4544deba245SFUJITA Tomonori streq = kzalloc(sizeof(*streq), GFP_KERNEL); 4554deba245SFUJITA Tomonori if (streq) 4564deba245SFUJITA Tomonori streq->stp = stp; 4574deba245SFUJITA Tomonori else { 458b30d8bcaSHannes Reinecke st_printk(KERN_ERR, stp, 459b30d8bcaSHannes Reinecke "Can't get SCSI request.\n"); 4604deba245SFUJITA Tomonori if (signal_pending(current)) 4614deba245SFUJITA Tomonori stp->buffer->syscall_result = -EINTR; 4624deba245SFUJITA Tomonori else 4634deba245SFUJITA Tomonori stp->buffer->syscall_result = -EBUSY; 4644deba245SFUJITA Tomonori } 4654deba245SFUJITA Tomonori 4664deba245SFUJITA Tomonori return streq; 4678b05b773SMike Christie } 4688b05b773SMike Christie 4698b05b773SMike Christie static void st_release_request(struct st_request *streq) 4708b05b773SMike Christie { 4718b05b773SMike Christie kfree(streq); 4721da177e4SLinus Torvalds } 4731da177e4SLinus Torvalds 47413b53b44SFUJITA Tomonori static void st_scsi_execute_end(struct request *req, int uptodate) 47513b53b44SFUJITA Tomonori { 47613b53b44SFUJITA Tomonori struct st_request *SRpnt = req->end_io_data; 47713b53b44SFUJITA Tomonori struct scsi_tape *STp = SRpnt->stp; 478c68bf8eeSPetr Uzel struct bio *tmp; 47913b53b44SFUJITA Tomonori 48013b53b44SFUJITA Tomonori STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors; 481c3a4d78cSTejun Heo STp->buffer->cmdstat.residual = req->resid_len; 48213b53b44SFUJITA Tomonori 483c68bf8eeSPetr Uzel tmp = SRpnt->bio; 48413b53b44SFUJITA Tomonori if (SRpnt->waiting) 48513b53b44SFUJITA Tomonori complete(SRpnt->waiting); 48613b53b44SFUJITA Tomonori 487c68bf8eeSPetr Uzel blk_rq_unmap_user(tmp); 48813b53b44SFUJITA Tomonori __blk_put_request(req->q, req); 48913b53b44SFUJITA Tomonori } 49013b53b44SFUJITA Tomonori 49113b53b44SFUJITA Tomonori static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd, 49213b53b44SFUJITA Tomonori int data_direction, void *buffer, unsigned bufflen, 49313b53b44SFUJITA Tomonori int timeout, int retries) 49413b53b44SFUJITA Tomonori { 49513b53b44SFUJITA Tomonori struct request *req; 49613b53b44SFUJITA Tomonori struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data; 49713b53b44SFUJITA Tomonori int err = 0; 49813b53b44SFUJITA Tomonori int write = (data_direction == DMA_TO_DEVICE); 49913b53b44SFUJITA Tomonori 50013b53b44SFUJITA Tomonori req = blk_get_request(SRpnt->stp->device->request_queue, write, 50113b53b44SFUJITA Tomonori GFP_KERNEL); 502a492f075SJoe Lawrence if (IS_ERR(req)) 50313b53b44SFUJITA Tomonori return DRIVER_ERROR << 24; 50413b53b44SFUJITA Tomonori 505f27b087bSJens Axboe blk_rq_set_block_pc(req); 50613b53b44SFUJITA Tomonori req->cmd_flags |= REQ_QUIET; 50713b53b44SFUJITA Tomonori 50813b53b44SFUJITA Tomonori mdata->null_mapped = 1; 50913b53b44SFUJITA Tomonori 51002ae2c0eSKai Makisara if (bufflen) { 51102ae2c0eSKai Makisara err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen, 51202ae2c0eSKai Makisara GFP_KERNEL); 51313b53b44SFUJITA Tomonori if (err) { 51413b53b44SFUJITA Tomonori blk_put_request(req); 51513b53b44SFUJITA Tomonori return DRIVER_ERROR << 24; 51613b53b44SFUJITA Tomonori } 51702ae2c0eSKai Makisara } 51813b53b44SFUJITA Tomonori 51913b53b44SFUJITA Tomonori SRpnt->bio = req->bio; 52013b53b44SFUJITA Tomonori req->cmd_len = COMMAND_SIZE(cmd[0]); 52113b53b44SFUJITA Tomonori memset(req->cmd, 0, BLK_MAX_CDB); 52213b53b44SFUJITA Tomonori memcpy(req->cmd, cmd, req->cmd_len); 52313b53b44SFUJITA Tomonori req->sense = SRpnt->sense; 52413b53b44SFUJITA Tomonori req->sense_len = 0; 52513b53b44SFUJITA Tomonori req->timeout = timeout; 52613b53b44SFUJITA Tomonori req->retries = retries; 52713b53b44SFUJITA Tomonori req->end_io_data = SRpnt; 52813b53b44SFUJITA Tomonori 52913b53b44SFUJITA Tomonori blk_execute_rq_nowait(req->q, NULL, req, 1, st_scsi_execute_end); 53013b53b44SFUJITA Tomonori return 0; 53113b53b44SFUJITA Tomonori } 53213b53b44SFUJITA Tomonori 5331da177e4SLinus Torvalds /* Do the scsi command. Waits until command performed if do_wait is true. 5341da177e4SLinus Torvalds Otherwise write_behind_check() is used to check that the command 5351da177e4SLinus Torvalds has finished. */ 5368b05b773SMike Christie static struct st_request * 5378b05b773SMike Christie st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd, 5381da177e4SLinus Torvalds int bytes, int direction, int timeout, int retries, int do_wait) 5391da177e4SLinus Torvalds { 540f03a5670SKai Makisara struct completion *waiting; 5416d476267SFUJITA Tomonori struct rq_map_data *mdata = &STp->buffer->map_data; 5426d476267SFUJITA Tomonori int ret; 5431da177e4SLinus Torvalds 544f03a5670SKai Makisara /* if async, make sure there's no command outstanding */ 545f03a5670SKai Makisara if (!do_wait && ((STp->buffer)->last_SRpnt)) { 546b30d8bcaSHannes Reinecke st_printk(KERN_ERR, STp, 547b30d8bcaSHannes Reinecke "Async command already active.\n"); 548f03a5670SKai Makisara if (signal_pending(current)) 549f03a5670SKai Makisara (STp->buffer)->syscall_result = (-EINTR); 550f03a5670SKai Makisara else 551f03a5670SKai Makisara (STp->buffer)->syscall_result = (-EBUSY); 552f03a5670SKai Makisara return NULL; 553f03a5670SKai Makisara } 554f03a5670SKai Makisara 5554deba245SFUJITA Tomonori if (!SRpnt) { 5564deba245SFUJITA Tomonori SRpnt = st_allocate_request(STp); 5574deba245SFUJITA Tomonori if (!SRpnt) 5581da177e4SLinus Torvalds return NULL; 5591da177e4SLinus Torvalds } 5601da177e4SLinus Torvalds 561f03a5670SKai Makisara /* If async IO, set last_SRpnt. This ptr tells write_behind_check 562f03a5670SKai Makisara which IO is outstanding. It's nulled out when the IO completes. */ 563f03a5670SKai Makisara if (!do_wait) 564f03a5670SKai Makisara (STp->buffer)->last_SRpnt = SRpnt; 565f03a5670SKai Makisara 566f03a5670SKai Makisara waiting = &STp->wait; 567f03a5670SKai Makisara init_completion(waiting); 5688b05b773SMike Christie SRpnt->waiting = waiting; 5698b05b773SMike Christie 5706620742fSFUJITA Tomonori if (STp->buffer->do_dio) { 571c982c368SFUJITA Tomonori mdata->page_order = 0; 5726620742fSFUJITA Tomonori mdata->nr_entries = STp->buffer->sg_segs; 5736620742fSFUJITA Tomonori mdata->pages = STp->buffer->mapped_pages; 5746620742fSFUJITA Tomonori } else { 575c982c368SFUJITA Tomonori mdata->page_order = STp->buffer->reserved_page_order; 5766d476267SFUJITA Tomonori mdata->nr_entries = 5776d476267SFUJITA Tomonori DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order); 578c982c368SFUJITA Tomonori mdata->pages = STp->buffer->reserved_pages; 579c982c368SFUJITA Tomonori mdata->offset = 0; 5806d476267SFUJITA Tomonori } 5816d476267SFUJITA Tomonori 5828b05b773SMike Christie memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd)); 5831da177e4SLinus Torvalds STp->buffer->cmdstat.have_sense = 0; 5848b05b773SMike Christie STp->buffer->syscall_result = 0; 5851da177e4SLinus Torvalds 5866620742fSFUJITA Tomonori ret = st_scsi_execute(SRpnt, cmd, direction, NULL, bytes, timeout, 5876620742fSFUJITA Tomonori retries); 5886d476267SFUJITA Tomonori if (ret) { 5898b05b773SMike Christie /* could not allocate the buffer or request was too large */ 5908b05b773SMike Christie (STp->buffer)->syscall_result = (-EBUSY); 591787926b1SKai Makisara (STp->buffer)->last_SRpnt = NULL; 5926d476267SFUJITA Tomonori } else if (do_wait) { 593f03a5670SKai Makisara wait_for_completion(waiting); 5948b05b773SMike Christie SRpnt->waiting = NULL; 5951da177e4SLinus Torvalds (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt); 5961da177e4SLinus Torvalds } 5978b05b773SMike Christie 5981da177e4SLinus Torvalds return SRpnt; 5991da177e4SLinus Torvalds } 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if 6031da177e4SLinus Torvalds write has been correct but EOM early warning reached, -EIO if write ended in 6041da177e4SLinus Torvalds error or zero if write successful. Asynchronous writes are used only in 6051da177e4SLinus Torvalds variable block mode. */ 6061da177e4SLinus Torvalds static int write_behind_check(struct scsi_tape * STp) 6071da177e4SLinus Torvalds { 6081da177e4SLinus Torvalds int retval = 0; 6091da177e4SLinus Torvalds struct st_buffer *STbuffer; 6101da177e4SLinus Torvalds struct st_partstat *STps; 6111da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp; 6128b05b773SMike Christie struct st_request *SRpnt; 6131da177e4SLinus Torvalds 6141da177e4SLinus Torvalds STbuffer = STp->buffer; 6151da177e4SLinus Torvalds if (!STbuffer->writing) 6161da177e4SLinus Torvalds return 0; 6171da177e4SLinus Torvalds 6181da177e4SLinus Torvalds DEB( 6191da177e4SLinus Torvalds if (STp->write_pending) 6201da177e4SLinus Torvalds STp->nbr_waits++; 6211da177e4SLinus Torvalds else 6221da177e4SLinus Torvalds STp->nbr_finished++; 6231da177e4SLinus Torvalds ) /* end DEB */ 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds wait_for_completion(&(STp->wait)); 626f03a5670SKai Makisara SRpnt = STbuffer->last_SRpnt; 627f03a5670SKai Makisara STbuffer->last_SRpnt = NULL; 6288b05b773SMike Christie SRpnt->waiting = NULL; 6291da177e4SLinus Torvalds 630f03a5670SKai Makisara (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt); 6318b05b773SMike Christie st_release_request(SRpnt); 6321da177e4SLinus Torvalds 6331da177e4SLinus Torvalds STbuffer->buffer_bytes -= STbuffer->writing; 6341da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 6351da177e4SLinus Torvalds if (STps->drv_block >= 0) { 6361da177e4SLinus Torvalds if (STp->block_size == 0) 6371da177e4SLinus Torvalds STps->drv_block++; 6381da177e4SLinus Torvalds else 6391da177e4SLinus Torvalds STps->drv_block += STbuffer->writing / STp->block_size; 6401da177e4SLinus Torvalds } 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds cmdstatp = &STbuffer->cmdstat; 6431da177e4SLinus Torvalds if (STbuffer->syscall_result) { 6441da177e4SLinus Torvalds retval = -EIO; 6451da177e4SLinus Torvalds if (cmdstatp->have_sense && !cmdstatp->deferred && 6461da177e4SLinus Torvalds (cmdstatp->flags & SENSE_EOM) && 6471da177e4SLinus Torvalds (cmdstatp->sense_hdr.sense_key == NO_SENSE || 6481da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) { 6491da177e4SLinus Torvalds /* EOM at write-behind, has all data been written? */ 6501da177e4SLinus Torvalds if (!cmdstatp->remainder_valid || 6511da177e4SLinus Torvalds cmdstatp->uremainder64 == 0) 6521da177e4SLinus Torvalds retval = -ENOSPC; 6531da177e4SLinus Torvalds } 6541da177e4SLinus Torvalds if (retval == -EIO) 6551da177e4SLinus Torvalds STps->drv_block = -1; 6561da177e4SLinus Torvalds } 6571da177e4SLinus Torvalds STbuffer->writing = 0; 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds DEB(if (debugging && retval) 660b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, 661b30d8bcaSHannes Reinecke "Async write error %x, return value %d.\n", 662b30d8bcaSHannes Reinecke STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */ 6631da177e4SLinus Torvalds 6641da177e4SLinus Torvalds return retval; 6651da177e4SLinus Torvalds } 6661da177e4SLinus Torvalds 6671da177e4SLinus Torvalds 6681da177e4SLinus Torvalds /* Step over EOF if it has been inadvertently crossed (ioctl not used because 6691da177e4SLinus Torvalds it messes up the block number). */ 6701da177e4SLinus Torvalds static int cross_eof(struct scsi_tape * STp, int forward) 6711da177e4SLinus Torvalds { 6728b05b773SMike Christie struct st_request *SRpnt; 6731da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 6741da177e4SLinus Torvalds 6751da177e4SLinus Torvalds cmd[0] = SPACE; 6761da177e4SLinus Torvalds cmd[1] = 0x01; /* Space FileMarks */ 6771da177e4SLinus Torvalds if (forward) { 6781da177e4SLinus Torvalds cmd[2] = cmd[3] = 0; 6791da177e4SLinus Torvalds cmd[4] = 1; 6801da177e4SLinus Torvalds } else 6811da177e4SLinus Torvalds cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */ 6821da177e4SLinus Torvalds cmd[5] = 0; 6831da177e4SLinus Torvalds 684b30d8bcaSHannes Reinecke DEBC_printk(STp, "Stepping over filemark %s.\n", 685b30d8bcaSHannes Reinecke forward ? "forward" : "backward"); 6861da177e4SLinus Torvalds 68702ae2c0eSKai Makisara SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE, 68839ade4b1SFUJITA Tomonori STp->device->request_queue->rq_timeout, 68902ae2c0eSKai Makisara MAX_RETRIES, 1); 69002ae2c0eSKai Makisara if (!SRpnt) 69102ae2c0eSKai Makisara return (STp->buffer)->syscall_result; 69239ade4b1SFUJITA Tomonori 69302ae2c0eSKai Makisara st_release_request(SRpnt); 69402ae2c0eSKai Makisara SRpnt = NULL; 6951da177e4SLinus Torvalds 6961da177e4SLinus Torvalds if ((STp->buffer)->cmdstat.midlevel_result != 0) 697b30d8bcaSHannes Reinecke st_printk(KERN_ERR, STp, 698b30d8bcaSHannes Reinecke "Stepping over filemark %s failed.\n", 699b30d8bcaSHannes Reinecke forward ? "forward" : "backward"); 7001da177e4SLinus Torvalds 70102ae2c0eSKai Makisara return (STp->buffer)->syscall_result; 7021da177e4SLinus Torvalds } 7031da177e4SLinus Torvalds 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds /* Flush the write buffer (never need to write if variable blocksize). */ 7068ef8d594SAdrian Bunk static int st_flush_write_buffer(struct scsi_tape * STp) 7071da177e4SLinus Torvalds { 708786231afSKai Makisara int transfer, blks; 7091da177e4SLinus Torvalds int result; 7101da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 7118b05b773SMike Christie struct st_request *SRpnt; 7121da177e4SLinus Torvalds struct st_partstat *STps; 7131da177e4SLinus Torvalds 7141da177e4SLinus Torvalds result = write_behind_check(STp); 7151da177e4SLinus Torvalds if (result) 7161da177e4SLinus Torvalds return result; 7171da177e4SLinus Torvalds 7181da177e4SLinus Torvalds result = 0; 7191da177e4SLinus Torvalds if (STp->dirty == 1) { 7201da177e4SLinus Torvalds 721786231afSKai Makisara transfer = STp->buffer->buffer_bytes; 722b30d8bcaSHannes Reinecke DEBC_printk(STp, "Flushing %d bytes.\n", transfer); 7231da177e4SLinus Torvalds 7241da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 7251da177e4SLinus Torvalds cmd[0] = WRITE_6; 7261da177e4SLinus Torvalds cmd[1] = 1; 7271da177e4SLinus Torvalds blks = transfer / STp->block_size; 7281da177e4SLinus Torvalds cmd[2] = blks >> 16; 7291da177e4SLinus Torvalds cmd[3] = blks >> 8; 7301da177e4SLinus Torvalds cmd[4] = blks; 7311da177e4SLinus Torvalds 7321da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE, 733a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 734a02488edSJames Bottomley MAX_WRITE_RETRIES, 1); 7351da177e4SLinus Torvalds if (!SRpnt) 7361da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 7371da177e4SLinus Torvalds 7381da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 7391da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0) { 7401da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds if (cmdstatp->have_sense && !cmdstatp->deferred && 7431da177e4SLinus Torvalds (cmdstatp->flags & SENSE_EOM) && 7441da177e4SLinus Torvalds (cmdstatp->sense_hdr.sense_key == NO_SENSE || 7451da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) && 7461da177e4SLinus Torvalds (!cmdstatp->remainder_valid || 7471da177e4SLinus Torvalds cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */ 7481da177e4SLinus Torvalds STp->dirty = 0; 7491da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = 0; 7501da177e4SLinus Torvalds if (STps->drv_block >= 0) 7511da177e4SLinus Torvalds STps->drv_block += blks; 7521da177e4SLinus Torvalds result = (-ENOSPC); 7531da177e4SLinus Torvalds } else { 754b30d8bcaSHannes Reinecke st_printk(KERN_ERR, STp, "Error on flush.\n"); 7551da177e4SLinus Torvalds STps->drv_block = (-1); 7561da177e4SLinus Torvalds result = (-EIO); 7571da177e4SLinus Torvalds } 7581da177e4SLinus Torvalds } else { 7591da177e4SLinus Torvalds if (STps->drv_block >= 0) 7601da177e4SLinus Torvalds STps->drv_block += blks; 7611da177e4SLinus Torvalds STp->dirty = 0; 7621da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = 0; 7631da177e4SLinus Torvalds } 7648b05b773SMike Christie st_release_request(SRpnt); 7651da177e4SLinus Torvalds SRpnt = NULL; 7661da177e4SLinus Torvalds } 7671da177e4SLinus Torvalds return result; 7681da177e4SLinus Torvalds } 7691da177e4SLinus Torvalds 7701da177e4SLinus Torvalds 7711da177e4SLinus Torvalds /* Flush the tape buffer. The tape will be positioned correctly unless 7721da177e4SLinus Torvalds seek_next is true. */ 7731da177e4SLinus Torvalds static int flush_buffer(struct scsi_tape *STp, int seek_next) 7741da177e4SLinus Torvalds { 7751da177e4SLinus Torvalds int backspace, result; 7761da177e4SLinus Torvalds struct st_buffer *STbuffer; 7771da177e4SLinus Torvalds struct st_partstat *STps; 7781da177e4SLinus Torvalds 7791da177e4SLinus Torvalds STbuffer = STp->buffer; 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds /* 7821da177e4SLinus Torvalds * If there was a bus reset, block further access 7831da177e4SLinus Torvalds * to this device. 7841da177e4SLinus Torvalds */ 7851da177e4SLinus Torvalds if (STp->pos_unknown) 7861da177e4SLinus Torvalds return (-EIO); 7871da177e4SLinus Torvalds 7881da177e4SLinus Torvalds if (STp->ready != ST_READY) 7891da177e4SLinus Torvalds return 0; 7901da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 7911da177e4SLinus Torvalds if (STps->rw == ST_WRITING) /* Writing */ 7928ef8d594SAdrian Bunk return st_flush_write_buffer(STp); 7931da177e4SLinus Torvalds 7941da177e4SLinus Torvalds if (STp->block_size == 0) 7951da177e4SLinus Torvalds return 0; 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds backspace = ((STp->buffer)->buffer_bytes + 7981da177e4SLinus Torvalds (STp->buffer)->read_pointer) / STp->block_size - 7991da177e4SLinus Torvalds ((STp->buffer)->read_pointer + STp->block_size - 1) / 8001da177e4SLinus Torvalds STp->block_size; 8011da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = 0; 8021da177e4SLinus Torvalds (STp->buffer)->read_pointer = 0; 8031da177e4SLinus Torvalds result = 0; 8041da177e4SLinus Torvalds if (!seek_next) { 8051da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) { 8061da177e4SLinus Torvalds result = cross_eof(STp, 0); /* Back over the EOF hit */ 8071da177e4SLinus Torvalds if (!result) 8081da177e4SLinus Torvalds STps->eof = ST_NOEOF; 8091da177e4SLinus Torvalds else { 8101da177e4SLinus Torvalds if (STps->drv_file >= 0) 8111da177e4SLinus Torvalds STps->drv_file++; 8121da177e4SLinus Torvalds STps->drv_block = 0; 8131da177e4SLinus Torvalds } 8141da177e4SLinus Torvalds } 8151da177e4SLinus Torvalds if (!result && backspace > 0) 8161da177e4SLinus Torvalds result = st_int_ioctl(STp, MTBSR, backspace); 8171da177e4SLinus Torvalds } else if (STps->eof == ST_FM_HIT) { 8181da177e4SLinus Torvalds if (STps->drv_file >= 0) 8191da177e4SLinus Torvalds STps->drv_file++; 8201da177e4SLinus Torvalds STps->drv_block = 0; 8211da177e4SLinus Torvalds STps->eof = ST_NOEOF; 8221da177e4SLinus Torvalds } 8231da177e4SLinus Torvalds return result; 8241da177e4SLinus Torvalds 8251da177e4SLinus Torvalds } 8261da177e4SLinus Torvalds 8271da177e4SLinus Torvalds /* Set the mode parameters */ 8281da177e4SLinus Torvalds static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm) 8291da177e4SLinus Torvalds { 8301da177e4SLinus Torvalds int set_it = 0; 8311da177e4SLinus Torvalds unsigned long arg; 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds if (!STp->density_changed && 8341da177e4SLinus Torvalds STm->default_density >= 0 && 8351da177e4SLinus Torvalds STm->default_density != STp->density) { 8361da177e4SLinus Torvalds arg = STm->default_density; 8371da177e4SLinus Torvalds set_it = 1; 8381da177e4SLinus Torvalds } else 8391da177e4SLinus Torvalds arg = STp->density; 8401da177e4SLinus Torvalds arg <<= MT_ST_DENSITY_SHIFT; 8411da177e4SLinus Torvalds if (!STp->blksize_changed && 8421da177e4SLinus Torvalds STm->default_blksize >= 0 && 8431da177e4SLinus Torvalds STm->default_blksize != STp->block_size) { 8441da177e4SLinus Torvalds arg |= STm->default_blksize; 8451da177e4SLinus Torvalds set_it = 1; 8461da177e4SLinus Torvalds } else 8471da177e4SLinus Torvalds arg |= STp->block_size; 8481da177e4SLinus Torvalds if (set_it && 8491da177e4SLinus Torvalds st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) { 850b30d8bcaSHannes Reinecke st_printk(KERN_WARNING, STp, 851b30d8bcaSHannes Reinecke "Can't set default block size to %d bytes " 852b30d8bcaSHannes Reinecke "and density %x.\n", 853b30d8bcaSHannes Reinecke STm->default_blksize, STm->default_density); 8541da177e4SLinus Torvalds if (modes_defined) 8551da177e4SLinus Torvalds return (-EINVAL); 8561da177e4SLinus Torvalds } 8571da177e4SLinus Torvalds return 0; 8581da177e4SLinus Torvalds } 8591da177e4SLinus Torvalds 8601da177e4SLinus Torvalds 8618b05b773SMike Christie /* Lock or unlock the drive door. Don't use when st_request allocated. */ 8621da177e4SLinus Torvalds static int do_door_lock(struct scsi_tape * STp, int do_lock) 8631da177e4SLinus Torvalds { 8641da177e4SLinus Torvalds int retval, cmd; 8651da177e4SLinus Torvalds 8661da177e4SLinus Torvalds cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK; 867b30d8bcaSHannes Reinecke DEBC_printk(STp, "%socking drive door.\n", do_lock ? "L" : "Unl"); 8681da177e4SLinus Torvalds retval = scsi_ioctl(STp->device, cmd, NULL); 8691da177e4SLinus Torvalds if (!retval) { 8701da177e4SLinus Torvalds STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED; 8711da177e4SLinus Torvalds } 8721da177e4SLinus Torvalds else { 8731da177e4SLinus Torvalds STp->door_locked = ST_LOCK_FAILS; 8741da177e4SLinus Torvalds } 8751da177e4SLinus Torvalds return retval; 8761da177e4SLinus Torvalds } 8771da177e4SLinus Torvalds 8781da177e4SLinus Torvalds 8791da177e4SLinus Torvalds /* Set the internal state after reset */ 8801da177e4SLinus Torvalds static void reset_state(struct scsi_tape *STp) 8811da177e4SLinus Torvalds { 8821da177e4SLinus Torvalds int i; 8831da177e4SLinus Torvalds struct st_partstat *STps; 8841da177e4SLinus Torvalds 8851da177e4SLinus Torvalds STp->pos_unknown = 0; 8861da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 8871da177e4SLinus Torvalds STps = &(STp->ps[i]); 8881da177e4SLinus Torvalds STps->rw = ST_IDLE; 8891da177e4SLinus Torvalds STps->eof = ST_NOEOF; 8901da177e4SLinus Torvalds STps->at_sm = 0; 8911da177e4SLinus Torvalds STps->last_block_valid = 0; 8921da177e4SLinus Torvalds STps->drv_block = -1; 8931da177e4SLinus Torvalds STps->drv_file = -1; 8941da177e4SLinus Torvalds } 8951da177e4SLinus Torvalds if (STp->can_partitions) { 8961da177e4SLinus Torvalds STp->partition = find_partition(STp); 8971da177e4SLinus Torvalds if (STp->partition < 0) 8981da177e4SLinus Torvalds STp->partition = 0; 8991da177e4SLinus Torvalds STp->new_partition = STp->partition; 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds } 9021da177e4SLinus Torvalds 9031da177e4SLinus Torvalds /* Test if the drive is ready. Returns either one of the codes below or a negative system 9041da177e4SLinus Torvalds error code. */ 9051da177e4SLinus Torvalds #define CHKRES_READY 0 9061da177e4SLinus Torvalds #define CHKRES_NEW_SESSION 1 9071da177e4SLinus Torvalds #define CHKRES_NOT_READY 2 9081da177e4SLinus Torvalds #define CHKRES_NO_TAPE 3 9091da177e4SLinus Torvalds 9101da177e4SLinus Torvalds #define MAX_ATTENTIONS 10 9111da177e4SLinus Torvalds 9121da177e4SLinus Torvalds static int test_ready(struct scsi_tape *STp, int do_wait) 9131da177e4SLinus Torvalds { 9141da177e4SLinus Torvalds int attentions, waits, max_wait, scode; 9151da177e4SLinus Torvalds int retval = CHKRES_READY, new_session = 0; 9161da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 91702ae2c0eSKai Makisara struct st_request *SRpnt = NULL; 9181da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds max_wait = do_wait ? ST_BLOCK_SECONDS : 0; 9211da177e4SLinus Torvalds 9221da177e4SLinus Torvalds for (attentions=waits=0; ; ) { 9231da177e4SLinus Torvalds memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 9241da177e4SLinus Torvalds cmd[0] = TEST_UNIT_READY; 92502ae2c0eSKai Makisara SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, 92602ae2c0eSKai Makisara STp->long_timeout, MAX_READY_RETRIES, 1); 9271da177e4SLinus Torvalds 92802ae2c0eSKai Makisara if (!SRpnt) { 92902ae2c0eSKai Makisara retval = (STp->buffer)->syscall_result; 9301da177e4SLinus Torvalds break; 93102ae2c0eSKai Makisara } 9321da177e4SLinus Torvalds 9331da177e4SLinus Torvalds if (cmdstatp->have_sense) { 9341da177e4SLinus Torvalds 9351da177e4SLinus Torvalds scode = cmdstatp->sense_hdr.sense_key; 9361da177e4SLinus Torvalds 9371da177e4SLinus Torvalds if (scode == UNIT_ATTENTION) { /* New media? */ 9381da177e4SLinus Torvalds new_session = 1; 9391da177e4SLinus Torvalds if (attentions < MAX_ATTENTIONS) { 9401da177e4SLinus Torvalds attentions++; 9411da177e4SLinus Torvalds continue; 9421da177e4SLinus Torvalds } 9431da177e4SLinus Torvalds else { 9441da177e4SLinus Torvalds retval = (-EIO); 9451da177e4SLinus Torvalds break; 9461da177e4SLinus Torvalds } 9471da177e4SLinus Torvalds } 9481da177e4SLinus Torvalds 9491da177e4SLinus Torvalds if (scode == NOT_READY) { 9501da177e4SLinus Torvalds if (waits < max_wait) { 9511da177e4SLinus Torvalds if (msleep_interruptible(1000)) { 9521da177e4SLinus Torvalds retval = (-EINTR); 9531da177e4SLinus Torvalds break; 9541da177e4SLinus Torvalds } 9551da177e4SLinus Torvalds waits++; 9561da177e4SLinus Torvalds continue; 9571da177e4SLinus Torvalds } 9581da177e4SLinus Torvalds else { 9591da177e4SLinus Torvalds if ((STp->device)->scsi_level >= SCSI_2 && 9601da177e4SLinus Torvalds cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */ 9611da177e4SLinus Torvalds retval = CHKRES_NO_TAPE; 9621da177e4SLinus Torvalds else 9631da177e4SLinus Torvalds retval = CHKRES_NOT_READY; 9641da177e4SLinus Torvalds break; 9651da177e4SLinus Torvalds } 9661da177e4SLinus Torvalds } 9671da177e4SLinus Torvalds } 9681da177e4SLinus Torvalds 9691da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 9701da177e4SLinus Torvalds if (!retval) 9711da177e4SLinus Torvalds retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY; 9721da177e4SLinus Torvalds break; 9731da177e4SLinus Torvalds } 9741da177e4SLinus Torvalds 97502ae2c0eSKai Makisara if (SRpnt != NULL) 9768b05b773SMike Christie st_release_request(SRpnt); 9771da177e4SLinus Torvalds return retval; 9781da177e4SLinus Torvalds } 9791da177e4SLinus Torvalds 9801da177e4SLinus Torvalds 9811da177e4SLinus Torvalds /* See if the drive is ready and gather information about the tape. Return values: 9821da177e4SLinus Torvalds < 0 negative error code from errno.h 9831da177e4SLinus Torvalds 0 drive ready 9841da177e4SLinus Torvalds 1 drive not ready (possibly no tape) 9851da177e4SLinus Torvalds */ 9861da177e4SLinus Torvalds static int check_tape(struct scsi_tape *STp, struct file *filp) 9871da177e4SLinus Torvalds { 9881da177e4SLinus Torvalds int i, retval, new_session = 0, do_wait; 9891da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning; 9901da177e4SLinus Torvalds unsigned short st_flags = filp->f_flags; 9918b05b773SMike Christie struct st_request *SRpnt = NULL; 9921da177e4SLinus Torvalds struct st_modedef *STm; 9931da177e4SLinus Torvalds struct st_partstat *STps; 994496ad9aaSAl Viro struct inode *inode = file_inode(filp); 9951da177e4SLinus Torvalds int mode = TAPE_MODE(inode); 9961da177e4SLinus Torvalds 9971da177e4SLinus Torvalds STp->ready = ST_READY; 9981da177e4SLinus Torvalds 9991da177e4SLinus Torvalds if (mode != STp->current_mode) { 1000b30d8bcaSHannes Reinecke DEBC_printk(STp, "Mode change from %d to %d.\n", 1001b30d8bcaSHannes Reinecke STp->current_mode, mode); 10021da177e4SLinus Torvalds new_session = 1; 10031da177e4SLinus Torvalds STp->current_mode = mode; 10041da177e4SLinus Torvalds } 10051da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 10061da177e4SLinus Torvalds 10071da177e4SLinus Torvalds saved_cleaning = STp->cleaning_req; 10081da177e4SLinus Torvalds STp->cleaning_req = 0; 10091da177e4SLinus Torvalds 10101da177e4SLinus Torvalds do_wait = ((filp->f_flags & O_NONBLOCK) == 0); 10111da177e4SLinus Torvalds retval = test_ready(STp, do_wait); 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds if (retval < 0) 10141da177e4SLinus Torvalds goto err_out; 10151da177e4SLinus Torvalds 10161da177e4SLinus Torvalds if (retval == CHKRES_NEW_SESSION) { 10171da177e4SLinus Torvalds STp->pos_unknown = 0; 10181da177e4SLinus Torvalds STp->partition = STp->new_partition = 0; 10191da177e4SLinus Torvalds if (STp->can_partitions) 10201da177e4SLinus Torvalds STp->nbr_partitions = 1; /* This guess will be updated later 10211da177e4SLinus Torvalds if necessary */ 10221da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 10231da177e4SLinus Torvalds STps = &(STp->ps[i]); 10241da177e4SLinus Torvalds STps->rw = ST_IDLE; 10251da177e4SLinus Torvalds STps->eof = ST_NOEOF; 10261da177e4SLinus Torvalds STps->at_sm = 0; 10271da177e4SLinus Torvalds STps->last_block_valid = 0; 10281da177e4SLinus Torvalds STps->drv_block = 0; 10291da177e4SLinus Torvalds STps->drv_file = 0; 10301da177e4SLinus Torvalds } 10311da177e4SLinus Torvalds new_session = 1; 10321da177e4SLinus Torvalds } 10331da177e4SLinus Torvalds else { 10341da177e4SLinus Torvalds STp->cleaning_req |= saved_cleaning; 10351da177e4SLinus Torvalds 10361da177e4SLinus Torvalds if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) { 10371da177e4SLinus Torvalds if (retval == CHKRES_NO_TAPE) 10381da177e4SLinus Torvalds STp->ready = ST_NO_TAPE; 10391da177e4SLinus Torvalds else 10401da177e4SLinus Torvalds STp->ready = ST_NOT_READY; 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds STp->density = 0; /* Clear the erroneous "residue" */ 10431da177e4SLinus Torvalds STp->write_prot = 0; 10441da177e4SLinus Torvalds STp->block_size = 0; 10451da177e4SLinus Torvalds STp->ps[0].drv_file = STp->ps[0].drv_block = (-1); 10461da177e4SLinus Torvalds STp->partition = STp->new_partition = 0; 10471da177e4SLinus Torvalds STp->door_locked = ST_UNLOCKED; 10481da177e4SLinus Torvalds return CHKRES_NOT_READY; 10491da177e4SLinus Torvalds } 10501da177e4SLinus Torvalds } 10511da177e4SLinus Torvalds 10521da177e4SLinus Torvalds if (STp->omit_blklims) 10531da177e4SLinus Torvalds STp->min_block = STp->max_block = (-1); 10541da177e4SLinus Torvalds else { 10551da177e4SLinus Torvalds memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 10561da177e4SLinus Torvalds cmd[0] = READ_BLOCK_LIMITS; 10571da177e4SLinus Torvalds 105802ae2c0eSKai Makisara SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE, 1059a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 106002ae2c0eSKai Makisara MAX_READY_RETRIES, 1); 106102ae2c0eSKai Makisara if (!SRpnt) { 106202ae2c0eSKai Makisara retval = (STp->buffer)->syscall_result; 10631da177e4SLinus Torvalds goto err_out; 10641da177e4SLinus Torvalds } 10651da177e4SLinus Torvalds 10668b05b773SMike Christie if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) { 10671da177e4SLinus Torvalds STp->max_block = ((STp->buffer)->b_data[1] << 16) | 10681da177e4SLinus Torvalds ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3]; 10691da177e4SLinus Torvalds STp->min_block = ((STp->buffer)->b_data[4] << 8) | 10701da177e4SLinus Torvalds (STp->buffer)->b_data[5]; 10711da177e4SLinus Torvalds if ( DEB( debugging || ) !STp->inited) 1072b30d8bcaSHannes Reinecke st_printk(KERN_INFO, STp, 1073b30d8bcaSHannes Reinecke "Block limits %d - %d bytes.\n", 10741da177e4SLinus Torvalds STp->min_block, STp->max_block); 10751da177e4SLinus Torvalds } else { 10761da177e4SLinus Torvalds STp->min_block = STp->max_block = (-1); 1077b30d8bcaSHannes Reinecke DEBC_printk(STp, "Can't read block limits.\n"); 10781da177e4SLinus Torvalds } 10791da177e4SLinus Torvalds } 10801da177e4SLinus Torvalds 10811da177e4SLinus Torvalds memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 10821da177e4SLinus Torvalds cmd[0] = MODE_SENSE; 10831da177e4SLinus Torvalds cmd[4] = 12; 10841da177e4SLinus Torvalds 108502ae2c0eSKai Makisara SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE, 1086a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 108702ae2c0eSKai Makisara MAX_READY_RETRIES, 1); 108802ae2c0eSKai Makisara if (!SRpnt) { 108902ae2c0eSKai Makisara retval = (STp->buffer)->syscall_result; 10901da177e4SLinus Torvalds goto err_out; 10911da177e4SLinus Torvalds } 10921da177e4SLinus Torvalds 10931da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0) { 1094b30d8bcaSHannes Reinecke DEBC_printk(STp, "No Mode Sense.\n"); 10951da177e4SLinus Torvalds STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */ 10961da177e4SLinus Torvalds (STp->buffer)->syscall_result = 0; /* Prevent error propagation */ 10971da177e4SLinus Torvalds STp->drv_write_prot = 0; 10981da177e4SLinus Torvalds } else { 1099b30d8bcaSHannes Reinecke DEBC_printk(STp,"Mode sense. Length %d, " 1100b30d8bcaSHannes Reinecke "medium %x, WBS %x, BLL %d\n", 1101b30d8bcaSHannes Reinecke (STp->buffer)->b_data[0], 1102b30d8bcaSHannes Reinecke (STp->buffer)->b_data[1], 1103b30d8bcaSHannes Reinecke (STp->buffer)->b_data[2], 1104b30d8bcaSHannes Reinecke (STp->buffer)->b_data[3]); 11051da177e4SLinus Torvalds 11061da177e4SLinus Torvalds if ((STp->buffer)->b_data[3] >= 8) { 11071da177e4SLinus Torvalds STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7; 11081da177e4SLinus Torvalds STp->density = (STp->buffer)->b_data[4]; 11091da177e4SLinus Torvalds STp->block_size = (STp->buffer)->b_data[9] * 65536 + 11101da177e4SLinus Torvalds (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11]; 1111b30d8bcaSHannes Reinecke DEBC_printk(STp, "Density %x, tape length: %x, " 1112b30d8bcaSHannes Reinecke "drv buffer: %d\n", 1113b30d8bcaSHannes Reinecke STp->density, 1114b30d8bcaSHannes Reinecke (STp->buffer)->b_data[5] * 65536 + 1115b30d8bcaSHannes Reinecke (STp->buffer)->b_data[6] * 256 + 1116b30d8bcaSHannes Reinecke (STp->buffer)->b_data[7], 1117b30d8bcaSHannes Reinecke STp->drv_buffer); 11181da177e4SLinus Torvalds } 11191da177e4SLinus Torvalds STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0; 1120c743e44fSLee Duncan if (!STp->drv_buffer && STp->immediate_filemark) { 1121b30d8bcaSHannes Reinecke st_printk(KERN_WARNING, STp, 1122b30d8bcaSHannes Reinecke "non-buffered tape: disabling " 1123b30d8bcaSHannes Reinecke "writing immediate filemarks\n"); 1124c743e44fSLee Duncan STp->immediate_filemark = 0; 1125c743e44fSLee Duncan } 11261da177e4SLinus Torvalds } 11278b05b773SMike Christie st_release_request(SRpnt); 11281da177e4SLinus Torvalds SRpnt = NULL; 11291da177e4SLinus Torvalds STp->inited = 1; 11301da177e4SLinus Torvalds 11311da177e4SLinus Torvalds if (STp->block_size > 0) 11321da177e4SLinus Torvalds (STp->buffer)->buffer_blocks = 11331da177e4SLinus Torvalds (STp->buffer)->buffer_size / STp->block_size; 11341da177e4SLinus Torvalds else 11351da177e4SLinus Torvalds (STp->buffer)->buffer_blocks = 1; 11361da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0; 11371da177e4SLinus Torvalds 1138b30d8bcaSHannes Reinecke DEBC_printk(STp, "Block size: %d, buffer size: %d (%d blocks).\n", 11391da177e4SLinus Torvalds STp->block_size, (STp->buffer)->buffer_size, 1140b30d8bcaSHannes Reinecke (STp->buffer)->buffer_blocks); 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds if (STp->drv_write_prot) { 11431da177e4SLinus Torvalds STp->write_prot = 1; 11441da177e4SLinus Torvalds 1145b30d8bcaSHannes Reinecke DEBC_printk(STp, "Write protected\n"); 11461da177e4SLinus Torvalds 11471da177e4SLinus Torvalds if (do_wait && 11481da177e4SLinus Torvalds ((st_flags & O_ACCMODE) == O_WRONLY || 11491da177e4SLinus Torvalds (st_flags & O_ACCMODE) == O_RDWR)) { 11501da177e4SLinus Torvalds retval = (-EROFS); 11511da177e4SLinus Torvalds goto err_out; 11521da177e4SLinus Torvalds } 11531da177e4SLinus Torvalds } 11541da177e4SLinus Torvalds 11551da177e4SLinus Torvalds if (STp->can_partitions && STp->nbr_partitions < 1) { 11561da177e4SLinus Torvalds /* This code is reached when the device is opened for the first time 11571da177e4SLinus Torvalds after the driver has been initialized with tape in the drive and the 11581da177e4SLinus Torvalds partition support has been enabled. */ 1159b30d8bcaSHannes Reinecke DEBC_printk(STp, "Updating partition number in status.\n"); 11601da177e4SLinus Torvalds if ((STp->partition = find_partition(STp)) < 0) { 11611da177e4SLinus Torvalds retval = STp->partition; 11621da177e4SLinus Torvalds goto err_out; 11631da177e4SLinus Torvalds } 11641da177e4SLinus Torvalds STp->new_partition = STp->partition; 11651da177e4SLinus Torvalds STp->nbr_partitions = 1; /* This guess will be updated when necessary */ 11661da177e4SLinus Torvalds } 11671da177e4SLinus Torvalds 11681da177e4SLinus Torvalds if (new_session) { /* Change the drive parameters for the new mode */ 11691da177e4SLinus Torvalds STp->density_changed = STp->blksize_changed = 0; 11701da177e4SLinus Torvalds STp->compression_changed = 0; 11711da177e4SLinus Torvalds if (!(STm->defaults_for_writes) && 11721da177e4SLinus Torvalds (retval = set_mode_densblk(STp, STm)) < 0) 11731da177e4SLinus Torvalds goto err_out; 11741da177e4SLinus Torvalds 11751da177e4SLinus Torvalds if (STp->default_drvbuffer != 0xff) { 11761da177e4SLinus Torvalds if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer)) 1177b30d8bcaSHannes Reinecke st_printk(KERN_WARNING, STp, 1178b30d8bcaSHannes Reinecke "Can't set default drive " 1179b30d8bcaSHannes Reinecke "buffering to %d.\n", 1180b30d8bcaSHannes Reinecke STp->default_drvbuffer); 11811da177e4SLinus Torvalds } 11821da177e4SLinus Torvalds } 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds return CHKRES_READY; 11851da177e4SLinus Torvalds 11861da177e4SLinus Torvalds err_out: 11871da177e4SLinus Torvalds return retval; 11881da177e4SLinus Torvalds } 11891da177e4SLinus Torvalds 11901da177e4SLinus Torvalds 1191b3369c68SJonathan Corbet /* Open the device. Needs to take the BKL only because of incrementing the SCSI host 11921da177e4SLinus Torvalds module count. */ 11931da177e4SLinus Torvalds static int st_open(struct inode *inode, struct file *filp) 11941da177e4SLinus Torvalds { 11951da177e4SLinus Torvalds int i, retval = (-EIO); 119646a243f7SOliver Neukum int resumed = 0; 11971da177e4SLinus Torvalds struct scsi_tape *STp; 11981da177e4SLinus Torvalds struct st_partstat *STps; 11991da177e4SLinus Torvalds int dev = TAPE_NR(inode); 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds /* 12021da177e4SLinus Torvalds * We really want to do nonseekable_open(inode, filp); here, but some 12031da177e4SLinus Torvalds * versions of tar incorrectly call lseek on tapes and bail out if that 12041da177e4SLinus Torvalds * fails. So we disallow pread() and pwrite(), but permit lseeks. 12051da177e4SLinus Torvalds */ 12061da177e4SLinus Torvalds filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE); 12071da177e4SLinus Torvalds 1208b3369c68SJonathan Corbet if (!(STp = scsi_tape_get(dev))) { 1209f03a5670SKai Makisara return -ENXIO; 1210b3369c68SJonathan Corbet } 1211f03a5670SKai Makisara 12121da177e4SLinus Torvalds filp->private_data = STp; 12131da177e4SLinus Torvalds 12146c648d95SJeff Mahoney spin_lock(&st_use_lock); 12151da177e4SLinus Torvalds if (STp->in_use) { 12166c648d95SJeff Mahoney spin_unlock(&st_use_lock); 1217f03a5670SKai Makisara scsi_tape_put(STp); 1218b30d8bcaSHannes Reinecke DEBC_printk(STp, "Device already in use.\n"); 12191da177e4SLinus Torvalds return (-EBUSY); 12201da177e4SLinus Torvalds } 12211da177e4SLinus Torvalds 12221da177e4SLinus Torvalds STp->in_use = 1; 12236c648d95SJeff Mahoney spin_unlock(&st_use_lock); 12241da177e4SLinus Torvalds STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0; 12251da177e4SLinus Torvalds 122646a243f7SOliver Neukum if (scsi_autopm_get_device(STp->device) < 0) { 122746a243f7SOliver Neukum retval = -EIO; 122846a243f7SOliver Neukum goto err_out; 122946a243f7SOliver Neukum } 123046a243f7SOliver Neukum resumed = 1; 12311da177e4SLinus Torvalds if (!scsi_block_when_processing_errors(STp->device)) { 12321da177e4SLinus Torvalds retval = (-ENXIO); 12331da177e4SLinus Torvalds goto err_out; 12341da177e4SLinus Torvalds } 12351da177e4SLinus Torvalds 12361da177e4SLinus Torvalds /* See that we have at least a one page buffer available */ 12371da177e4SLinus Torvalds if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) { 1238b30d8bcaSHannes Reinecke st_printk(KERN_WARNING, STp, 1239b30d8bcaSHannes Reinecke "Can't allocate one page tape buffer.\n"); 12401da177e4SLinus Torvalds retval = (-EOVERFLOW); 12411da177e4SLinus Torvalds goto err_out; 12421da177e4SLinus Torvalds } 12431da177e4SLinus Torvalds 124440f6b36cSKai Makisara (STp->buffer)->cleared = 0; 12451da177e4SLinus Torvalds (STp->buffer)->writing = 0; 12461da177e4SLinus Torvalds (STp->buffer)->syscall_result = 0; 12471da177e4SLinus Torvalds 12481da177e4SLinus Torvalds STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY); 12491da177e4SLinus Torvalds 12501da177e4SLinus Torvalds STp->dirty = 0; 12511da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 12521da177e4SLinus Torvalds STps = &(STp->ps[i]); 12531da177e4SLinus Torvalds STps->rw = ST_IDLE; 12541da177e4SLinus Torvalds } 12559abe16c6SKai Makisara STp->try_dio_now = STp->try_dio; 12561da177e4SLinus Torvalds STp->recover_count = 0; 12571da177e4SLinus Torvalds DEB( STp->nbr_waits = STp->nbr_finished = 0; 1258deee13dfSKai Makisara STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; ) 12591da177e4SLinus Torvalds 12601da177e4SLinus Torvalds retval = check_tape(STp, filp); 12611da177e4SLinus Torvalds if (retval < 0) 12621da177e4SLinus Torvalds goto err_out; 12631da177e4SLinus Torvalds if ((filp->f_flags & O_NONBLOCK) == 0 && 12641da177e4SLinus Torvalds retval != CHKRES_READY) { 1265413f7327SKai Makisara if (STp->ready == NO_TAPE) 1266413f7327SKai Makisara retval = (-ENOMEDIUM); 1267413f7327SKai Makisara else 12681da177e4SLinus Torvalds retval = (-EIO); 12691da177e4SLinus Torvalds goto err_out; 12701da177e4SLinus Torvalds } 12711da177e4SLinus Torvalds return 0; 12721da177e4SLinus Torvalds 12731da177e4SLinus Torvalds err_out: 12741da177e4SLinus Torvalds normalize_buffer(STp->buffer); 12750644f539SHannes Reinecke spin_lock(&st_use_lock); 12761da177e4SLinus Torvalds STp->in_use = 0; 12770644f539SHannes Reinecke spin_unlock(&st_use_lock); 1278f03a5670SKai Makisara scsi_tape_put(STp); 127946a243f7SOliver Neukum if (resumed) 128046a243f7SOliver Neukum scsi_autopm_put_device(STp->device); 12811da177e4SLinus Torvalds return retval; 12821da177e4SLinus Torvalds 12831da177e4SLinus Torvalds } 12841da177e4SLinus Torvalds 12851da177e4SLinus Torvalds 12861da177e4SLinus Torvalds /* Flush the tape buffer before close */ 128775e1fcc0SMiklos Szeredi static int st_flush(struct file *filp, fl_owner_t id) 12881da177e4SLinus Torvalds { 12891da177e4SLinus Torvalds int result = 0, result2; 12901da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 12918b05b773SMike Christie struct st_request *SRpnt; 12921da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 12931da177e4SLinus Torvalds struct st_modedef *STm = &(STp->modes[STp->current_mode]); 12941da177e4SLinus Torvalds struct st_partstat *STps = &(STp->ps[STp->partition]); 12951da177e4SLinus Torvalds 12961da177e4SLinus Torvalds if (file_count(filp) > 1) 12971da177e4SLinus Torvalds return 0; 12981da177e4SLinus Torvalds 12991da177e4SLinus Torvalds if (STps->rw == ST_WRITING && !STp->pos_unknown) { 13008ef8d594SAdrian Bunk result = st_flush_write_buffer(STp); 13011da177e4SLinus Torvalds if (result != 0 && result != (-ENOSPC)) 13021da177e4SLinus Torvalds goto out; 13031da177e4SLinus Torvalds } 13041da177e4SLinus Torvalds 13051da177e4SLinus Torvalds if (STp->can_partitions && 13061da177e4SLinus Torvalds (result2 = switch_partition(STp)) < 0) { 1307b30d8bcaSHannes Reinecke DEBC_printk(STp, "switch_partition at close failed.\n"); 13081da177e4SLinus Torvalds if (result == 0) 13091da177e4SLinus Torvalds result = result2; 13101da177e4SLinus Torvalds goto out; 13111da177e4SLinus Torvalds } 13121da177e4SLinus Torvalds 13131da177e4SLinus Torvalds DEBC( if (STp->nbr_requests) 1314b30d8bcaSHannes Reinecke st_printk(KERN_DEBUG, STp, 1315b30d8bcaSHannes Reinecke "Number of r/w requests %d, dio used in %d, " 1316b30d8bcaSHannes Reinecke "pages %d.\n", STp->nbr_requests, STp->nbr_dio, 1317b30d8bcaSHannes Reinecke STp->nbr_pages)); 13181da177e4SLinus Torvalds 13191da177e4SLinus Torvalds if (STps->rw == ST_WRITING && !STp->pos_unknown) { 13201da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 13211da177e4SLinus Torvalds 1322b30d8bcaSHannes Reinecke #if DEBUG 1323b30d8bcaSHannes Reinecke DEBC_printk(STp, "Async write waits %d, finished %d.\n", 1324b30d8bcaSHannes Reinecke STp->nbr_waits, STp->nbr_finished); 1325b30d8bcaSHannes Reinecke #endif 13261da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 13271da177e4SLinus Torvalds cmd[0] = WRITE_FILEMARKS; 1328c743e44fSLee Duncan if (STp->immediate_filemark) 1329c743e44fSLee Duncan cmd[1] = 1; 13301da177e4SLinus Torvalds cmd[4] = 1 + STp->two_fm; 13311da177e4SLinus Torvalds 133202ae2c0eSKai Makisara SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE, 1333212cd8bfSFUJITA Tomonori STp->device->request_queue->rq_timeout, 133402ae2c0eSKai Makisara MAX_WRITE_RETRIES, 1); 133502ae2c0eSKai Makisara if (!SRpnt) { 133602ae2c0eSKai Makisara result = (STp->buffer)->syscall_result; 13371da177e4SLinus Torvalds goto out; 13381da177e4SLinus Torvalds } 13391da177e4SLinus Torvalds 13401da177e4SLinus Torvalds if (STp->buffer->syscall_result == 0 || 13411da177e4SLinus Torvalds (cmdstatp->have_sense && !cmdstatp->deferred && 13421da177e4SLinus Torvalds (cmdstatp->flags & SENSE_EOM) && 13431da177e4SLinus Torvalds (cmdstatp->sense_hdr.sense_key == NO_SENSE || 13441da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) && 13451da177e4SLinus Torvalds (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) { 13461da177e4SLinus Torvalds /* Write successful at EOM */ 13478b05b773SMike Christie st_release_request(SRpnt); 13481da177e4SLinus Torvalds SRpnt = NULL; 13491da177e4SLinus Torvalds if (STps->drv_file >= 0) 13501da177e4SLinus Torvalds STps->drv_file++; 13511da177e4SLinus Torvalds STps->drv_block = 0; 13521da177e4SLinus Torvalds if (STp->two_fm) 13531da177e4SLinus Torvalds cross_eof(STp, 0); 13541da177e4SLinus Torvalds STps->eof = ST_FM; 13551da177e4SLinus Torvalds } 13561da177e4SLinus Torvalds else { /* Write error */ 13578b05b773SMike Christie st_release_request(SRpnt); 13581da177e4SLinus Torvalds SRpnt = NULL; 1359b30d8bcaSHannes Reinecke st_printk(KERN_ERR, STp, 1360b30d8bcaSHannes Reinecke "Error on write filemark.\n"); 13611da177e4SLinus Torvalds if (result == 0) 13621da177e4SLinus Torvalds result = (-EIO); 13631da177e4SLinus Torvalds } 13641da177e4SLinus Torvalds 1365b30d8bcaSHannes Reinecke DEBC_printk(STp, "Buffer flushed, %d EOF(s) written\n", cmd[4]); 13661da177e4SLinus Torvalds } else if (!STp->rew_at_close) { 13671da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 13681da177e4SLinus Torvalds if (!STm->sysv || STps->rw != ST_READING) { 13691da177e4SLinus Torvalds if (STp->can_bsr) 13701da177e4SLinus Torvalds result = flush_buffer(STp, 0); 13711da177e4SLinus Torvalds else if (STps->eof == ST_FM_HIT) { 13721da177e4SLinus Torvalds result = cross_eof(STp, 0); 13731da177e4SLinus Torvalds if (result) { 13741da177e4SLinus Torvalds if (STps->drv_file >= 0) 13751da177e4SLinus Torvalds STps->drv_file++; 13761da177e4SLinus Torvalds STps->drv_block = 0; 13771da177e4SLinus Torvalds STps->eof = ST_FM; 13781da177e4SLinus Torvalds } else 13791da177e4SLinus Torvalds STps->eof = ST_NOEOF; 13801da177e4SLinus Torvalds } 13811da177e4SLinus Torvalds } else if ((STps->eof == ST_NOEOF && 13821da177e4SLinus Torvalds !(result = cross_eof(STp, 1))) || 13831da177e4SLinus Torvalds STps->eof == ST_FM_HIT) { 13841da177e4SLinus Torvalds if (STps->drv_file >= 0) 13851da177e4SLinus Torvalds STps->drv_file++; 13861da177e4SLinus Torvalds STps->drv_block = 0; 13871da177e4SLinus Torvalds STps->eof = ST_FM; 13881da177e4SLinus Torvalds } 13891da177e4SLinus Torvalds } 13901da177e4SLinus Torvalds 13911da177e4SLinus Torvalds out: 13921da177e4SLinus Torvalds if (STp->rew_at_close) { 13931da177e4SLinus Torvalds result2 = st_int_ioctl(STp, MTREW, 1); 13941da177e4SLinus Torvalds if (result == 0) 13951da177e4SLinus Torvalds result = result2; 13961da177e4SLinus Torvalds } 13971da177e4SLinus Torvalds return result; 13981da177e4SLinus Torvalds } 13991da177e4SLinus Torvalds 14001da177e4SLinus Torvalds 14011da177e4SLinus Torvalds /* Close the device and release it. BKL is not needed: this is the only thread 14021da177e4SLinus Torvalds accessing this tape. */ 14031da177e4SLinus Torvalds static int st_release(struct inode *inode, struct file *filp) 14041da177e4SLinus Torvalds { 14051da177e4SLinus Torvalds int result = 0; 14061da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds if (STp->door_locked == ST_LOCKED_AUTO) 14091da177e4SLinus Torvalds do_door_lock(STp, 0); 14101da177e4SLinus Torvalds 14111da177e4SLinus Torvalds normalize_buffer(STp->buffer); 14126c648d95SJeff Mahoney spin_lock(&st_use_lock); 14131da177e4SLinus Torvalds STp->in_use = 0; 14146c648d95SJeff Mahoney spin_unlock(&st_use_lock); 141546a243f7SOliver Neukum scsi_autopm_put_device(STp->device); 1416f03a5670SKai Makisara scsi_tape_put(STp); 14171da177e4SLinus Torvalds 14181da177e4SLinus Torvalds return result; 14191da177e4SLinus Torvalds } 14201da177e4SLinus Torvalds 14211da177e4SLinus Torvalds /* The checks common to both reading and writing */ 14221da177e4SLinus Torvalds static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count) 14231da177e4SLinus Torvalds { 14241da177e4SLinus Torvalds ssize_t retval = 0; 14251da177e4SLinus Torvalds 14261da177e4SLinus Torvalds /* 14271da177e4SLinus Torvalds * If we are in the middle of error recovery, don't let anyone 14281da177e4SLinus Torvalds * else try and use this device. Also, if error recovery fails, it 14291da177e4SLinus Torvalds * may try and take the device offline, in which case all further 14301da177e4SLinus Torvalds * access to the device is prohibited. 14311da177e4SLinus Torvalds */ 14321da177e4SLinus Torvalds if (!scsi_block_when_processing_errors(STp->device)) { 14331da177e4SLinus Torvalds retval = (-ENXIO); 14341da177e4SLinus Torvalds goto out; 14351da177e4SLinus Torvalds } 14361da177e4SLinus Torvalds 14371da177e4SLinus Torvalds if (STp->ready != ST_READY) { 14381da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 14391da177e4SLinus Torvalds retval = (-ENOMEDIUM); 14401da177e4SLinus Torvalds else 14411da177e4SLinus Torvalds retval = (-EIO); 14421da177e4SLinus Torvalds goto out; 14431da177e4SLinus Torvalds } 14441da177e4SLinus Torvalds 14451da177e4SLinus Torvalds if (! STp->modes[STp->current_mode].defined) { 14461da177e4SLinus Torvalds retval = (-ENXIO); 14471da177e4SLinus Torvalds goto out; 14481da177e4SLinus Torvalds } 14491da177e4SLinus Torvalds 14501da177e4SLinus Torvalds 14511da177e4SLinus Torvalds /* 14521da177e4SLinus Torvalds * If there was a bus reset, block further access 14531da177e4SLinus Torvalds * to this device. 14541da177e4SLinus Torvalds */ 14551da177e4SLinus Torvalds if (STp->pos_unknown) { 14561da177e4SLinus Torvalds retval = (-EIO); 14571da177e4SLinus Torvalds goto out; 14581da177e4SLinus Torvalds } 14591da177e4SLinus Torvalds 14601da177e4SLinus Torvalds if (count == 0) 14611da177e4SLinus Torvalds goto out; 14621da177e4SLinus Torvalds 14631da177e4SLinus Torvalds DEB( 14641da177e4SLinus Torvalds if (!STp->in_use) { 1465b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, 1466b30d8bcaSHannes Reinecke "Incorrect device.\n"); 14671da177e4SLinus Torvalds retval = (-EIO); 14681da177e4SLinus Torvalds goto out; 14691da177e4SLinus Torvalds } ) /* end DEB */ 14701da177e4SLinus Torvalds 14711da177e4SLinus Torvalds if (STp->can_partitions && 14721da177e4SLinus Torvalds (retval = switch_partition(STp)) < 0) 14731da177e4SLinus Torvalds goto out; 14741da177e4SLinus Torvalds 14751da177e4SLinus Torvalds if (STp->block_size == 0 && STp->max_block > 0 && 14761da177e4SLinus Torvalds (count < STp->min_block || count > STp->max_block)) { 14771da177e4SLinus Torvalds retval = (-EINVAL); 14781da177e4SLinus Torvalds goto out; 14791da177e4SLinus Torvalds } 14801da177e4SLinus Torvalds 14811da177e4SLinus Torvalds if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && 14821da177e4SLinus Torvalds !do_door_lock(STp, 1)) 14831da177e4SLinus Torvalds STp->door_locked = ST_LOCKED_AUTO; 14841da177e4SLinus Torvalds 14851da177e4SLinus Torvalds out: 14861da177e4SLinus Torvalds return retval; 14871da177e4SLinus Torvalds } 14881da177e4SLinus Torvalds 14891da177e4SLinus Torvalds 14901da177e4SLinus Torvalds static int setup_buffering(struct scsi_tape *STp, const char __user *buf, 14911da177e4SLinus Torvalds size_t count, int is_read) 14921da177e4SLinus Torvalds { 14931da177e4SLinus Torvalds int i, bufsize, retval = 0; 14941da177e4SLinus Torvalds struct st_buffer *STbp = STp->buffer; 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds if (is_read) 14979abe16c6SKai Makisara i = STp->try_dio_now && try_rdio; 14981da177e4SLinus Torvalds else 14999abe16c6SKai Makisara i = STp->try_dio_now && try_wdio; 15008b05b773SMike Christie 15011da177e4SLinus Torvalds if (i && ((unsigned long)buf & queue_dma_alignment( 15021da177e4SLinus Torvalds STp->device->request_queue)) == 0) { 15036620742fSFUJITA Tomonori i = sgl_map_user_pages(STbp, STbp->use_sg, (unsigned long)buf, 15046620742fSFUJITA Tomonori count, (is_read ? READ : WRITE)); 15051da177e4SLinus Torvalds if (i > 0) { 15061da177e4SLinus Torvalds STbp->do_dio = i; 15071da177e4SLinus Torvalds STbp->buffer_bytes = 0; /* can be used as transfer counter */ 15081da177e4SLinus Torvalds } 15091da177e4SLinus Torvalds else 15101da177e4SLinus Torvalds STbp->do_dio = 0; /* fall back to buffering with any error */ 15111da177e4SLinus Torvalds STbp->sg_segs = STbp->do_dio; 15121da177e4SLinus Torvalds DEB( 15131da177e4SLinus Torvalds if (STbp->do_dio) { 15141da177e4SLinus Torvalds STp->nbr_dio++; 15151da177e4SLinus Torvalds STp->nbr_pages += STbp->do_dio; 15161da177e4SLinus Torvalds } 15171da177e4SLinus Torvalds ) 15181da177e4SLinus Torvalds } else 15191da177e4SLinus Torvalds STbp->do_dio = 0; 15201da177e4SLinus Torvalds DEB( STp->nbr_requests++; ) 15211da177e4SLinus Torvalds 15221da177e4SLinus Torvalds if (!STbp->do_dio) { 15231da177e4SLinus Torvalds if (STp->block_size) 15241da177e4SLinus Torvalds bufsize = STp->block_size > st_fixed_buffer_size ? 15251da177e4SLinus Torvalds STp->block_size : st_fixed_buffer_size; 152640f6b36cSKai Makisara else { 15271da177e4SLinus Torvalds bufsize = count; 152840f6b36cSKai Makisara /* Make sure that data from previous user is not leaked even if 152940f6b36cSKai Makisara HBA does not return correct residual */ 153040f6b36cSKai Makisara if (is_read && STp->sili && !STbp->cleared) 153140f6b36cSKai Makisara clear_buffer(STbp); 153240f6b36cSKai Makisara } 153340f6b36cSKai Makisara 15341da177e4SLinus Torvalds if (bufsize > STbp->buffer_size && 15351da177e4SLinus Torvalds !enlarge_buffer(STbp, bufsize, STp->restr_dma)) { 1536b30d8bcaSHannes Reinecke st_printk(KERN_WARNING, STp, 1537b30d8bcaSHannes Reinecke "Can't allocate %d byte tape buffer.\n", 1538b30d8bcaSHannes Reinecke bufsize); 15391da177e4SLinus Torvalds retval = (-EOVERFLOW); 15401da177e4SLinus Torvalds goto out; 15411da177e4SLinus Torvalds } 15421da177e4SLinus Torvalds if (STp->block_size) 15431da177e4SLinus Torvalds STbp->buffer_blocks = bufsize / STp->block_size; 15441da177e4SLinus Torvalds } 15451da177e4SLinus Torvalds 15461da177e4SLinus Torvalds out: 15471da177e4SLinus Torvalds return retval; 15481da177e4SLinus Torvalds } 15491da177e4SLinus Torvalds 15501da177e4SLinus Torvalds 15511da177e4SLinus Torvalds /* Can be called more than once after each setup_buffer() */ 1552787926b1SKai Makisara static void release_buffering(struct scsi_tape *STp, int is_read) 15531da177e4SLinus Torvalds { 15541da177e4SLinus Torvalds struct st_buffer *STbp; 15551da177e4SLinus Torvalds 15561da177e4SLinus Torvalds STbp = STp->buffer; 15571da177e4SLinus Torvalds if (STbp->do_dio) { 15586620742fSFUJITA Tomonori sgl_unmap_user_pages(STbp, STbp->do_dio, is_read); 15591da177e4SLinus Torvalds STbp->do_dio = 0; 1560787926b1SKai Makisara STbp->sg_segs = 0; 15611da177e4SLinus Torvalds } 15621da177e4SLinus Torvalds } 15631da177e4SLinus Torvalds 15641da177e4SLinus Torvalds 15651da177e4SLinus Torvalds /* Write command */ 15661da177e4SLinus Torvalds static ssize_t 15671da177e4SLinus Torvalds st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) 15681da177e4SLinus Torvalds { 15691da177e4SLinus Torvalds ssize_t total; 15701da177e4SLinus Torvalds ssize_t i, do_count, blks, transfer; 15711da177e4SLinus Torvalds ssize_t retval; 15721da177e4SLinus Torvalds int undone, retry_eot = 0, scode; 15731da177e4SLinus Torvalds int async_write; 15741da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 15751da177e4SLinus Torvalds const char __user *b_point; 15768b05b773SMike Christie struct st_request *SRpnt = NULL; 15771da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 15781da177e4SLinus Torvalds struct st_modedef *STm; 15791da177e4SLinus Torvalds struct st_partstat *STps; 15801da177e4SLinus Torvalds struct st_buffer *STbp; 15811da177e4SLinus Torvalds 158228f85009SMatthias Kaehlcke if (mutex_lock_interruptible(&STp->lock)) 15831da177e4SLinus Torvalds return -ERESTARTSYS; 15841da177e4SLinus Torvalds 15851da177e4SLinus Torvalds retval = rw_checks(STp, filp, count); 15861da177e4SLinus Torvalds if (retval || count == 0) 15871da177e4SLinus Torvalds goto out; 15881da177e4SLinus Torvalds 15891da177e4SLinus Torvalds /* Write must be integral number of blocks */ 15901da177e4SLinus Torvalds if (STp->block_size != 0 && (count % STp->block_size) != 0) { 1591b30d8bcaSHannes Reinecke st_printk(KERN_WARNING, STp, 1592b30d8bcaSHannes Reinecke "Write not multiple of tape block size.\n"); 15931da177e4SLinus Torvalds retval = (-EINVAL); 15941da177e4SLinus Torvalds goto out; 15951da177e4SLinus Torvalds } 15961da177e4SLinus Torvalds 15971da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 15981da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 15991da177e4SLinus Torvalds 16001da177e4SLinus Torvalds if (STp->write_prot) { 16011da177e4SLinus Torvalds retval = (-EACCES); 16021da177e4SLinus Torvalds goto out; 16031da177e4SLinus Torvalds } 16041da177e4SLinus Torvalds 16051da177e4SLinus Torvalds 16061da177e4SLinus Torvalds if (STps->rw == ST_READING) { 16071da177e4SLinus Torvalds retval = flush_buffer(STp, 0); 16081da177e4SLinus Torvalds if (retval) 16091da177e4SLinus Torvalds goto out; 16101da177e4SLinus Torvalds STps->rw = ST_WRITING; 16111da177e4SLinus Torvalds } else if (STps->rw != ST_WRITING && 16121da177e4SLinus Torvalds STps->drv_file == 0 && STps->drv_block == 0) { 16131da177e4SLinus Torvalds if ((retval = set_mode_densblk(STp, STm)) < 0) 16141da177e4SLinus Torvalds goto out; 16151da177e4SLinus Torvalds if (STm->default_compression != ST_DONT_TOUCH && 16161da177e4SLinus Torvalds !(STp->compression_changed)) { 16171da177e4SLinus Torvalds if (st_compression(STp, (STm->default_compression == ST_YES))) { 1618b30d8bcaSHannes Reinecke st_printk(KERN_WARNING, STp, 1619b30d8bcaSHannes Reinecke "Can't set default compression.\n"); 16201da177e4SLinus Torvalds if (modes_defined) { 16211da177e4SLinus Torvalds retval = (-EINVAL); 16221da177e4SLinus Torvalds goto out; 16231da177e4SLinus Torvalds } 16241da177e4SLinus Torvalds } 16251da177e4SLinus Torvalds } 16261da177e4SLinus Torvalds } 16271da177e4SLinus Torvalds 16281da177e4SLinus Torvalds STbp = STp->buffer; 16291da177e4SLinus Torvalds i = write_behind_check(STp); 16301da177e4SLinus Torvalds if (i) { 16311da177e4SLinus Torvalds if (i == -ENOSPC) 16321da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 16331da177e4SLinus Torvalds else 16341da177e4SLinus Torvalds STps->eof = ST_EOM_ERROR; 16351da177e4SLinus Torvalds } 16361da177e4SLinus Torvalds 16371da177e4SLinus Torvalds if (STps->eof == ST_EOM_OK) { 16381da177e4SLinus Torvalds STps->eof = ST_EOD_1; /* allow next write */ 16391da177e4SLinus Torvalds retval = (-ENOSPC); 16401da177e4SLinus Torvalds goto out; 16411da177e4SLinus Torvalds } 16421da177e4SLinus Torvalds else if (STps->eof == ST_EOM_ERROR) { 16431da177e4SLinus Torvalds retval = (-EIO); 16441da177e4SLinus Torvalds goto out; 16451da177e4SLinus Torvalds } 16461da177e4SLinus Torvalds 16471da177e4SLinus Torvalds /* Check the buffer readability in cases where copy_user might catch 16481da177e4SLinus Torvalds the problems after some tape movement. */ 16491da177e4SLinus Torvalds if (STp->block_size != 0 && 16501da177e4SLinus Torvalds !STbp->do_dio && 16511da177e4SLinus Torvalds (copy_from_user(&i, buf, 1) != 0 || 16521da177e4SLinus Torvalds copy_from_user(&i, buf + count - 1, 1) != 0)) { 16531da177e4SLinus Torvalds retval = (-EFAULT); 16541da177e4SLinus Torvalds goto out; 16551da177e4SLinus Torvalds } 16561da177e4SLinus Torvalds 16571da177e4SLinus Torvalds retval = setup_buffering(STp, buf, count, 0); 16581da177e4SLinus Torvalds if (retval) 16591da177e4SLinus Torvalds goto out; 16601da177e4SLinus Torvalds 16611da177e4SLinus Torvalds total = count; 16621da177e4SLinus Torvalds 16631da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 16641da177e4SLinus Torvalds cmd[0] = WRITE_6; 16651da177e4SLinus Torvalds cmd[1] = (STp->block_size != 0); 16661da177e4SLinus Torvalds 16671da177e4SLinus Torvalds STps->rw = ST_WRITING; 16681da177e4SLinus Torvalds 16691da177e4SLinus Torvalds b_point = buf; 16701da177e4SLinus Torvalds while (count > 0 && !retry_eot) { 16711da177e4SLinus Torvalds 16721da177e4SLinus Torvalds if (STbp->do_dio) { 16731da177e4SLinus Torvalds do_count = count; 16741da177e4SLinus Torvalds } 16751da177e4SLinus Torvalds else { 16761da177e4SLinus Torvalds if (STp->block_size == 0) 16771da177e4SLinus Torvalds do_count = count; 16781da177e4SLinus Torvalds else { 16791da177e4SLinus Torvalds do_count = STbp->buffer_blocks * STp->block_size - 16801da177e4SLinus Torvalds STbp->buffer_bytes; 16811da177e4SLinus Torvalds if (do_count > count) 16821da177e4SLinus Torvalds do_count = count; 16831da177e4SLinus Torvalds } 16841da177e4SLinus Torvalds 16851da177e4SLinus Torvalds i = append_to_buffer(b_point, STbp, do_count); 16861da177e4SLinus Torvalds if (i) { 16871da177e4SLinus Torvalds retval = i; 16881da177e4SLinus Torvalds goto out; 16891da177e4SLinus Torvalds } 16901da177e4SLinus Torvalds } 16911da177e4SLinus Torvalds count -= do_count; 16921da177e4SLinus Torvalds b_point += do_count; 16931da177e4SLinus Torvalds 16941da177e4SLinus Torvalds async_write = STp->block_size == 0 && !STbp->do_dio && 16951da177e4SLinus Torvalds STm->do_async_writes && STps->eof < ST_EOM_OK; 16961da177e4SLinus Torvalds 16971da177e4SLinus Torvalds if (STp->block_size != 0 && STm->do_buffer_writes && 16989abe16c6SKai Makisara !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK && 16991da177e4SLinus Torvalds STbp->buffer_bytes < STbp->buffer_size) { 17001da177e4SLinus Torvalds STp->dirty = 1; 17011da177e4SLinus Torvalds /* Don't write a buffer that is not full enough. */ 17021da177e4SLinus Torvalds if (!async_write && count == 0) 17031da177e4SLinus Torvalds break; 17041da177e4SLinus Torvalds } 17051da177e4SLinus Torvalds 17061da177e4SLinus Torvalds retry_write: 17071da177e4SLinus Torvalds if (STp->block_size == 0) 17081da177e4SLinus Torvalds blks = transfer = do_count; 17091da177e4SLinus Torvalds else { 17101da177e4SLinus Torvalds if (!STbp->do_dio) 17111da177e4SLinus Torvalds blks = STbp->buffer_bytes; 17121da177e4SLinus Torvalds else 17131da177e4SLinus Torvalds blks = do_count; 17141da177e4SLinus Torvalds blks /= STp->block_size; 17151da177e4SLinus Torvalds transfer = blks * STp->block_size; 17161da177e4SLinus Torvalds } 17171da177e4SLinus Torvalds cmd[2] = blks >> 16; 17181da177e4SLinus Torvalds cmd[3] = blks >> 8; 17191da177e4SLinus Torvalds cmd[4] = blks; 17201da177e4SLinus Torvalds 17211da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE, 1722a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 1723a02488edSJames Bottomley MAX_WRITE_RETRIES, !async_write); 17241da177e4SLinus Torvalds if (!SRpnt) { 17251da177e4SLinus Torvalds retval = STbp->syscall_result; 17261da177e4SLinus Torvalds goto out; 17271da177e4SLinus Torvalds } 17288b05b773SMike Christie if (async_write && !STbp->syscall_result) { 17291da177e4SLinus Torvalds STbp->writing = transfer; 17301da177e4SLinus Torvalds STp->dirty = !(STbp->writing == 17311da177e4SLinus Torvalds STbp->buffer_bytes); 17321da177e4SLinus Torvalds SRpnt = NULL; /* Prevent releasing this request! */ 17331da177e4SLinus Torvalds DEB( STp->write_pending = 1; ) 17341da177e4SLinus Torvalds break; 17351da177e4SLinus Torvalds } 17361da177e4SLinus Torvalds 17371da177e4SLinus Torvalds if (STbp->syscall_result != 0) { 17381da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 17391da177e4SLinus Torvalds 1740b30d8bcaSHannes Reinecke DEBC_printk(STp, "Error on write:\n"); 17411da177e4SLinus Torvalds if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) { 17421da177e4SLinus Torvalds scode = cmdstatp->sense_hdr.sense_key; 17431da177e4SLinus Torvalds if (cmdstatp->remainder_valid) 17441da177e4SLinus Torvalds undone = (int)cmdstatp->uremainder64; 17451da177e4SLinus Torvalds else if (STp->block_size == 0 && 17461da177e4SLinus Torvalds scode == VOLUME_OVERFLOW) 17471da177e4SLinus Torvalds undone = transfer; 17481da177e4SLinus Torvalds else 17491da177e4SLinus Torvalds undone = 0; 17501da177e4SLinus Torvalds if (STp->block_size != 0) 17511da177e4SLinus Torvalds undone *= STp->block_size; 17521da177e4SLinus Torvalds if (undone <= do_count) { 17531da177e4SLinus Torvalds /* Only data from this write is not written */ 17541da177e4SLinus Torvalds count += undone; 1755626dcb1eSKai Makisara b_point -= undone; 17561da177e4SLinus Torvalds do_count -= undone; 17571da177e4SLinus Torvalds if (STp->block_size) 17581da177e4SLinus Torvalds blks = (transfer - undone) / STp->block_size; 17591da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 17601da177e4SLinus Torvalds /* Continue in fixed block mode if all written 17611da177e4SLinus Torvalds in this request but still something left to write 17621da177e4SLinus Torvalds (retval left to zero) 17631da177e4SLinus Torvalds */ 17641da177e4SLinus Torvalds if (STp->block_size == 0 || 17651da177e4SLinus Torvalds undone > 0 || count == 0) 17661da177e4SLinus Torvalds retval = (-ENOSPC); /* EOM within current request */ 1767b30d8bcaSHannes Reinecke DEBC_printk(STp, "EOM with %d " 1768b30d8bcaSHannes Reinecke "bytes unwritten.\n", 1769b30d8bcaSHannes Reinecke (int)count); 17701da177e4SLinus Torvalds } else { 17711da177e4SLinus Torvalds /* EOT within data buffered earlier (possible only 17721da177e4SLinus Torvalds in fixed block mode without direct i/o) */ 17731da177e4SLinus Torvalds if (!retry_eot && !cmdstatp->deferred && 17741da177e4SLinus Torvalds (scode == NO_SENSE || scode == RECOVERED_ERROR)) { 17751da177e4SLinus Torvalds move_buffer_data(STp->buffer, transfer - undone); 17761da177e4SLinus Torvalds retry_eot = 1; 17771da177e4SLinus Torvalds if (STps->drv_block >= 0) { 17781da177e4SLinus Torvalds STps->drv_block += (transfer - undone) / 17791da177e4SLinus Torvalds STp->block_size; 17801da177e4SLinus Torvalds } 17811da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 1782b30d8bcaSHannes Reinecke DEBC_printk(STp, "Retry " 1783b30d8bcaSHannes Reinecke "write of %d " 1784b30d8bcaSHannes Reinecke "bytes at EOM.\n", 1785b30d8bcaSHannes Reinecke STp->buffer->buffer_bytes); 17861da177e4SLinus Torvalds goto retry_write; 17871da177e4SLinus Torvalds } 17881da177e4SLinus Torvalds else { 17891da177e4SLinus Torvalds /* Either error within data buffered by driver or 17901da177e4SLinus Torvalds failed retry */ 17911da177e4SLinus Torvalds count -= do_count; 17921da177e4SLinus Torvalds blks = do_count = 0; 17931da177e4SLinus Torvalds STps->eof = ST_EOM_ERROR; 17941da177e4SLinus Torvalds STps->drv_block = (-1); /* Too cautious? */ 17951da177e4SLinus Torvalds retval = (-EIO); /* EOM for old data */ 1796b30d8bcaSHannes Reinecke DEBC_printk(STp, "EOM with " 1797b30d8bcaSHannes Reinecke "lost data.\n"); 17981da177e4SLinus Torvalds } 17991da177e4SLinus Torvalds } 18001da177e4SLinus Torvalds } else { 18011da177e4SLinus Torvalds count += do_count; 18021da177e4SLinus Torvalds STps->drv_block = (-1); /* Too cautious? */ 18038b05b773SMike Christie retval = STbp->syscall_result; 18041da177e4SLinus Torvalds } 18051da177e4SLinus Torvalds 18061da177e4SLinus Torvalds } 18071da177e4SLinus Torvalds 18081da177e4SLinus Torvalds if (STps->drv_block >= 0) { 18091da177e4SLinus Torvalds if (STp->block_size == 0) 18101da177e4SLinus Torvalds STps->drv_block += (do_count > 0); 18111da177e4SLinus Torvalds else 18121da177e4SLinus Torvalds STps->drv_block += blks; 18131da177e4SLinus Torvalds } 18141da177e4SLinus Torvalds 18151da177e4SLinus Torvalds STbp->buffer_bytes = 0; 18161da177e4SLinus Torvalds STp->dirty = 0; 18171da177e4SLinus Torvalds 18181da177e4SLinus Torvalds if (retval || retry_eot) { 18191da177e4SLinus Torvalds if (count < total) 18201da177e4SLinus Torvalds retval = total - count; 18211da177e4SLinus Torvalds goto out; 18221da177e4SLinus Torvalds } 18231da177e4SLinus Torvalds } 18241da177e4SLinus Torvalds 18251da177e4SLinus Torvalds if (STps->eof == ST_EOD_1) 18261da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 18271da177e4SLinus Torvalds else if (STps->eof != ST_EOM_OK) 18281da177e4SLinus Torvalds STps->eof = ST_NOEOF; 18291da177e4SLinus Torvalds retval = total - count; 18301da177e4SLinus Torvalds 18311da177e4SLinus Torvalds out: 18321da177e4SLinus Torvalds if (SRpnt != NULL) 18338b05b773SMike Christie st_release_request(SRpnt); 1834787926b1SKai Makisara release_buffering(STp, 0); 183528f85009SMatthias Kaehlcke mutex_unlock(&STp->lock); 18361da177e4SLinus Torvalds 18371da177e4SLinus Torvalds return retval; 18381da177e4SLinus Torvalds } 18391da177e4SLinus Torvalds 18401da177e4SLinus Torvalds /* Read data from the tape. Returns zero in the normal case, one if the 18411da177e4SLinus Torvalds eof status has changed, and the negative error code in case of a 18421da177e4SLinus Torvalds fatal error. Otherwise updates the buffer and the eof state. 18431da177e4SLinus Torvalds 18441da177e4SLinus Torvalds Does release user buffer mapping if it is set. 18451da177e4SLinus Torvalds */ 18461da177e4SLinus Torvalds static long read_tape(struct scsi_tape *STp, long count, 18478b05b773SMike Christie struct st_request ** aSRpnt) 18481da177e4SLinus Torvalds { 18491da177e4SLinus Torvalds int transfer, blks, bytes; 18501da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 18518b05b773SMike Christie struct st_request *SRpnt; 18521da177e4SLinus Torvalds struct st_modedef *STm; 18531da177e4SLinus Torvalds struct st_partstat *STps; 18541da177e4SLinus Torvalds struct st_buffer *STbp; 18551da177e4SLinus Torvalds int retval = 0; 18561da177e4SLinus Torvalds 18571da177e4SLinus Torvalds if (count == 0) 18581da177e4SLinus Torvalds return 0; 18591da177e4SLinus Torvalds 18601da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 18611da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 18621da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) 18631da177e4SLinus Torvalds return 1; 18641da177e4SLinus Torvalds STbp = STp->buffer; 18651da177e4SLinus Torvalds 18661da177e4SLinus Torvalds if (STp->block_size == 0) 18671da177e4SLinus Torvalds blks = bytes = count; 18681da177e4SLinus Torvalds else { 18699abe16c6SKai Makisara if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) { 18701da177e4SLinus Torvalds blks = (STp->buffer)->buffer_blocks; 18711da177e4SLinus Torvalds bytes = blks * STp->block_size; 18721da177e4SLinus Torvalds } else { 18731da177e4SLinus Torvalds bytes = count; 18741da177e4SLinus Torvalds if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size) 18751da177e4SLinus Torvalds bytes = (STp->buffer)->buffer_size; 18761da177e4SLinus Torvalds blks = bytes / STp->block_size; 18771da177e4SLinus Torvalds bytes = blks * STp->block_size; 18781da177e4SLinus Torvalds } 18791da177e4SLinus Torvalds } 18801da177e4SLinus Torvalds 18811da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 18821da177e4SLinus Torvalds cmd[0] = READ_6; 18831da177e4SLinus Torvalds cmd[1] = (STp->block_size != 0); 188440f6b36cSKai Makisara if (!cmd[1] && STp->sili) 188540f6b36cSKai Makisara cmd[1] |= 2; 18861da177e4SLinus Torvalds cmd[2] = blks >> 16; 18871da177e4SLinus Torvalds cmd[3] = blks >> 8; 18881da177e4SLinus Torvalds cmd[4] = blks; 18891da177e4SLinus Torvalds 18901da177e4SLinus Torvalds SRpnt = *aSRpnt; 18911da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE, 1892a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 1893a02488edSJames Bottomley MAX_RETRIES, 1); 1894787926b1SKai Makisara release_buffering(STp, 1); 18951da177e4SLinus Torvalds *aSRpnt = SRpnt; 18961da177e4SLinus Torvalds if (!SRpnt) 18971da177e4SLinus Torvalds return STbp->syscall_result; 18981da177e4SLinus Torvalds 18991da177e4SLinus Torvalds STbp->read_pointer = 0; 19001da177e4SLinus Torvalds STps->at_sm = 0; 19011da177e4SLinus Torvalds 19021da177e4SLinus Torvalds /* Something to check */ 19031da177e4SLinus Torvalds if (STbp->syscall_result) { 19041da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 19051da177e4SLinus Torvalds 19061da177e4SLinus Torvalds retval = 1; 1907b30d8bcaSHannes Reinecke DEBC_printk(STp, 1908b30d8bcaSHannes Reinecke "Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n", 19098b05b773SMike Christie SRpnt->sense[0], SRpnt->sense[1], 19108b05b773SMike Christie SRpnt->sense[2], SRpnt->sense[3], 19118b05b773SMike Christie SRpnt->sense[4], SRpnt->sense[5], 1912b30d8bcaSHannes Reinecke SRpnt->sense[6], SRpnt->sense[7]); 19131da177e4SLinus Torvalds if (cmdstatp->have_sense) { 19141da177e4SLinus Torvalds 19151da177e4SLinus Torvalds if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK) 19161da177e4SLinus Torvalds cmdstatp->flags &= 0xcf; /* No need for EOM in this case */ 19171da177e4SLinus Torvalds 19181da177e4SLinus Torvalds if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */ 19191da177e4SLinus Torvalds /* Compute the residual count */ 19201da177e4SLinus Torvalds if (cmdstatp->remainder_valid) 19211da177e4SLinus Torvalds transfer = (int)cmdstatp->uremainder64; 19221da177e4SLinus Torvalds else 19231da177e4SLinus Torvalds transfer = 0; 19241da177e4SLinus Torvalds if (STp->block_size == 0 && 19251da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR) 19261da177e4SLinus Torvalds transfer = bytes; 19271da177e4SLinus Torvalds 19281da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_ILI) { /* ILI */ 1929b30d8bcaSHannes Reinecke if (STp->block_size == 0 && 1930b30d8bcaSHannes Reinecke transfer < 0) { 1931b30d8bcaSHannes Reinecke st_printk(KERN_NOTICE, STp, 1932b30d8bcaSHannes Reinecke "Failed to read %d " 1933b30d8bcaSHannes Reinecke "byte block with %d " 1934b30d8bcaSHannes Reinecke "byte transfer.\n", 1935b30d8bcaSHannes Reinecke bytes - transfer, 1936b30d8bcaSHannes Reinecke bytes); 19371da177e4SLinus Torvalds if (STps->drv_block >= 0) 19381da177e4SLinus Torvalds STps->drv_block += 1; 19391da177e4SLinus Torvalds STbp->buffer_bytes = 0; 19401da177e4SLinus Torvalds return (-ENOMEM); 1941b30d8bcaSHannes Reinecke } else if (STp->block_size == 0) { 19421da177e4SLinus Torvalds STbp->buffer_bytes = bytes - transfer; 19431da177e4SLinus Torvalds } else { 19448b05b773SMike Christie st_release_request(SRpnt); 19451da177e4SLinus Torvalds SRpnt = *aSRpnt = NULL; 19461da177e4SLinus Torvalds if (transfer == blks) { /* We did not get anything, error */ 1947b30d8bcaSHannes Reinecke st_printk(KERN_NOTICE, STp, 1948b30d8bcaSHannes Reinecke "Incorrect " 1949b30d8bcaSHannes Reinecke "block size.\n"); 19501da177e4SLinus Torvalds if (STps->drv_block >= 0) 19511da177e4SLinus Torvalds STps->drv_block += blks - transfer + 1; 19521da177e4SLinus Torvalds st_int_ioctl(STp, MTBSR, 1); 19531da177e4SLinus Torvalds return (-EIO); 19541da177e4SLinus Torvalds } 19551da177e4SLinus Torvalds /* We have some data, deliver it */ 19561da177e4SLinus Torvalds STbp->buffer_bytes = (blks - transfer) * 19571da177e4SLinus Torvalds STp->block_size; 1958b30d8bcaSHannes Reinecke DEBC_printk(STp, "ILI but " 1959b30d8bcaSHannes Reinecke "enough data " 1960b30d8bcaSHannes Reinecke "received %ld " 1961b30d8bcaSHannes Reinecke "%d.\n", count, 1962b30d8bcaSHannes Reinecke STbp->buffer_bytes); 19631da177e4SLinus Torvalds if (STps->drv_block >= 0) 19641da177e4SLinus Torvalds STps->drv_block += 1; 19651da177e4SLinus Torvalds if (st_int_ioctl(STp, MTBSR, 1)) 19661da177e4SLinus Torvalds return (-EIO); 19671da177e4SLinus Torvalds } 19681da177e4SLinus Torvalds } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */ 19691da177e4SLinus Torvalds if (STps->eof != ST_FM_HIT) 19701da177e4SLinus Torvalds STps->eof = ST_FM_HIT; 19711da177e4SLinus Torvalds else 19721da177e4SLinus Torvalds STps->eof = ST_EOD_2; 19731da177e4SLinus Torvalds if (STp->block_size == 0) 19741da177e4SLinus Torvalds STbp->buffer_bytes = 0; 19751da177e4SLinus Torvalds else 19761da177e4SLinus Torvalds STbp->buffer_bytes = 19771da177e4SLinus Torvalds bytes - transfer * STp->block_size; 1978b30d8bcaSHannes Reinecke DEBC_printk(STp, "EOF detected (%d " 1979b30d8bcaSHannes Reinecke "bytes read).\n", 1980b30d8bcaSHannes Reinecke STbp->buffer_bytes); 19811da177e4SLinus Torvalds } else if (cmdstatp->flags & SENSE_EOM) { 19821da177e4SLinus Torvalds if (STps->eof == ST_FM) 19831da177e4SLinus Torvalds STps->eof = ST_EOD_1; 19841da177e4SLinus Torvalds else 19851da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 19861da177e4SLinus Torvalds if (STp->block_size == 0) 19871da177e4SLinus Torvalds STbp->buffer_bytes = bytes - transfer; 19881da177e4SLinus Torvalds else 19891da177e4SLinus Torvalds STbp->buffer_bytes = 19901da177e4SLinus Torvalds bytes - transfer * STp->block_size; 19911da177e4SLinus Torvalds 1992b30d8bcaSHannes Reinecke DEBC_printk(STp, "EOM detected (%d " 1993b30d8bcaSHannes Reinecke "bytes read).\n", 1994b30d8bcaSHannes Reinecke STbp->buffer_bytes); 19951da177e4SLinus Torvalds } 19961da177e4SLinus Torvalds } 19971da177e4SLinus Torvalds /* end of EOF, EOM, ILI test */ 19981da177e4SLinus Torvalds else { /* nonzero sense key */ 1999b30d8bcaSHannes Reinecke DEBC_printk(STp, "Tape error while reading.\n"); 20001da177e4SLinus Torvalds STps->drv_block = (-1); 20011da177e4SLinus Torvalds if (STps->eof == ST_FM && 20021da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == BLANK_CHECK) { 2003b30d8bcaSHannes Reinecke DEBC_printk(STp, "Zero returned for " 2004b30d8bcaSHannes Reinecke "first BLANK CHECK " 2005b30d8bcaSHannes Reinecke "after EOF.\n"); 20061da177e4SLinus Torvalds STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */ 20071da177e4SLinus Torvalds } else /* Some other extended sense code */ 20081da177e4SLinus Torvalds retval = (-EIO); 20091da177e4SLinus Torvalds } 20101da177e4SLinus Torvalds 20111da177e4SLinus Torvalds if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */ 20121da177e4SLinus Torvalds STbp->buffer_bytes = 0; 20131da177e4SLinus Torvalds } 20141da177e4SLinus Torvalds /* End of extended sense test */ 20151da177e4SLinus Torvalds else { /* Non-extended sense */ 20161da177e4SLinus Torvalds retval = STbp->syscall_result; 20171da177e4SLinus Torvalds } 20181da177e4SLinus Torvalds 20191da177e4SLinus Torvalds } 20201da177e4SLinus Torvalds /* End of error handling */ 202140f6b36cSKai Makisara else { /* Read successful */ 20221da177e4SLinus Torvalds STbp->buffer_bytes = bytes; 202340f6b36cSKai Makisara if (STp->sili) /* In fixed block mode residual is always zero here */ 202440f6b36cSKai Makisara STbp->buffer_bytes -= STp->buffer->cmdstat.residual; 202540f6b36cSKai Makisara } 20261da177e4SLinus Torvalds 20271da177e4SLinus Torvalds if (STps->drv_block >= 0) { 20281da177e4SLinus Torvalds if (STp->block_size == 0) 20291da177e4SLinus Torvalds STps->drv_block++; 20301da177e4SLinus Torvalds else 20311da177e4SLinus Torvalds STps->drv_block += STbp->buffer_bytes / STp->block_size; 20321da177e4SLinus Torvalds } 20331da177e4SLinus Torvalds return retval; 20341da177e4SLinus Torvalds } 20351da177e4SLinus Torvalds 20361da177e4SLinus Torvalds 20371da177e4SLinus Torvalds /* Read command */ 20381da177e4SLinus Torvalds static ssize_t 20391da177e4SLinus Torvalds st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos) 20401da177e4SLinus Torvalds { 20411da177e4SLinus Torvalds ssize_t total; 20421da177e4SLinus Torvalds ssize_t retval = 0; 20431da177e4SLinus Torvalds ssize_t i, transfer; 20441da177e4SLinus Torvalds int special, do_dio = 0; 20458b05b773SMike Christie struct st_request *SRpnt = NULL; 20461da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 20471da177e4SLinus Torvalds struct st_modedef *STm; 20481da177e4SLinus Torvalds struct st_partstat *STps; 20491da177e4SLinus Torvalds struct st_buffer *STbp = STp->buffer; 20501da177e4SLinus Torvalds 205128f85009SMatthias Kaehlcke if (mutex_lock_interruptible(&STp->lock)) 20521da177e4SLinus Torvalds return -ERESTARTSYS; 20531da177e4SLinus Torvalds 20541da177e4SLinus Torvalds retval = rw_checks(STp, filp, count); 20551da177e4SLinus Torvalds if (retval || count == 0) 20561da177e4SLinus Torvalds goto out; 20571da177e4SLinus Torvalds 20581da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 20599abe16c6SKai Makisara if (STp->block_size != 0 && (count % STp->block_size) != 0) { 20609abe16c6SKai Makisara if (!STm->do_read_ahead) { 20611da177e4SLinus Torvalds retval = (-EINVAL); /* Read must be integral number of blocks */ 20621da177e4SLinus Torvalds goto out; 20631da177e4SLinus Torvalds } 20649abe16c6SKai Makisara STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */ 20659abe16c6SKai Makisara } 20661da177e4SLinus Torvalds 20671da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 20681da177e4SLinus Torvalds if (STps->rw == ST_WRITING) { 20691da177e4SLinus Torvalds retval = flush_buffer(STp, 0); 20701da177e4SLinus Torvalds if (retval) 20711da177e4SLinus Torvalds goto out; 20721da177e4SLinus Torvalds STps->rw = ST_READING; 20731da177e4SLinus Torvalds } 20741da177e4SLinus Torvalds DEB( 20751da177e4SLinus Torvalds if (debugging && STps->eof != ST_NOEOF) 2076b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, 2077b30d8bcaSHannes Reinecke "EOF/EOM flag up (%d). Bytes %d\n", 20781da177e4SLinus Torvalds STps->eof, STbp->buffer_bytes); 20791da177e4SLinus Torvalds ) /* end DEB */ 20801da177e4SLinus Torvalds 20811da177e4SLinus Torvalds retval = setup_buffering(STp, buf, count, 1); 20821da177e4SLinus Torvalds if (retval) 20831da177e4SLinus Torvalds goto out; 20841da177e4SLinus Torvalds do_dio = STbp->do_dio; 20851da177e4SLinus Torvalds 20861da177e4SLinus Torvalds if (STbp->buffer_bytes == 0 && 20871da177e4SLinus Torvalds STps->eof >= ST_EOD_1) { 20881da177e4SLinus Torvalds if (STps->eof < ST_EOD) { 20891da177e4SLinus Torvalds STps->eof += 1; 20901da177e4SLinus Torvalds retval = 0; 20911da177e4SLinus Torvalds goto out; 20921da177e4SLinus Torvalds } 20931da177e4SLinus Torvalds retval = (-EIO); /* EOM or Blank Check */ 20941da177e4SLinus Torvalds goto out; 20951da177e4SLinus Torvalds } 20961da177e4SLinus Torvalds 20971da177e4SLinus Torvalds if (do_dio) { 20981da177e4SLinus Torvalds /* Check the buffer writability before any tape movement. Don't alter 20991da177e4SLinus Torvalds buffer data. */ 21001da177e4SLinus Torvalds if (copy_from_user(&i, buf, 1) != 0 || 21011da177e4SLinus Torvalds copy_to_user(buf, &i, 1) != 0 || 21021da177e4SLinus Torvalds copy_from_user(&i, buf + count - 1, 1) != 0 || 21031da177e4SLinus Torvalds copy_to_user(buf + count - 1, &i, 1) != 0) { 21041da177e4SLinus Torvalds retval = (-EFAULT); 21051da177e4SLinus Torvalds goto out; 21061da177e4SLinus Torvalds } 21071da177e4SLinus Torvalds } 21081da177e4SLinus Torvalds 21091da177e4SLinus Torvalds STps->rw = ST_READING; 21101da177e4SLinus Torvalds 21111da177e4SLinus Torvalds 21121da177e4SLinus Torvalds /* Loop until enough data in buffer or a special condition found */ 21131da177e4SLinus Torvalds for (total = 0, special = 0; total < count && !special;) { 21141da177e4SLinus Torvalds 21151da177e4SLinus Torvalds /* Get new data if the buffer is empty */ 21161da177e4SLinus Torvalds if (STbp->buffer_bytes == 0) { 21171da177e4SLinus Torvalds special = read_tape(STp, count - total, &SRpnt); 21181da177e4SLinus Torvalds if (special < 0) { /* No need to continue read */ 21191da177e4SLinus Torvalds retval = special; 21201da177e4SLinus Torvalds goto out; 21211da177e4SLinus Torvalds } 21221da177e4SLinus Torvalds } 21231da177e4SLinus Torvalds 21241da177e4SLinus Torvalds /* Move the data from driver buffer to user buffer */ 21251da177e4SLinus Torvalds if (STbp->buffer_bytes > 0) { 21261da177e4SLinus Torvalds DEB( 21271da177e4SLinus Torvalds if (debugging && STps->eof != ST_NOEOF) 2128b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, 2129b30d8bcaSHannes Reinecke "EOF up (%d). Left %d, needed %d.\n", 21301da177e4SLinus Torvalds STps->eof, STbp->buffer_bytes, 21311da177e4SLinus Torvalds (int)(count - total)); 21321da177e4SLinus Torvalds ) /* end DEB */ 21331da177e4SLinus Torvalds transfer = STbp->buffer_bytes < count - total ? 21341da177e4SLinus Torvalds STbp->buffer_bytes : count - total; 21351da177e4SLinus Torvalds if (!do_dio) { 21361da177e4SLinus Torvalds i = from_buffer(STbp, buf, transfer); 21371da177e4SLinus Torvalds if (i) { 21381da177e4SLinus Torvalds retval = i; 21391da177e4SLinus Torvalds goto out; 21401da177e4SLinus Torvalds } 21411da177e4SLinus Torvalds } 21421da177e4SLinus Torvalds buf += transfer; 21431da177e4SLinus Torvalds total += transfer; 21441da177e4SLinus Torvalds } 21451da177e4SLinus Torvalds 21461da177e4SLinus Torvalds if (STp->block_size == 0) 21471da177e4SLinus Torvalds break; /* Read only one variable length block */ 21481da177e4SLinus Torvalds 21491da177e4SLinus Torvalds } /* for (total = 0, special = 0; 21501da177e4SLinus Torvalds total < count && !special; ) */ 21511da177e4SLinus Torvalds 21521da177e4SLinus Torvalds /* Change the eof state if no data from tape or buffer */ 21531da177e4SLinus Torvalds if (total == 0) { 21541da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) { 21551da177e4SLinus Torvalds STps->eof = ST_FM; 21561da177e4SLinus Torvalds STps->drv_block = 0; 21571da177e4SLinus Torvalds if (STps->drv_file >= 0) 21581da177e4SLinus Torvalds STps->drv_file++; 21591da177e4SLinus Torvalds } else if (STps->eof == ST_EOD_1) { 21601da177e4SLinus Torvalds STps->eof = ST_EOD_2; 21611da177e4SLinus Torvalds STps->drv_block = 0; 21621da177e4SLinus Torvalds if (STps->drv_file >= 0) 21631da177e4SLinus Torvalds STps->drv_file++; 21641da177e4SLinus Torvalds } else if (STps->eof == ST_EOD_2) 21651da177e4SLinus Torvalds STps->eof = ST_EOD; 21661da177e4SLinus Torvalds } else if (STps->eof == ST_FM) 21671da177e4SLinus Torvalds STps->eof = ST_NOEOF; 21681da177e4SLinus Torvalds retval = total; 21691da177e4SLinus Torvalds 21701da177e4SLinus Torvalds out: 21711da177e4SLinus Torvalds if (SRpnt != NULL) { 21728b05b773SMike Christie st_release_request(SRpnt); 21731da177e4SLinus Torvalds SRpnt = NULL; 21741da177e4SLinus Torvalds } 21751da177e4SLinus Torvalds if (do_dio) { 2176787926b1SKai Makisara release_buffering(STp, 1); 21771da177e4SLinus Torvalds STbp->buffer_bytes = 0; 21781da177e4SLinus Torvalds } 217928f85009SMatthias Kaehlcke mutex_unlock(&STp->lock); 21801da177e4SLinus Torvalds 21811da177e4SLinus Torvalds return retval; 21821da177e4SLinus Torvalds } 21831da177e4SLinus Torvalds 21841da177e4SLinus Torvalds 21851da177e4SLinus Torvalds 21861da177e4SLinus Torvalds DEB( 21871da177e4SLinus Torvalds /* Set the driver options */ 2188b30d8bcaSHannes Reinecke static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm) 21891da177e4SLinus Torvalds { 21901da177e4SLinus Torvalds if (debugging) { 2191b30d8bcaSHannes Reinecke st_printk(KERN_INFO, STp, 2192b30d8bcaSHannes Reinecke "Mode %d options: buffer writes: %d, " 2193b30d8bcaSHannes Reinecke "async writes: %d, read ahead: %d\n", 2194b30d8bcaSHannes Reinecke STp->current_mode, STm->do_buffer_writes, 2195b30d8bcaSHannes Reinecke STm->do_async_writes, STm->do_read_ahead); 2196b30d8bcaSHannes Reinecke st_printk(KERN_INFO, STp, 2197b30d8bcaSHannes Reinecke " can bsr: %d, two FMs: %d, " 2198b30d8bcaSHannes Reinecke "fast mteom: %d, auto lock: %d,\n", 2199b30d8bcaSHannes Reinecke STp->can_bsr, STp->two_fm, STp->fast_mteom, 2200b30d8bcaSHannes Reinecke STp->do_auto_lock); 2201b30d8bcaSHannes Reinecke st_printk(KERN_INFO, STp, 2202b30d8bcaSHannes Reinecke " defs for wr: %d, no block limits: %d, " 2203b30d8bcaSHannes Reinecke "partitions: %d, s2 log: %d\n", 2204b30d8bcaSHannes Reinecke STm->defaults_for_writes, STp->omit_blklims, 2205b30d8bcaSHannes Reinecke STp->can_partitions, STp->scsi2_logical); 2206b30d8bcaSHannes Reinecke st_printk(KERN_INFO, STp, 2207b30d8bcaSHannes Reinecke " sysv: %d nowait: %d sili: %d " 2208b30d8bcaSHannes Reinecke "nowait_filemark: %d\n", 2209b30d8bcaSHannes Reinecke STm->sysv, STp->immediate, STp->sili, 2210c743e44fSLee Duncan STp->immediate_filemark); 2211b30d8bcaSHannes Reinecke st_printk(KERN_INFO, STp, " debugging: %d\n", debugging); 22121da177e4SLinus Torvalds } 22131da177e4SLinus Torvalds } 22141da177e4SLinus Torvalds ) 22151da177e4SLinus Torvalds 22161da177e4SLinus Torvalds 22171da177e4SLinus Torvalds static int st_set_options(struct scsi_tape *STp, long options) 22181da177e4SLinus Torvalds { 22191da177e4SLinus Torvalds int value; 22201da177e4SLinus Torvalds long code; 22211da177e4SLinus Torvalds struct st_modedef *STm; 22221da177e4SLinus Torvalds struct cdev *cd0, *cd1; 2223d6216c47SMaurizio Lombardi struct device *d0, *d1; 22241da177e4SLinus Torvalds 22251da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 22261da177e4SLinus Torvalds if (!STm->defined) { 2227d6216c47SMaurizio Lombardi cd0 = STm->cdevs[0]; 2228d6216c47SMaurizio Lombardi cd1 = STm->cdevs[1]; 2229d6216c47SMaurizio Lombardi d0 = STm->devs[0]; 2230d6216c47SMaurizio Lombardi d1 = STm->devs[1]; 22311da177e4SLinus Torvalds memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef)); 2232d6216c47SMaurizio Lombardi STm->cdevs[0] = cd0; 2233d6216c47SMaurizio Lombardi STm->cdevs[1] = cd1; 2234d6216c47SMaurizio Lombardi STm->devs[0] = d0; 2235d6216c47SMaurizio Lombardi STm->devs[1] = d1; 22361da177e4SLinus Torvalds modes_defined = 1; 2237b30d8bcaSHannes Reinecke DEBC_printk(STp, "Initialized mode %d definition from mode 0\n", 2238b30d8bcaSHannes Reinecke STp->current_mode); 22391da177e4SLinus Torvalds } 22401da177e4SLinus Torvalds 22411da177e4SLinus Torvalds code = options & MT_ST_OPTIONS; 22421da177e4SLinus Torvalds if (code == MT_ST_BOOLEANS) { 22431da177e4SLinus Torvalds STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0; 22441da177e4SLinus Torvalds STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0; 22451da177e4SLinus Torvalds STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0; 22461da177e4SLinus Torvalds STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0; 22471da177e4SLinus Torvalds STp->two_fm = (options & MT_ST_TWO_FM) != 0; 22481da177e4SLinus Torvalds STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0; 22491da177e4SLinus Torvalds STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0; 22501da177e4SLinus Torvalds STp->can_bsr = (options & MT_ST_CAN_BSR) != 0; 22511da177e4SLinus Torvalds STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0; 22521da177e4SLinus Torvalds if ((STp->device)->scsi_level >= SCSI_2) 22531da177e4SLinus Torvalds STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0; 22541da177e4SLinus Torvalds STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0; 22551da177e4SLinus Torvalds STp->immediate = (options & MT_ST_NOWAIT) != 0; 2256c743e44fSLee Duncan STp->immediate_filemark = (options & MT_ST_NOWAIT_EOF) != 0; 22571da177e4SLinus Torvalds STm->sysv = (options & MT_ST_SYSV) != 0; 225840f6b36cSKai Makisara STp->sili = (options & MT_ST_SILI) != 0; 22591da177e4SLinus Torvalds DEB( debugging = (options & MT_ST_DEBUGGING) != 0; 2260b30d8bcaSHannes Reinecke st_log_options(STp, STm); ) 22611da177e4SLinus Torvalds } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) { 22621da177e4SLinus Torvalds value = (code == MT_ST_SETBOOLEANS); 22631da177e4SLinus Torvalds if ((options & MT_ST_BUFFER_WRITES) != 0) 22641da177e4SLinus Torvalds STm->do_buffer_writes = value; 22651da177e4SLinus Torvalds if ((options & MT_ST_ASYNC_WRITES) != 0) 22661da177e4SLinus Torvalds STm->do_async_writes = value; 22671da177e4SLinus Torvalds if ((options & MT_ST_DEF_WRITES) != 0) 22681da177e4SLinus Torvalds STm->defaults_for_writes = value; 22691da177e4SLinus Torvalds if ((options & MT_ST_READ_AHEAD) != 0) 22701da177e4SLinus Torvalds STm->do_read_ahead = value; 22711da177e4SLinus Torvalds if ((options & MT_ST_TWO_FM) != 0) 22721da177e4SLinus Torvalds STp->two_fm = value; 22731da177e4SLinus Torvalds if ((options & MT_ST_FAST_MTEOM) != 0) 22741da177e4SLinus Torvalds STp->fast_mteom = value; 22751da177e4SLinus Torvalds if ((options & MT_ST_AUTO_LOCK) != 0) 22761da177e4SLinus Torvalds STp->do_auto_lock = value; 22771da177e4SLinus Torvalds if ((options & MT_ST_CAN_BSR) != 0) 22781da177e4SLinus Torvalds STp->can_bsr = value; 22791da177e4SLinus Torvalds if ((options & MT_ST_NO_BLKLIMS) != 0) 22801da177e4SLinus Torvalds STp->omit_blklims = value; 22811da177e4SLinus Torvalds if ((STp->device)->scsi_level >= SCSI_2 && 22821da177e4SLinus Torvalds (options & MT_ST_CAN_PARTITIONS) != 0) 22831da177e4SLinus Torvalds STp->can_partitions = value; 22841da177e4SLinus Torvalds if ((options & MT_ST_SCSI2LOGICAL) != 0) 22851da177e4SLinus Torvalds STp->scsi2_logical = value; 22861da177e4SLinus Torvalds if ((options & MT_ST_NOWAIT) != 0) 22871da177e4SLinus Torvalds STp->immediate = value; 2288c743e44fSLee Duncan if ((options & MT_ST_NOWAIT_EOF) != 0) 2289c743e44fSLee Duncan STp->immediate_filemark = value; 22901da177e4SLinus Torvalds if ((options & MT_ST_SYSV) != 0) 22911da177e4SLinus Torvalds STm->sysv = value; 229240f6b36cSKai Makisara if ((options & MT_ST_SILI) != 0) 229340f6b36cSKai Makisara STp->sili = value; 22941da177e4SLinus Torvalds DEB( 22951da177e4SLinus Torvalds if ((options & MT_ST_DEBUGGING) != 0) 22961da177e4SLinus Torvalds debugging = value; 2297b30d8bcaSHannes Reinecke st_log_options(STp, STm); ) 22981da177e4SLinus Torvalds } else if (code == MT_ST_WRITE_THRESHOLD) { 22991da177e4SLinus Torvalds /* Retained for compatibility */ 23001da177e4SLinus Torvalds } else if (code == MT_ST_DEF_BLKSIZE) { 23011da177e4SLinus Torvalds value = (options & ~MT_ST_OPTIONS); 23021da177e4SLinus Torvalds if (value == ~MT_ST_OPTIONS) { 23031da177e4SLinus Torvalds STm->default_blksize = (-1); 2304b30d8bcaSHannes Reinecke DEBC_printk(STp, "Default block size disabled.\n"); 23051da177e4SLinus Torvalds } else { 23061da177e4SLinus Torvalds STm->default_blksize = value; 2307b30d8bcaSHannes Reinecke DEBC_printk(STp,"Default block size set to " 2308b30d8bcaSHannes Reinecke "%d bytes.\n", STm->default_blksize); 23091da177e4SLinus Torvalds if (STp->ready == ST_READY) { 23101da177e4SLinus Torvalds STp->blksize_changed = 0; 23111da177e4SLinus Torvalds set_mode_densblk(STp, STm); 23121da177e4SLinus Torvalds } 23131da177e4SLinus Torvalds } 23141da177e4SLinus Torvalds } else if (code == MT_ST_TIMEOUTS) { 23151da177e4SLinus Torvalds value = (options & ~MT_ST_OPTIONS); 23161da177e4SLinus Torvalds if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) { 23171da177e4SLinus Torvalds STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ; 2318b30d8bcaSHannes Reinecke DEBC_printk(STp, "Long timeout set to %d seconds.\n", 2319b30d8bcaSHannes Reinecke (value & ~MT_ST_SET_LONG_TIMEOUT)); 23201da177e4SLinus Torvalds } else { 2321a02488edSJames Bottomley blk_queue_rq_timeout(STp->device->request_queue, 2322a02488edSJames Bottomley value * HZ); 2323b30d8bcaSHannes Reinecke DEBC_printk(STp, "Normal timeout set to %d seconds.\n", 2324b30d8bcaSHannes Reinecke value); 23251da177e4SLinus Torvalds } 23261da177e4SLinus Torvalds } else if (code == MT_ST_SET_CLN) { 23271da177e4SLinus Torvalds value = (options & ~MT_ST_OPTIONS) & 0xff; 23281da177e4SLinus Torvalds if (value != 0 && 2329832151f4SRoel Kluin (value < EXTENDED_SENSE_START || 2330832151f4SRoel Kluin value >= SCSI_SENSE_BUFFERSIZE)) 23311da177e4SLinus Torvalds return (-EINVAL); 23321da177e4SLinus Torvalds STp->cln_mode = value; 23331da177e4SLinus Torvalds STp->cln_sense_mask = (options >> 8) & 0xff; 23341da177e4SLinus Torvalds STp->cln_sense_value = (options >> 16) & 0xff; 2335b30d8bcaSHannes Reinecke st_printk(KERN_INFO, STp, 2336b30d8bcaSHannes Reinecke "Cleaning request mode %d, mask %02x, value %02x\n", 2337b30d8bcaSHannes Reinecke value, STp->cln_sense_mask, STp->cln_sense_value); 23381da177e4SLinus Torvalds } else if (code == MT_ST_DEF_OPTIONS) { 23391da177e4SLinus Torvalds code = (options & ~MT_ST_CLEAR_DEFAULT); 23401da177e4SLinus Torvalds value = (options & MT_ST_CLEAR_DEFAULT); 23411da177e4SLinus Torvalds if (code == MT_ST_DEF_DENSITY) { 23421da177e4SLinus Torvalds if (value == MT_ST_CLEAR_DEFAULT) { 23431da177e4SLinus Torvalds STm->default_density = (-1); 2344b30d8bcaSHannes Reinecke DEBC_printk(STp, 2345b30d8bcaSHannes Reinecke "Density default disabled.\n"); 23461da177e4SLinus Torvalds } else { 23471da177e4SLinus Torvalds STm->default_density = value & 0xff; 2348b30d8bcaSHannes Reinecke DEBC_printk(STp, "Density default set to %x\n", 2349b30d8bcaSHannes Reinecke STm->default_density); 23501da177e4SLinus Torvalds if (STp->ready == ST_READY) { 23511da177e4SLinus Torvalds STp->density_changed = 0; 23521da177e4SLinus Torvalds set_mode_densblk(STp, STm); 23531da177e4SLinus Torvalds } 23541da177e4SLinus Torvalds } 23551da177e4SLinus Torvalds } else if (code == MT_ST_DEF_DRVBUFFER) { 23561da177e4SLinus Torvalds if (value == MT_ST_CLEAR_DEFAULT) { 23571da177e4SLinus Torvalds STp->default_drvbuffer = 0xff; 2358b30d8bcaSHannes Reinecke DEBC_printk(STp, 2359b30d8bcaSHannes Reinecke "Drive buffer default disabled.\n"); 23601da177e4SLinus Torvalds } else { 23611da177e4SLinus Torvalds STp->default_drvbuffer = value & 7; 2362b30d8bcaSHannes Reinecke DEBC_printk(STp, 2363b30d8bcaSHannes Reinecke "Drive buffer default set to %x\n", 2364b30d8bcaSHannes Reinecke STp->default_drvbuffer); 23651da177e4SLinus Torvalds if (STp->ready == ST_READY) 23661da177e4SLinus Torvalds st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer); 23671da177e4SLinus Torvalds } 23681da177e4SLinus Torvalds } else if (code == MT_ST_DEF_COMPRESSION) { 23691da177e4SLinus Torvalds if (value == MT_ST_CLEAR_DEFAULT) { 23701da177e4SLinus Torvalds STm->default_compression = ST_DONT_TOUCH; 2371b30d8bcaSHannes Reinecke DEBC_printk(STp, 2372b30d8bcaSHannes Reinecke "Compression default disabled.\n"); 23731da177e4SLinus Torvalds } else { 23741da177e4SLinus Torvalds if ((value & 0xff00) != 0) { 23751da177e4SLinus Torvalds STp->c_algo = (value & 0xff00) >> 8; 2376b30d8bcaSHannes Reinecke DEBC_printk(STp, "Compression " 2377b30d8bcaSHannes Reinecke "algorithm set to 0x%x.\n", 2378b30d8bcaSHannes Reinecke STp->c_algo); 23791da177e4SLinus Torvalds } 23801da177e4SLinus Torvalds if ((value & 0xff) != 0xff) { 23811da177e4SLinus Torvalds STm->default_compression = (value & 1 ? ST_YES : ST_NO); 2382b30d8bcaSHannes Reinecke DEBC_printk(STp, "Compression default " 2383b30d8bcaSHannes Reinecke "set to %x\n", 2384b30d8bcaSHannes Reinecke (value & 1)); 23851da177e4SLinus Torvalds if (STp->ready == ST_READY) { 23861da177e4SLinus Torvalds STp->compression_changed = 0; 23871da177e4SLinus Torvalds st_compression(STp, (STm->default_compression == ST_YES)); 23881da177e4SLinus Torvalds } 23891da177e4SLinus Torvalds } 23901da177e4SLinus Torvalds } 23911da177e4SLinus Torvalds } 23921da177e4SLinus Torvalds } else 23931da177e4SLinus Torvalds return (-EIO); 23941da177e4SLinus Torvalds 23951da177e4SLinus Torvalds return 0; 23961da177e4SLinus Torvalds } 23971da177e4SLinus Torvalds 23981da177e4SLinus Torvalds #define MODE_HEADER_LENGTH 4 23991da177e4SLinus Torvalds 24001da177e4SLinus Torvalds /* Mode header and page byte offsets */ 24011da177e4SLinus Torvalds #define MH_OFF_DATA_LENGTH 0 24021da177e4SLinus Torvalds #define MH_OFF_MEDIUM_TYPE 1 24031da177e4SLinus Torvalds #define MH_OFF_DEV_SPECIFIC 2 24041da177e4SLinus Torvalds #define MH_OFF_BDESCS_LENGTH 3 24051da177e4SLinus Torvalds #define MP_OFF_PAGE_NBR 0 24061da177e4SLinus Torvalds #define MP_OFF_PAGE_LENGTH 1 24071da177e4SLinus Torvalds 24081da177e4SLinus Torvalds /* Mode header and page bit masks */ 24091da177e4SLinus Torvalds #define MH_BIT_WP 0x80 24101da177e4SLinus Torvalds #define MP_MSK_PAGE_NBR 0x3f 24111da177e4SLinus Torvalds 24121da177e4SLinus Torvalds /* Don't return block descriptors */ 24131da177e4SLinus Torvalds #define MODE_SENSE_OMIT_BDESCS 0x08 24141da177e4SLinus Torvalds 24151da177e4SLinus Torvalds #define MODE_SELECT_PAGE_FORMAT 0x10 24161da177e4SLinus Torvalds 24171da177e4SLinus Torvalds /* Read a mode page into the tape buffer. The block descriptors are included 24181da177e4SLinus Torvalds if incl_block_descs is true. The page control is ored to the page number 24191da177e4SLinus Torvalds parameter, if necessary. */ 24201da177e4SLinus Torvalds static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs) 24211da177e4SLinus Torvalds { 24221da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 24238ecf0d99SFUJITA Tomonori struct st_request *SRpnt; 24241da177e4SLinus Torvalds 24251da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 24261da177e4SLinus Torvalds cmd[0] = MODE_SENSE; 24271da177e4SLinus Torvalds if (omit_block_descs) 24281da177e4SLinus Torvalds cmd[1] = MODE_SENSE_OMIT_BDESCS; 24291da177e4SLinus Torvalds cmd[2] = page; 24301da177e4SLinus Torvalds cmd[4] = 255; 24311da177e4SLinus Torvalds 243202ae2c0eSKai Makisara SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_FROM_DEVICE, 243302ae2c0eSKai Makisara STp->device->request_queue->rq_timeout, 0, 1); 243402ae2c0eSKai Makisara if (SRpnt == NULL) 243502ae2c0eSKai Makisara return (STp->buffer)->syscall_result; 24361da177e4SLinus Torvalds 24378b05b773SMike Christie st_release_request(SRpnt); 24381da177e4SLinus Torvalds 243902ae2c0eSKai Makisara return STp->buffer->syscall_result; 24401da177e4SLinus Torvalds } 24411da177e4SLinus Torvalds 24421da177e4SLinus Torvalds 24431da177e4SLinus Torvalds /* Send the mode page in the tape buffer to the drive. Assumes that the mode data 24441da177e4SLinus Torvalds in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */ 24451da177e4SLinus Torvalds static int write_mode_page(struct scsi_tape *STp, int page, int slow) 24461da177e4SLinus Torvalds { 244702ae2c0eSKai Makisara int pgo; 24481da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 244918c87015SFUJITA Tomonori struct st_request *SRpnt; 245002ae2c0eSKai Makisara int timeout; 24511da177e4SLinus Torvalds 24521da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 24531da177e4SLinus Torvalds cmd[0] = MODE_SELECT; 24541da177e4SLinus Torvalds cmd[1] = MODE_SELECT_PAGE_FORMAT; 24551da177e4SLinus Torvalds pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH]; 24561da177e4SLinus Torvalds cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2; 24571da177e4SLinus Torvalds 24581da177e4SLinus Torvalds /* Clear reserved fields */ 24591da177e4SLinus Torvalds (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0; 24601da177e4SLinus Torvalds (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0; 24611da177e4SLinus Torvalds (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP; 24621da177e4SLinus Torvalds (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR; 24631da177e4SLinus Torvalds 246402ae2c0eSKai Makisara timeout = slow ? 246502ae2c0eSKai Makisara STp->long_timeout : STp->device->request_queue->rq_timeout; 246602ae2c0eSKai Makisara SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_TO_DEVICE, 246702ae2c0eSKai Makisara timeout, 0, 1); 246802ae2c0eSKai Makisara if (SRpnt == NULL) 246902ae2c0eSKai Makisara return (STp->buffer)->syscall_result; 24701da177e4SLinus Torvalds 24718b05b773SMike Christie st_release_request(SRpnt); 24721da177e4SLinus Torvalds 247302ae2c0eSKai Makisara return STp->buffer->syscall_result; 24741da177e4SLinus Torvalds } 24751da177e4SLinus Torvalds 24761da177e4SLinus Torvalds 24771da177e4SLinus Torvalds #define COMPRESSION_PAGE 0x0f 24781da177e4SLinus Torvalds #define COMPRESSION_PAGE_LENGTH 16 24791da177e4SLinus Torvalds 24801da177e4SLinus Torvalds #define CP_OFF_DCE_DCC 2 24811da177e4SLinus Torvalds #define CP_OFF_C_ALGO 7 24821da177e4SLinus Torvalds 24831da177e4SLinus Torvalds #define DCE_MASK 0x80 24841da177e4SLinus Torvalds #define DCC_MASK 0x40 24851da177e4SLinus Torvalds #define RED_MASK 0x60 24861da177e4SLinus Torvalds 24871da177e4SLinus Torvalds 24881da177e4SLinus Torvalds /* Control the compression with mode page 15. Algorithm not changed if zero. 24891da177e4SLinus Torvalds 24901da177e4SLinus Torvalds The block descriptors are read and written because Sony SDT-7000 does not 24911da177e4SLinus Torvalds work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>). 24921da177e4SLinus Torvalds Including block descriptors should not cause any harm to other drives. */ 24931da177e4SLinus Torvalds 24941da177e4SLinus Torvalds static int st_compression(struct scsi_tape * STp, int state) 24951da177e4SLinus Torvalds { 24961da177e4SLinus Torvalds int retval; 24971da177e4SLinus Torvalds int mpoffs; /* Offset to mode page start */ 24981da177e4SLinus Torvalds unsigned char *b_data = (STp->buffer)->b_data; 24991da177e4SLinus Torvalds 25001da177e4SLinus Torvalds if (STp->ready != ST_READY) 25011da177e4SLinus Torvalds return (-EIO); 25021da177e4SLinus Torvalds 25031da177e4SLinus Torvalds /* Read the current page contents */ 25041da177e4SLinus Torvalds retval = read_mode_page(STp, COMPRESSION_PAGE, 0); 25051da177e4SLinus Torvalds if (retval) { 2506b30d8bcaSHannes Reinecke DEBC_printk(STp, "Compression mode page not supported.\n"); 25071da177e4SLinus Torvalds return (-EIO); 25081da177e4SLinus Torvalds } 25091da177e4SLinus Torvalds 25101da177e4SLinus Torvalds mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH]; 2511b30d8bcaSHannes Reinecke DEBC_printk(STp, "Compression state is %d.\n", 2512b30d8bcaSHannes Reinecke (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)); 25131da177e4SLinus Torvalds 25141da177e4SLinus Torvalds /* Check if compression can be changed */ 25151da177e4SLinus Torvalds if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) { 2516b30d8bcaSHannes Reinecke DEBC_printk(STp, "Compression not supported.\n"); 25171da177e4SLinus Torvalds return (-EIO); 25181da177e4SLinus Torvalds } 25191da177e4SLinus Torvalds 25201da177e4SLinus Torvalds /* Do the change */ 25211da177e4SLinus Torvalds if (state) { 25221da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK; 25231da177e4SLinus Torvalds if (STp->c_algo != 0) 25241da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo; 25251da177e4SLinus Torvalds } 25261da177e4SLinus Torvalds else { 25271da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK; 25281da177e4SLinus Torvalds if (STp->c_algo != 0) 25291da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */ 25301da177e4SLinus Torvalds } 25311da177e4SLinus Torvalds 25321da177e4SLinus Torvalds retval = write_mode_page(STp, COMPRESSION_PAGE, 0); 25331da177e4SLinus Torvalds if (retval) { 2534b30d8bcaSHannes Reinecke DEBC_printk(STp, "Compression change failed.\n"); 25351da177e4SLinus Torvalds return (-EIO); 25361da177e4SLinus Torvalds } 2537b30d8bcaSHannes Reinecke DEBC_printk(STp, "Compression state changed to %d.\n", state); 25381da177e4SLinus Torvalds 25391da177e4SLinus Torvalds STp->compression_changed = 1; 25401da177e4SLinus Torvalds return 0; 25411da177e4SLinus Torvalds } 25421da177e4SLinus Torvalds 25431da177e4SLinus Torvalds 25441da177e4SLinus Torvalds /* Process the load and unload commands (does unload if the load code is zero) */ 25451da177e4SLinus Torvalds static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code) 25461da177e4SLinus Torvalds { 25471da177e4SLinus Torvalds int retval = (-EIO), timeout; 25481da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 25491da177e4SLinus Torvalds struct st_partstat *STps; 25508b05b773SMike Christie struct st_request *SRpnt; 25511da177e4SLinus Torvalds 25521da177e4SLinus Torvalds if (STp->ready != ST_READY && !load_code) { 25531da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 25541da177e4SLinus Torvalds return (-ENOMEDIUM); 25551da177e4SLinus Torvalds else 25561da177e4SLinus Torvalds return (-EIO); 25571da177e4SLinus Torvalds } 25581da177e4SLinus Torvalds 25591da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 25601da177e4SLinus Torvalds cmd[0] = START_STOP; 25611da177e4SLinus Torvalds if (load_code) 25621da177e4SLinus Torvalds cmd[4] |= 1; 25631da177e4SLinus Torvalds /* 25641da177e4SLinus Torvalds * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A 25651da177e4SLinus Torvalds */ 25661da177e4SLinus Torvalds if (load_code >= 1 + MT_ST_HPLOADER_OFFSET 25671da177e4SLinus Torvalds && load_code <= 6 + MT_ST_HPLOADER_OFFSET) { 2568b30d8bcaSHannes Reinecke DEBC_printk(STp, " Enhanced %sload slot %2d.\n", 2569b30d8bcaSHannes Reinecke (cmd[4]) ? "" : "un", 2570b30d8bcaSHannes Reinecke load_code - MT_ST_HPLOADER_OFFSET); 25711da177e4SLinus Torvalds cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */ 25721da177e4SLinus Torvalds } 25731da177e4SLinus Torvalds if (STp->immediate) { 25741da177e4SLinus Torvalds cmd[1] = 1; /* Don't wait for completion */ 2575a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 25761da177e4SLinus Torvalds } 25771da177e4SLinus Torvalds else 25781da177e4SLinus Torvalds timeout = STp->long_timeout; 25791da177e4SLinus Torvalds 25801da177e4SLinus Torvalds DEBC( 25811da177e4SLinus Torvalds if (!load_code) 2582b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, "Unloading tape.\n"); 25831da177e4SLinus Torvalds else 2584b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, "Loading tape.\n"); 25851da177e4SLinus Torvalds ); 25861da177e4SLinus Torvalds 258702ae2c0eSKai Makisara SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE, 258802ae2c0eSKai Makisara timeout, MAX_RETRIES, 1); 25891da177e4SLinus Torvalds if (!SRpnt) 259002ae2c0eSKai Makisara return (STp->buffer)->syscall_result; 25911da177e4SLinus Torvalds 25921da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 259302ae2c0eSKai Makisara st_release_request(SRpnt); 25941da177e4SLinus Torvalds 25951da177e4SLinus Torvalds if (!retval) { /* SCSI command successful */ 25961da177e4SLinus Torvalds 25971da177e4SLinus Torvalds if (!load_code) { 25981da177e4SLinus Torvalds STp->rew_at_close = 0; 25991da177e4SLinus Torvalds STp->ready = ST_NO_TAPE; 26001da177e4SLinus Torvalds } 26011da177e4SLinus Torvalds else { 26021da177e4SLinus Torvalds STp->rew_at_close = STp->autorew_dev; 26031da177e4SLinus Torvalds retval = check_tape(STp, filp); 26041da177e4SLinus Torvalds if (retval > 0) 26051da177e4SLinus Torvalds retval = 0; 26061da177e4SLinus Torvalds } 26071da177e4SLinus Torvalds } 26081da177e4SLinus Torvalds else { 26091da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 26101da177e4SLinus Torvalds STps->drv_file = STps->drv_block = (-1); 26111da177e4SLinus Torvalds } 26121da177e4SLinus Torvalds 26131da177e4SLinus Torvalds return retval; 26141da177e4SLinus Torvalds } 26151da177e4SLinus Torvalds 26161da177e4SLinus Torvalds #if DEBUG 26171da177e4SLinus Torvalds #define ST_DEB_FORWARD 0 26181da177e4SLinus Torvalds #define ST_DEB_BACKWARD 1 2619b30d8bcaSHannes Reinecke static void deb_space_print(struct scsi_tape *STp, int direction, char *units, unsigned char *cmd) 26201da177e4SLinus Torvalds { 26211da177e4SLinus Torvalds s32 sc; 26221da177e4SLinus Torvalds 2623b30d8bcaSHannes Reinecke if (!debugging) 2624b30d8bcaSHannes Reinecke return; 2625b30d8bcaSHannes Reinecke 26261da177e4SLinus Torvalds sc = cmd[2] & 0x80 ? 0xff000000 : 0; 26271da177e4SLinus Torvalds sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4]; 26281da177e4SLinus Torvalds if (direction) 26291da177e4SLinus Torvalds sc = -sc; 2630b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, "Spacing tape %s over %d %s.\n", 26311da177e4SLinus Torvalds direction ? "backward" : "forward", sc, units); 26321da177e4SLinus Torvalds } 2633b30d8bcaSHannes Reinecke #else 2634b30d8bcaSHannes Reinecke #define ST_DEB_FORWARD 0 2635b30d8bcaSHannes Reinecke #define ST_DEB_BACKWARD 1 2636b30d8bcaSHannes Reinecke static void deb_space_print(struct scsi_tape *STp, int direction, char *units, unsigned char *cmd) {} 26371da177e4SLinus Torvalds #endif 26381da177e4SLinus Torvalds 26391da177e4SLinus Torvalds 26401da177e4SLinus Torvalds /* Internal ioctl function */ 26411da177e4SLinus Torvalds static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg) 26421da177e4SLinus Torvalds { 26431da177e4SLinus Torvalds int timeout; 26441da177e4SLinus Torvalds long ltmp; 26451da177e4SLinus Torvalds int ioctl_result; 26461da177e4SLinus Torvalds int chg_eof = 1; 26471da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 26488b05b773SMike Christie struct st_request *SRpnt; 26491da177e4SLinus Torvalds struct st_partstat *STps; 26501da177e4SLinus Torvalds int fileno, blkno, at_sm, undone; 26511da177e4SLinus Torvalds int datalen = 0, direction = DMA_NONE; 26521da177e4SLinus Torvalds 26531da177e4SLinus Torvalds WARN_ON(STp->buffer->do_dio != 0); 26541da177e4SLinus Torvalds if (STp->ready != ST_READY) { 26551da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 26561da177e4SLinus Torvalds return (-ENOMEDIUM); 26571da177e4SLinus Torvalds else 26581da177e4SLinus Torvalds return (-EIO); 26591da177e4SLinus Torvalds } 26601da177e4SLinus Torvalds timeout = STp->long_timeout; 26611da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 26621da177e4SLinus Torvalds fileno = STps->drv_file; 26631da177e4SLinus Torvalds blkno = STps->drv_block; 26641da177e4SLinus Torvalds at_sm = STps->at_sm; 26651da177e4SLinus Torvalds 26661da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 26671da177e4SLinus Torvalds switch (cmd_in) { 26681da177e4SLinus Torvalds case MTFSFM: 26691da177e4SLinus Torvalds chg_eof = 0; /* Changed from the FSF after this */ 26701da177e4SLinus Torvalds case MTFSF: 26711da177e4SLinus Torvalds cmd[0] = SPACE; 26721da177e4SLinus Torvalds cmd[1] = 0x01; /* Space FileMarks */ 26731da177e4SLinus Torvalds cmd[2] = (arg >> 16); 26741da177e4SLinus Torvalds cmd[3] = (arg >> 8); 26751da177e4SLinus Torvalds cmd[4] = arg; 2676b30d8bcaSHannes Reinecke deb_space_print(STp, ST_DEB_FORWARD, "filemarks", cmd); 26771da177e4SLinus Torvalds if (fileno >= 0) 26781da177e4SLinus Torvalds fileno += arg; 26791da177e4SLinus Torvalds blkno = 0; 26801da177e4SLinus Torvalds at_sm &= (arg == 0); 26811da177e4SLinus Torvalds break; 26821da177e4SLinus Torvalds case MTBSFM: 26831da177e4SLinus Torvalds chg_eof = 0; /* Changed from the FSF after this */ 26841da177e4SLinus Torvalds case MTBSF: 26851da177e4SLinus Torvalds cmd[0] = SPACE; 26861da177e4SLinus Torvalds cmd[1] = 0x01; /* Space FileMarks */ 26871da177e4SLinus Torvalds ltmp = (-arg); 26881da177e4SLinus Torvalds cmd[2] = (ltmp >> 16); 26891da177e4SLinus Torvalds cmd[3] = (ltmp >> 8); 26901da177e4SLinus Torvalds cmd[4] = ltmp; 2691b30d8bcaSHannes Reinecke deb_space_print(STp, ST_DEB_BACKWARD, "filemarks", cmd); 26921da177e4SLinus Torvalds if (fileno >= 0) 26931da177e4SLinus Torvalds fileno -= arg; 26941da177e4SLinus Torvalds blkno = (-1); /* We can't know the block number */ 26951da177e4SLinus Torvalds at_sm &= (arg == 0); 26961da177e4SLinus Torvalds break; 26971da177e4SLinus Torvalds case MTFSR: 26981da177e4SLinus Torvalds cmd[0] = SPACE; 26991da177e4SLinus Torvalds cmd[1] = 0x00; /* Space Blocks */ 27001da177e4SLinus Torvalds cmd[2] = (arg >> 16); 27011da177e4SLinus Torvalds cmd[3] = (arg >> 8); 27021da177e4SLinus Torvalds cmd[4] = arg; 2703b30d8bcaSHannes Reinecke deb_space_print(STp, ST_DEB_FORWARD, "blocks", cmd); 27041da177e4SLinus Torvalds if (blkno >= 0) 27051da177e4SLinus Torvalds blkno += arg; 27061da177e4SLinus Torvalds at_sm &= (arg == 0); 27071da177e4SLinus Torvalds break; 27081da177e4SLinus Torvalds case MTBSR: 27091da177e4SLinus Torvalds cmd[0] = SPACE; 27101da177e4SLinus Torvalds cmd[1] = 0x00; /* Space Blocks */ 27111da177e4SLinus Torvalds ltmp = (-arg); 27121da177e4SLinus Torvalds cmd[2] = (ltmp >> 16); 27131da177e4SLinus Torvalds cmd[3] = (ltmp >> 8); 27141da177e4SLinus Torvalds cmd[4] = ltmp; 2715b30d8bcaSHannes Reinecke deb_space_print(STp, ST_DEB_BACKWARD, "blocks", cmd); 27161da177e4SLinus Torvalds if (blkno >= 0) 27171da177e4SLinus Torvalds blkno -= arg; 27181da177e4SLinus Torvalds at_sm &= (arg == 0); 27191da177e4SLinus Torvalds break; 27201da177e4SLinus Torvalds case MTFSS: 27211da177e4SLinus Torvalds cmd[0] = SPACE; 27221da177e4SLinus Torvalds cmd[1] = 0x04; /* Space Setmarks */ 27231da177e4SLinus Torvalds cmd[2] = (arg >> 16); 27241da177e4SLinus Torvalds cmd[3] = (arg >> 8); 27251da177e4SLinus Torvalds cmd[4] = arg; 2726b30d8bcaSHannes Reinecke deb_space_print(STp, ST_DEB_FORWARD, "setmarks", cmd); 27271da177e4SLinus Torvalds if (arg != 0) { 27281da177e4SLinus Torvalds blkno = fileno = (-1); 27291da177e4SLinus Torvalds at_sm = 1; 27301da177e4SLinus Torvalds } 27311da177e4SLinus Torvalds break; 27321da177e4SLinus Torvalds case MTBSS: 27331da177e4SLinus Torvalds cmd[0] = SPACE; 27341da177e4SLinus Torvalds cmd[1] = 0x04; /* Space Setmarks */ 27351da177e4SLinus Torvalds ltmp = (-arg); 27361da177e4SLinus Torvalds cmd[2] = (ltmp >> 16); 27371da177e4SLinus Torvalds cmd[3] = (ltmp >> 8); 27381da177e4SLinus Torvalds cmd[4] = ltmp; 2739b30d8bcaSHannes Reinecke deb_space_print(STp, ST_DEB_BACKWARD, "setmarks", cmd); 27401da177e4SLinus Torvalds if (arg != 0) { 27411da177e4SLinus Torvalds blkno = fileno = (-1); 27421da177e4SLinus Torvalds at_sm = 1; 27431da177e4SLinus Torvalds } 27441da177e4SLinus Torvalds break; 27451da177e4SLinus Torvalds case MTWEOF: 27463e51d3c9SKai Makisara case MTWEOFI: 27471da177e4SLinus Torvalds case MTWSM: 27481da177e4SLinus Torvalds if (STp->write_prot) 27491da177e4SLinus Torvalds return (-EACCES); 27501da177e4SLinus Torvalds cmd[0] = WRITE_FILEMARKS; 27511da177e4SLinus Torvalds if (cmd_in == MTWSM) 27521da177e4SLinus Torvalds cmd[1] = 2; 2753c743e44fSLee Duncan if (cmd_in == MTWEOFI || 2754c743e44fSLee Duncan (cmd_in == MTWEOF && STp->immediate_filemark)) 27553e51d3c9SKai Makisara cmd[1] |= 1; 27561da177e4SLinus Torvalds cmd[2] = (arg >> 16); 27571da177e4SLinus Torvalds cmd[3] = (arg >> 8); 27581da177e4SLinus Torvalds cmd[4] = arg; 2759a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 27601da177e4SLinus Torvalds DEBC( 27613e51d3c9SKai Makisara if (cmd_in != MTWSM) 2762b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, 2763b30d8bcaSHannes Reinecke "Writing %d filemarks.\n", 2764b30d8bcaSHannes Reinecke cmd[2] * 65536 + 2765b30d8bcaSHannes Reinecke cmd[3] * 256 + 2766b30d8bcaSHannes Reinecke cmd[4]); 27671da177e4SLinus Torvalds else 2768b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, 2769b30d8bcaSHannes Reinecke "Writing %d setmarks.\n", 2770b30d8bcaSHannes Reinecke cmd[2] * 65536 + 2771b30d8bcaSHannes Reinecke cmd[3] * 256 + 2772b30d8bcaSHannes Reinecke cmd[4]); 27731da177e4SLinus Torvalds ) 27741da177e4SLinus Torvalds if (fileno >= 0) 27751da177e4SLinus Torvalds fileno += arg; 27761da177e4SLinus Torvalds blkno = 0; 27771da177e4SLinus Torvalds at_sm = (cmd_in == MTWSM); 27781da177e4SLinus Torvalds break; 27791da177e4SLinus Torvalds case MTREW: 27801da177e4SLinus Torvalds cmd[0] = REZERO_UNIT; 27811da177e4SLinus Torvalds if (STp->immediate) { 27821da177e4SLinus Torvalds cmd[1] = 1; /* Don't wait for completion */ 2783a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 27841da177e4SLinus Torvalds } 2785b30d8bcaSHannes Reinecke DEBC_printk(STp, "Rewinding tape.\n"); 27861da177e4SLinus Torvalds fileno = blkno = at_sm = 0; 27871da177e4SLinus Torvalds break; 27881da177e4SLinus Torvalds case MTNOP: 2789b30d8bcaSHannes Reinecke DEBC_printk(STp, "No op on tape.\n"); 27901da177e4SLinus Torvalds return 0; /* Should do something ? */ 27911da177e4SLinus Torvalds break; 27921da177e4SLinus Torvalds case MTRETEN: 27931da177e4SLinus Torvalds cmd[0] = START_STOP; 27941da177e4SLinus Torvalds if (STp->immediate) { 27951da177e4SLinus Torvalds cmd[1] = 1; /* Don't wait for completion */ 2796a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 27971da177e4SLinus Torvalds } 27981da177e4SLinus Torvalds cmd[4] = 3; 2799b30d8bcaSHannes Reinecke DEBC_printk(STp, "Retensioning tape.\n"); 28001da177e4SLinus Torvalds fileno = blkno = at_sm = 0; 28011da177e4SLinus Torvalds break; 28021da177e4SLinus Torvalds case MTEOM: 28031da177e4SLinus Torvalds if (!STp->fast_mteom) { 28041da177e4SLinus Torvalds /* space to the end of tape */ 28051da177e4SLinus Torvalds ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff); 28061da177e4SLinus Torvalds fileno = STps->drv_file; 28071da177e4SLinus Torvalds if (STps->eof >= ST_EOD_1) 28081da177e4SLinus Torvalds return 0; 28091da177e4SLinus Torvalds /* The next lines would hide the number of spaced FileMarks 28101da177e4SLinus Torvalds That's why I inserted the previous lines. I had no luck 28111da177e4SLinus Torvalds with detecting EOM with FSF, so we go now to EOM. 28121da177e4SLinus Torvalds Joerg Weule */ 28131da177e4SLinus Torvalds } else 28141da177e4SLinus Torvalds fileno = (-1); 28151da177e4SLinus Torvalds cmd[0] = SPACE; 28161da177e4SLinus Torvalds cmd[1] = 3; 2817b30d8bcaSHannes Reinecke DEBC_printk(STp, "Spacing to end of recorded medium.\n"); 28181da177e4SLinus Torvalds blkno = -1; 28191da177e4SLinus Torvalds at_sm = 0; 28201da177e4SLinus Torvalds break; 28211da177e4SLinus Torvalds case MTERASE: 28221da177e4SLinus Torvalds if (STp->write_prot) 28231da177e4SLinus Torvalds return (-EACCES); 28241da177e4SLinus Torvalds cmd[0] = ERASE; 28251da177e4SLinus Torvalds cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */ 28261da177e4SLinus Torvalds if (STp->immediate) { 28271da177e4SLinus Torvalds cmd[1] |= 2; /* Don't wait for completion */ 2828a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 28291da177e4SLinus Torvalds } 28301da177e4SLinus Torvalds else 28311da177e4SLinus Torvalds timeout = STp->long_timeout * 8; 28321da177e4SLinus Torvalds 2833b30d8bcaSHannes Reinecke DEBC_printk(STp, "Erasing tape.\n"); 28341da177e4SLinus Torvalds fileno = blkno = at_sm = 0; 28351da177e4SLinus Torvalds break; 28361da177e4SLinus Torvalds case MTSETBLK: /* Set block length */ 28371da177e4SLinus Torvalds case MTSETDENSITY: /* Set tape density */ 28381da177e4SLinus Torvalds case MTSETDRVBUFFER: /* Set drive buffering */ 28391da177e4SLinus Torvalds case SET_DENS_AND_BLK: /* Set density and block size */ 28401da177e4SLinus Torvalds chg_eof = 0; 28411da177e4SLinus Torvalds if (STp->dirty || (STp->buffer)->buffer_bytes != 0) 28421da177e4SLinus Torvalds return (-EIO); /* Not allowed if data in buffer */ 28431da177e4SLinus Torvalds if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) && 28441da177e4SLinus Torvalds (arg & MT_ST_BLKSIZE_MASK) != 0 && 28451da177e4SLinus Torvalds STp->max_block > 0 && 28461da177e4SLinus Torvalds ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block || 28471da177e4SLinus Torvalds (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) { 2848b30d8bcaSHannes Reinecke st_printk(KERN_WARNING, STp, "Illegal block size.\n"); 28491da177e4SLinus Torvalds return (-EINVAL); 28501da177e4SLinus Torvalds } 28511da177e4SLinus Torvalds cmd[0] = MODE_SELECT; 28521da177e4SLinus Torvalds if ((STp->use_pf & USE_PF)) 28531da177e4SLinus Torvalds cmd[1] = MODE_SELECT_PAGE_FORMAT; 28541da177e4SLinus Torvalds cmd[4] = datalen = 12; 28551da177e4SLinus Torvalds direction = DMA_TO_DEVICE; 28561da177e4SLinus Torvalds 28571da177e4SLinus Torvalds memset((STp->buffer)->b_data, 0, 12); 28581da177e4SLinus Torvalds if (cmd_in == MTSETDRVBUFFER) 28591da177e4SLinus Torvalds (STp->buffer)->b_data[2] = (arg & 7) << 4; 28601da177e4SLinus Torvalds else 28611da177e4SLinus Torvalds (STp->buffer)->b_data[2] = 28621da177e4SLinus Torvalds STp->drv_buffer << 4; 28631da177e4SLinus Torvalds (STp->buffer)->b_data[3] = 8; /* block descriptor length */ 28641da177e4SLinus Torvalds if (cmd_in == MTSETDENSITY) { 28651da177e4SLinus Torvalds (STp->buffer)->b_data[4] = arg; 28661da177e4SLinus Torvalds STp->density_changed = 1; /* At least we tried ;-) */ 28671da177e4SLinus Torvalds } else if (cmd_in == SET_DENS_AND_BLK) 28681da177e4SLinus Torvalds (STp->buffer)->b_data[4] = arg >> 24; 28691da177e4SLinus Torvalds else 28701da177e4SLinus Torvalds (STp->buffer)->b_data[4] = STp->density; 28711da177e4SLinus Torvalds if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) { 28721da177e4SLinus Torvalds ltmp = arg & MT_ST_BLKSIZE_MASK; 28731da177e4SLinus Torvalds if (cmd_in == MTSETBLK) 28741da177e4SLinus Torvalds STp->blksize_changed = 1; /* At least we tried ;-) */ 28751da177e4SLinus Torvalds } else 28761da177e4SLinus Torvalds ltmp = STp->block_size; 28771da177e4SLinus Torvalds (STp->buffer)->b_data[9] = (ltmp >> 16); 28781da177e4SLinus Torvalds (STp->buffer)->b_data[10] = (ltmp >> 8); 28791da177e4SLinus Torvalds (STp->buffer)->b_data[11] = ltmp; 2880a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 28811da177e4SLinus Torvalds DEBC( 28821da177e4SLinus Torvalds if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) 2883b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, 2884b30d8bcaSHannes Reinecke "Setting block size to %d bytes.\n", 28851da177e4SLinus Torvalds (STp->buffer)->b_data[9] * 65536 + 28861da177e4SLinus Torvalds (STp->buffer)->b_data[10] * 256 + 28871da177e4SLinus Torvalds (STp->buffer)->b_data[11]); 28881da177e4SLinus Torvalds if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK) 2889b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, 2890b30d8bcaSHannes Reinecke "Setting density code to %x.\n", 28911da177e4SLinus Torvalds (STp->buffer)->b_data[4]); 28921da177e4SLinus Torvalds if (cmd_in == MTSETDRVBUFFER) 2893b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, 2894b30d8bcaSHannes Reinecke "Setting drive buffer code to %d.\n", 28951da177e4SLinus Torvalds ((STp->buffer)->b_data[2] >> 4) & 7); 28961da177e4SLinus Torvalds ) 28971da177e4SLinus Torvalds break; 28981da177e4SLinus Torvalds default: 28991da177e4SLinus Torvalds return (-ENOSYS); 29001da177e4SLinus Torvalds } 29011da177e4SLinus Torvalds 290202ae2c0eSKai Makisara SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction, 290302ae2c0eSKai Makisara timeout, MAX_RETRIES, 1); 29041da177e4SLinus Torvalds if (!SRpnt) 29051da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 29061da177e4SLinus Torvalds 29071da177e4SLinus Torvalds ioctl_result = (STp->buffer)->syscall_result; 29081da177e4SLinus Torvalds 29091da177e4SLinus Torvalds if (!ioctl_result) { /* SCSI command successful */ 29108b05b773SMike Christie st_release_request(SRpnt); 29111da177e4SLinus Torvalds SRpnt = NULL; 29121da177e4SLinus Torvalds STps->drv_block = blkno; 29131da177e4SLinus Torvalds STps->drv_file = fileno; 29141da177e4SLinus Torvalds STps->at_sm = at_sm; 29151da177e4SLinus Torvalds 29161da177e4SLinus Torvalds if (cmd_in == MTBSFM) 29171da177e4SLinus Torvalds ioctl_result = st_int_ioctl(STp, MTFSF, 1); 29181da177e4SLinus Torvalds else if (cmd_in == MTFSFM) 29191da177e4SLinus Torvalds ioctl_result = st_int_ioctl(STp, MTBSF, 1); 29201da177e4SLinus Torvalds 29211da177e4SLinus Torvalds if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) { 29221da177e4SLinus Torvalds STp->block_size = arg & MT_ST_BLKSIZE_MASK; 29231da177e4SLinus Torvalds if (STp->block_size != 0) { 29241da177e4SLinus Torvalds (STp->buffer)->buffer_blocks = 29251da177e4SLinus Torvalds (STp->buffer)->buffer_size / STp->block_size; 29261da177e4SLinus Torvalds } 29271da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0; 29281da177e4SLinus Torvalds if (cmd_in == SET_DENS_AND_BLK) 29291da177e4SLinus Torvalds STp->density = arg >> MT_ST_DENSITY_SHIFT; 29301da177e4SLinus Torvalds } else if (cmd_in == MTSETDRVBUFFER) 29311da177e4SLinus Torvalds STp->drv_buffer = (arg & 7); 29321da177e4SLinus Torvalds else if (cmd_in == MTSETDENSITY) 29331da177e4SLinus Torvalds STp->density = arg; 29341da177e4SLinus Torvalds 29351da177e4SLinus Torvalds if (cmd_in == MTEOM) 29361da177e4SLinus Torvalds STps->eof = ST_EOD; 29371da177e4SLinus Torvalds else if (cmd_in == MTFSF) 29381da177e4SLinus Torvalds STps->eof = ST_FM; 29391da177e4SLinus Torvalds else if (chg_eof) 29401da177e4SLinus Torvalds STps->eof = ST_NOEOF; 29411da177e4SLinus Torvalds 29423e51d3c9SKai Makisara if (cmd_in == MTWEOF || cmd_in == MTWEOFI) 29433e51d3c9SKai Makisara STps->rw = ST_IDLE; /* prevent automatic WEOF at close */ 29441da177e4SLinus Torvalds } else { /* SCSI command was not completely successful. Don't return 29451da177e4SLinus Torvalds from this block without releasing the SCSI command block! */ 29461da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 29471da177e4SLinus Torvalds 29481da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_EOM) { 29491da177e4SLinus Torvalds if (cmd_in != MTBSF && cmd_in != MTBSFM && 29501da177e4SLinus Torvalds cmd_in != MTBSR && cmd_in != MTBSS) 29511da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 29521da177e4SLinus Torvalds STps->drv_block = 0; 29531da177e4SLinus Torvalds } 29541da177e4SLinus Torvalds 29551da177e4SLinus Torvalds if (cmdstatp->remainder_valid) 29561da177e4SLinus Torvalds undone = (int)cmdstatp->uremainder64; 29571da177e4SLinus Torvalds else 29581da177e4SLinus Torvalds undone = 0; 29591da177e4SLinus Torvalds 29603e51d3c9SKai Makisara if ((cmd_in == MTWEOF || cmd_in == MTWEOFI) && 29611da177e4SLinus Torvalds cmdstatp->have_sense && 296291614c05SKai Makisara (cmdstatp->flags & SENSE_EOM)) { 296391614c05SKai Makisara if (cmdstatp->sense_hdr.sense_key == NO_SENSE || 296491614c05SKai Makisara cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) { 296591614c05SKai Makisara ioctl_result = 0; /* EOF(s) written successfully at EOM */ 29661da177e4SLinus Torvalds STps->eof = ST_NOEOF; 296791614c05SKai Makisara } else { /* Writing EOF(s) failed */ 296891614c05SKai Makisara if (fileno >= 0) 296991614c05SKai Makisara fileno -= undone; 297091614c05SKai Makisara if (undone < arg) 297191614c05SKai Makisara STps->eof = ST_NOEOF; 297291614c05SKai Makisara } 297391614c05SKai Makisara STps->drv_file = fileno; 29741da177e4SLinus Torvalds } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) { 29751da177e4SLinus Torvalds if (fileno >= 0) 29761da177e4SLinus Torvalds STps->drv_file = fileno - undone; 29771da177e4SLinus Torvalds else 29781da177e4SLinus Torvalds STps->drv_file = fileno; 29791da177e4SLinus Torvalds STps->drv_block = -1; 29801da177e4SLinus Torvalds STps->eof = ST_NOEOF; 29811da177e4SLinus Torvalds } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) { 29821da177e4SLinus Torvalds if (arg > 0 && undone < 0) /* Some drives get this wrong */ 29831da177e4SLinus Torvalds undone = (-undone); 29841da177e4SLinus Torvalds if (STps->drv_file >= 0) 29851da177e4SLinus Torvalds STps->drv_file = fileno + undone; 29861da177e4SLinus Torvalds STps->drv_block = 0; 29871da177e4SLinus Torvalds STps->eof = ST_NOEOF; 29881da177e4SLinus Torvalds } else if (cmd_in == MTFSR) { 29891da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */ 29901da177e4SLinus Torvalds if (STps->drv_file >= 0) 29911da177e4SLinus Torvalds STps->drv_file++; 29921da177e4SLinus Torvalds STps->drv_block = 0; 29931da177e4SLinus Torvalds STps->eof = ST_FM; 29941da177e4SLinus Torvalds } else { 29951da177e4SLinus Torvalds if (blkno >= undone) 29961da177e4SLinus Torvalds STps->drv_block = blkno - undone; 29971da177e4SLinus Torvalds else 29981da177e4SLinus Torvalds STps->drv_block = (-1); 29991da177e4SLinus Torvalds STps->eof = ST_NOEOF; 30001da177e4SLinus Torvalds } 30011da177e4SLinus Torvalds } else if (cmd_in == MTBSR) { 30021da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */ 30031da177e4SLinus Torvalds STps->drv_file--; 30041da177e4SLinus Torvalds STps->drv_block = (-1); 30051da177e4SLinus Torvalds } else { 30061da177e4SLinus Torvalds if (arg > 0 && undone < 0) /* Some drives get this wrong */ 30071da177e4SLinus Torvalds undone = (-undone); 30081da177e4SLinus Torvalds if (STps->drv_block >= 0) 30091da177e4SLinus Torvalds STps->drv_block = blkno + undone; 30101da177e4SLinus Torvalds } 30111da177e4SLinus Torvalds STps->eof = ST_NOEOF; 30121da177e4SLinus Torvalds } else if (cmd_in == MTEOM) { 30131da177e4SLinus Torvalds STps->drv_file = (-1); 30141da177e4SLinus Torvalds STps->drv_block = (-1); 30151da177e4SLinus Torvalds STps->eof = ST_EOD; 30161da177e4SLinus Torvalds } else if (cmd_in == MTSETBLK || 30171da177e4SLinus Torvalds cmd_in == MTSETDENSITY || 30181da177e4SLinus Torvalds cmd_in == MTSETDRVBUFFER || 30191da177e4SLinus Torvalds cmd_in == SET_DENS_AND_BLK) { 30201da177e4SLinus Torvalds if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST && 30211da177e4SLinus Torvalds !(STp->use_pf & PF_TESTED)) { 30221da177e4SLinus Torvalds /* Try the other possible state of Page Format if not 30231da177e4SLinus Torvalds already tried */ 30241da2019fSKai Makisara STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED; 30258b05b773SMike Christie st_release_request(SRpnt); 30261da177e4SLinus Torvalds SRpnt = NULL; 30271da177e4SLinus Torvalds return st_int_ioctl(STp, cmd_in, arg); 30281da177e4SLinus Torvalds } 30291da177e4SLinus Torvalds } else if (chg_eof) 30301da177e4SLinus Torvalds STps->eof = ST_NOEOF; 30311da177e4SLinus Torvalds 30321da177e4SLinus Torvalds if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK) 30331da177e4SLinus Torvalds STps->eof = ST_EOD; 30341da177e4SLinus Torvalds 30358b05b773SMike Christie st_release_request(SRpnt); 30361da177e4SLinus Torvalds SRpnt = NULL; 30371da177e4SLinus Torvalds } 30381da177e4SLinus Torvalds 30391da177e4SLinus Torvalds return ioctl_result; 30401da177e4SLinus Torvalds } 30411da177e4SLinus Torvalds 30421da177e4SLinus Torvalds 30431da177e4SLinus Torvalds /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc 30441da177e4SLinus Torvalds structure. */ 30451da177e4SLinus Torvalds 30461da177e4SLinus Torvalds static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition, 30471da177e4SLinus Torvalds int logical) 30481da177e4SLinus Torvalds { 30491da177e4SLinus Torvalds int result; 30501da177e4SLinus Torvalds unsigned char scmd[MAX_COMMAND_SIZE]; 30518b05b773SMike Christie struct st_request *SRpnt; 30521da177e4SLinus Torvalds 30531da177e4SLinus Torvalds if (STp->ready != ST_READY) 30541da177e4SLinus Torvalds return (-EIO); 30551da177e4SLinus Torvalds 30561da177e4SLinus Torvalds memset(scmd, 0, MAX_COMMAND_SIZE); 30571da177e4SLinus Torvalds if ((STp->device)->scsi_level < SCSI_2) { 30581da177e4SLinus Torvalds scmd[0] = QFA_REQUEST_BLOCK; 30591da177e4SLinus Torvalds scmd[4] = 3; 30601da177e4SLinus Torvalds } else { 30611da177e4SLinus Torvalds scmd[0] = READ_POSITION; 30621da177e4SLinus Torvalds if (!logical && !STp->scsi2_logical) 30631da177e4SLinus Torvalds scmd[1] = 1; 30641da177e4SLinus Torvalds } 306502ae2c0eSKai Makisara SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE, 30667a31ec3cSFUJITA Tomonori STp->device->request_queue->rq_timeout, 306702ae2c0eSKai Makisara MAX_READY_RETRIES, 1); 306802ae2c0eSKai Makisara if (!SRpnt) 306902ae2c0eSKai Makisara return (STp->buffer)->syscall_result; 30701da177e4SLinus Torvalds 30711da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0 || 30721da177e4SLinus Torvalds (STp->device->scsi_level >= SCSI_2 && 30731da177e4SLinus Torvalds ((STp->buffer)->b_data[0] & 4) != 0)) { 30741da177e4SLinus Torvalds *block = *partition = 0; 3075b30d8bcaSHannes Reinecke DEBC_printk(STp, " Can't read tape position.\n"); 30761da177e4SLinus Torvalds result = (-EIO); 30771da177e4SLinus Torvalds } else { 30781da177e4SLinus Torvalds result = 0; 30791da177e4SLinus Torvalds if ((STp->device)->scsi_level < SCSI_2) { 30801da177e4SLinus Torvalds *block = ((STp->buffer)->b_data[0] << 16) 30811da177e4SLinus Torvalds + ((STp->buffer)->b_data[1] << 8) 30821da177e4SLinus Torvalds + (STp->buffer)->b_data[2]; 30831da177e4SLinus Torvalds *partition = 0; 30841da177e4SLinus Torvalds } else { 30851da177e4SLinus Torvalds *block = ((STp->buffer)->b_data[4] << 24) 30861da177e4SLinus Torvalds + ((STp->buffer)->b_data[5] << 16) 30871da177e4SLinus Torvalds + ((STp->buffer)->b_data[6] << 8) 30881da177e4SLinus Torvalds + (STp->buffer)->b_data[7]; 30891da177e4SLinus Torvalds *partition = (STp->buffer)->b_data[1]; 30901da177e4SLinus Torvalds if (((STp->buffer)->b_data[0] & 0x80) && 30911da177e4SLinus Torvalds (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */ 30921da177e4SLinus Torvalds STp->ps[0].drv_block = STp->ps[0].drv_file = 0; 30931da177e4SLinus Torvalds } 3094b30d8bcaSHannes Reinecke DEBC_printk(STp, "Got tape pos. blk %d part %d.\n", 3095b30d8bcaSHannes Reinecke *block, *partition); 30961da177e4SLinus Torvalds } 30978b05b773SMike Christie st_release_request(SRpnt); 30981da177e4SLinus Torvalds SRpnt = NULL; 30991da177e4SLinus Torvalds 31001da177e4SLinus Torvalds return result; 31011da177e4SLinus Torvalds } 31021da177e4SLinus Torvalds 31031da177e4SLinus Torvalds 31041da177e4SLinus Torvalds /* Set the tape block and partition. Negative partition means that only the 31051da177e4SLinus Torvalds block should be set in vendor specific way. */ 31061da177e4SLinus Torvalds static int set_location(struct scsi_tape *STp, unsigned int block, int partition, 31071da177e4SLinus Torvalds int logical) 31081da177e4SLinus Torvalds { 31091da177e4SLinus Torvalds struct st_partstat *STps; 31101da177e4SLinus Torvalds int result, p; 31111da177e4SLinus Torvalds unsigned int blk; 31121da177e4SLinus Torvalds int timeout; 31131da177e4SLinus Torvalds unsigned char scmd[MAX_COMMAND_SIZE]; 31148b05b773SMike Christie struct st_request *SRpnt; 31151da177e4SLinus Torvalds 31161da177e4SLinus Torvalds if (STp->ready != ST_READY) 31171da177e4SLinus Torvalds return (-EIO); 31181da177e4SLinus Torvalds timeout = STp->long_timeout; 31191da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 31201da177e4SLinus Torvalds 3121b30d8bcaSHannes Reinecke DEBC_printk(STp, "Setting block to %d and partition to %d.\n", 3122b30d8bcaSHannes Reinecke block, partition); 31231da177e4SLinus Torvalds DEB(if (partition < 0) 31241da177e4SLinus Torvalds return (-EIO); ) 31251da177e4SLinus Torvalds 31261da177e4SLinus Torvalds /* Update the location at the partition we are leaving */ 31271da177e4SLinus Torvalds if ((!STp->can_partitions && partition != 0) || 31281da177e4SLinus Torvalds partition >= ST_NBR_PARTITIONS) 31291da177e4SLinus Torvalds return (-EINVAL); 31301da177e4SLinus Torvalds if (partition != STp->partition) { 31311da177e4SLinus Torvalds if (get_location(STp, &blk, &p, 1)) 31321da177e4SLinus Torvalds STps->last_block_valid = 0; 31331da177e4SLinus Torvalds else { 31341da177e4SLinus Torvalds STps->last_block_valid = 1; 31351da177e4SLinus Torvalds STps->last_block_visited = blk; 3136b30d8bcaSHannes Reinecke DEBC_printk(STp, "Visited block %d for " 3137b30d8bcaSHannes Reinecke "partition %d saved.\n", 3138b30d8bcaSHannes Reinecke blk, STp->partition); 31391da177e4SLinus Torvalds } 31401da177e4SLinus Torvalds } 31411da177e4SLinus Torvalds 31421da177e4SLinus Torvalds memset(scmd, 0, MAX_COMMAND_SIZE); 31431da177e4SLinus Torvalds if ((STp->device)->scsi_level < SCSI_2) { 31441da177e4SLinus Torvalds scmd[0] = QFA_SEEK_BLOCK; 31451da177e4SLinus Torvalds scmd[2] = (block >> 16); 31461da177e4SLinus Torvalds scmd[3] = (block >> 8); 31471da177e4SLinus Torvalds scmd[4] = block; 31481da177e4SLinus Torvalds scmd[5] = 0; 31491da177e4SLinus Torvalds } else { 31501da177e4SLinus Torvalds scmd[0] = SEEK_10; 31511da177e4SLinus Torvalds scmd[3] = (block >> 24); 31521da177e4SLinus Torvalds scmd[4] = (block >> 16); 31531da177e4SLinus Torvalds scmd[5] = (block >> 8); 31541da177e4SLinus Torvalds scmd[6] = block; 31551da177e4SLinus Torvalds if (!logical && !STp->scsi2_logical) 31561da177e4SLinus Torvalds scmd[1] = 4; 31571da177e4SLinus Torvalds if (STp->partition != partition) { 31581da177e4SLinus Torvalds scmd[1] |= 2; 31591da177e4SLinus Torvalds scmd[8] = partition; 3160b30d8bcaSHannes Reinecke DEBC_printk(STp, "Trying to change partition " 3161b30d8bcaSHannes Reinecke "from %d to %d\n", STp->partition, 3162b30d8bcaSHannes Reinecke partition); 31631da177e4SLinus Torvalds } 31641da177e4SLinus Torvalds } 31651da177e4SLinus Torvalds if (STp->immediate) { 31661da177e4SLinus Torvalds scmd[1] |= 1; /* Don't wait for completion */ 3167a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 31681da177e4SLinus Torvalds } 31691da177e4SLinus Torvalds 317002ae2c0eSKai Makisara SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE, 317102ae2c0eSKai Makisara timeout, MAX_READY_RETRIES, 1); 31721da177e4SLinus Torvalds if (!SRpnt) 317302ae2c0eSKai Makisara return (STp->buffer)->syscall_result; 31741da177e4SLinus Torvalds 31751da177e4SLinus Torvalds STps->drv_block = STps->drv_file = (-1); 31761da177e4SLinus Torvalds STps->eof = ST_NOEOF; 31771da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0) { 31781da177e4SLinus Torvalds result = (-EIO); 31791da177e4SLinus Torvalds if (STp->can_partitions && 31801da177e4SLinus Torvalds (STp->device)->scsi_level >= SCSI_2 && 31811da177e4SLinus Torvalds (p = find_partition(STp)) >= 0) 31821da177e4SLinus Torvalds STp->partition = p; 31831da177e4SLinus Torvalds } else { 31841da177e4SLinus Torvalds if (STp->can_partitions) { 31851da177e4SLinus Torvalds STp->partition = partition; 31861da177e4SLinus Torvalds STps = &(STp->ps[partition]); 31871da177e4SLinus Torvalds if (!STps->last_block_valid || 31881da177e4SLinus Torvalds STps->last_block_visited != block) { 31891da177e4SLinus Torvalds STps->at_sm = 0; 31901da177e4SLinus Torvalds STps->rw = ST_IDLE; 31911da177e4SLinus Torvalds } 31921da177e4SLinus Torvalds } else 31931da177e4SLinus Torvalds STps->at_sm = 0; 31941da177e4SLinus Torvalds if (block == 0) 31951da177e4SLinus Torvalds STps->drv_block = STps->drv_file = 0; 31961da177e4SLinus Torvalds result = 0; 31971da177e4SLinus Torvalds } 319802ae2c0eSKai Makisara 31998b05b773SMike Christie st_release_request(SRpnt); 32001da177e4SLinus Torvalds SRpnt = NULL; 32011da177e4SLinus Torvalds 32021da177e4SLinus Torvalds return result; 32031da177e4SLinus Torvalds } 32041da177e4SLinus Torvalds 32051da177e4SLinus Torvalds 32061da177e4SLinus Torvalds /* Find the current partition number for the drive status. Called from open and 32071da177e4SLinus Torvalds returns either partition number of negative error code. */ 32081da177e4SLinus Torvalds static int find_partition(struct scsi_tape *STp) 32091da177e4SLinus Torvalds { 32101da177e4SLinus Torvalds int i, partition; 32111da177e4SLinus Torvalds unsigned int block; 32121da177e4SLinus Torvalds 32131da177e4SLinus Torvalds if ((i = get_location(STp, &block, &partition, 1)) < 0) 32141da177e4SLinus Torvalds return i; 32151da177e4SLinus Torvalds if (partition >= ST_NBR_PARTITIONS) 32161da177e4SLinus Torvalds return (-EIO); 32171da177e4SLinus Torvalds return partition; 32181da177e4SLinus Torvalds } 32191da177e4SLinus Torvalds 32201da177e4SLinus Torvalds 32211da177e4SLinus Torvalds /* Change the partition if necessary */ 32221da177e4SLinus Torvalds static int switch_partition(struct scsi_tape *STp) 32231da177e4SLinus Torvalds { 32241da177e4SLinus Torvalds struct st_partstat *STps; 32251da177e4SLinus Torvalds 32261da177e4SLinus Torvalds if (STp->partition == STp->new_partition) 32271da177e4SLinus Torvalds return 0; 32281da177e4SLinus Torvalds STps = &(STp->ps[STp->new_partition]); 32291da177e4SLinus Torvalds if (!STps->last_block_valid) 32301da177e4SLinus Torvalds STps->last_block_visited = 0; 32311da177e4SLinus Torvalds return set_location(STp, STps->last_block_visited, STp->new_partition, 1); 32321da177e4SLinus Torvalds } 32331da177e4SLinus Torvalds 32341da177e4SLinus Torvalds /* Functions for reading and writing the medium partition mode page. */ 32351da177e4SLinus Torvalds 32361da177e4SLinus Torvalds #define PART_PAGE 0x11 32371da177e4SLinus Torvalds #define PART_PAGE_FIXED_LENGTH 8 32381da177e4SLinus Torvalds 32391da177e4SLinus Torvalds #define PP_OFF_MAX_ADD_PARTS 2 32401da177e4SLinus Torvalds #define PP_OFF_NBR_ADD_PARTS 3 32411da177e4SLinus Torvalds #define PP_OFF_FLAGS 4 32421da177e4SLinus Torvalds #define PP_OFF_PART_UNITS 6 32431da177e4SLinus Torvalds #define PP_OFF_RESERVED 7 32441da177e4SLinus Torvalds 32451da177e4SLinus Torvalds #define PP_BIT_IDP 0x20 32461da177e4SLinus Torvalds #define PP_MSK_PSUM_MB 0x10 32471da177e4SLinus Torvalds 32481da177e4SLinus Torvalds /* Get the number of partitions on the tape. As a side effect reads the 32491da177e4SLinus Torvalds mode page into the tape buffer. */ 32501da177e4SLinus Torvalds static int nbr_partitions(struct scsi_tape *STp) 32511da177e4SLinus Torvalds { 32521da177e4SLinus Torvalds int result; 32531da177e4SLinus Torvalds 32541da177e4SLinus Torvalds if (STp->ready != ST_READY) 32551da177e4SLinus Torvalds return (-EIO); 32561da177e4SLinus Torvalds 32571da177e4SLinus Torvalds result = read_mode_page(STp, PART_PAGE, 1); 32581da177e4SLinus Torvalds 32591da177e4SLinus Torvalds if (result) { 3260b30d8bcaSHannes Reinecke DEBC_printk(STp, "Can't read medium partition page.\n"); 32611da177e4SLinus Torvalds result = (-EIO); 32621da177e4SLinus Torvalds } else { 32631da177e4SLinus Torvalds result = (STp->buffer)->b_data[MODE_HEADER_LENGTH + 32641da177e4SLinus Torvalds PP_OFF_NBR_ADD_PARTS] + 1; 3265b30d8bcaSHannes Reinecke DEBC_printk(STp, "Number of partitions %d.\n", result); 32661da177e4SLinus Torvalds } 32671da177e4SLinus Torvalds 32681da177e4SLinus Torvalds return result; 32691da177e4SLinus Torvalds } 32701da177e4SLinus Torvalds 32711da177e4SLinus Torvalds 32721da177e4SLinus Torvalds /* Partition the tape into two partitions if size > 0 or one partition if 32731da177e4SLinus Torvalds size == 0. 32741da177e4SLinus Torvalds 32751da177e4SLinus Torvalds The block descriptors are read and written because Sony SDT-7000 does not 32761da177e4SLinus Torvalds work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>). 32771da177e4SLinus Torvalds 32781da177e4SLinus Torvalds My HP C1533A drive returns only one partition size field. This is used to 32791da177e4SLinus Torvalds set the size of partition 1. There is no size field for the default partition. 32801da177e4SLinus Torvalds Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is 32811da177e4SLinus Torvalds used to set the size of partition 1 (this is what the SCSI-3 standard specifies). 32821da177e4SLinus Torvalds The following algorithm is used to accommodate both drives: if the number of 32831da177e4SLinus Torvalds partition size fields is greater than the maximum number of additional partitions 32841da177e4SLinus Torvalds in the mode page, the second field is used. Otherwise the first field is used. 32851da177e4SLinus Torvalds 32861da177e4SLinus Torvalds For Seagate DDS drives the page length must be 8 when no partitions is defined 32871da177e4SLinus Torvalds and 10 when 1 partition is defined (information from Eric Lee Green). This is 32881da177e4SLinus Torvalds is acceptable also to some other old drives and enforced if the first partition 32891da177e4SLinus Torvalds size field is used for the first additional partition size. 32901da177e4SLinus Torvalds */ 32911da177e4SLinus Torvalds static int partition_tape(struct scsi_tape *STp, int size) 32921da177e4SLinus Torvalds { 32931da177e4SLinus Torvalds int result; 32941da177e4SLinus Torvalds int pgo, psd_cnt, psdo; 32951da177e4SLinus Torvalds unsigned char *bp; 32961da177e4SLinus Torvalds 32971da177e4SLinus Torvalds result = read_mode_page(STp, PART_PAGE, 0); 32981da177e4SLinus Torvalds if (result) { 3299b30d8bcaSHannes Reinecke DEBC_printk(STp, "Can't read partition mode page.\n"); 33001da177e4SLinus Torvalds return result; 33011da177e4SLinus Torvalds } 33021da177e4SLinus Torvalds /* The mode page is in the buffer. Let's modify it and write it. */ 33031da177e4SLinus Torvalds bp = (STp->buffer)->b_data; 33041da177e4SLinus Torvalds pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH]; 3305b30d8bcaSHannes Reinecke DEBC_printk(STp, "Partition page length is %d bytes.\n", 3306b30d8bcaSHannes Reinecke bp[pgo + MP_OFF_PAGE_LENGTH] + 2); 33071da177e4SLinus Torvalds 33081da177e4SLinus Torvalds psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2; 33091da177e4SLinus Torvalds psdo = pgo + PART_PAGE_FIXED_LENGTH; 33101da177e4SLinus Torvalds if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) { 33111da177e4SLinus Torvalds bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */ 33121da177e4SLinus Torvalds psdo += 2; 33131da177e4SLinus Torvalds } 33141da177e4SLinus Torvalds memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2); 33151da177e4SLinus Torvalds 3316b30d8bcaSHannes Reinecke DEBC_printk(STp, "psd_cnt %d, max.parts %d, nbr_parts %d\n", 33171da177e4SLinus Torvalds psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS], 3318b30d8bcaSHannes Reinecke bp[pgo + PP_OFF_NBR_ADD_PARTS]); 33191da177e4SLinus Torvalds 33201da177e4SLinus Torvalds if (size <= 0) { 33211da177e4SLinus Torvalds bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0; 33221da177e4SLinus Torvalds if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS]) 33231da177e4SLinus Torvalds bp[pgo + MP_OFF_PAGE_LENGTH] = 6; 3324b30d8bcaSHannes Reinecke DEBC_printk(STp, "Formatting tape with one partition.\n"); 33251da177e4SLinus Torvalds } else { 33261da177e4SLinus Torvalds bp[psdo] = (size >> 8) & 0xff; 33271da177e4SLinus Torvalds bp[psdo + 1] = size & 0xff; 33281da177e4SLinus Torvalds bp[pgo + 3] = 1; 33291da177e4SLinus Torvalds if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8) 33301da177e4SLinus Torvalds bp[pgo + MP_OFF_PAGE_LENGTH] = 8; 3331b30d8bcaSHannes Reinecke DEBC_printk(STp, "Formatting tape with two partitions " 3332b30d8bcaSHannes Reinecke "(1 = %d MB).\n", size); 33331da177e4SLinus Torvalds } 33341da177e4SLinus Torvalds bp[pgo + PP_OFF_PART_UNITS] = 0; 33351da177e4SLinus Torvalds bp[pgo + PP_OFF_RESERVED] = 0; 33361da177e4SLinus Torvalds bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB; 33371da177e4SLinus Torvalds 33381da177e4SLinus Torvalds result = write_mode_page(STp, PART_PAGE, 1); 33391da177e4SLinus Torvalds if (result) { 3340b30d8bcaSHannes Reinecke st_printk(KERN_INFO, STp, "Partitioning of tape failed.\n"); 33411da177e4SLinus Torvalds result = (-EIO); 33421da177e4SLinus Torvalds } 33431da177e4SLinus Torvalds 33441da177e4SLinus Torvalds return result; 33451da177e4SLinus Torvalds } 33461da177e4SLinus Torvalds 33471da177e4SLinus Torvalds 33481da177e4SLinus Torvalds 33491da177e4SLinus Torvalds /* The ioctl command */ 3350fd66c1b4SKai Makisara static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) 33511da177e4SLinus Torvalds { 33521da177e4SLinus Torvalds int i, cmd_nr, cmd_type, bt; 33531da177e4SLinus Torvalds int retval = 0; 33541da177e4SLinus Torvalds unsigned int blk; 33551da177e4SLinus Torvalds struct scsi_tape *STp = file->private_data; 33561da177e4SLinus Torvalds struct st_modedef *STm; 33571da177e4SLinus Torvalds struct st_partstat *STps; 33581da177e4SLinus Torvalds void __user *p = (void __user *)arg; 33591da177e4SLinus Torvalds 336028f85009SMatthias Kaehlcke if (mutex_lock_interruptible(&STp->lock)) 33611da177e4SLinus Torvalds return -ERESTARTSYS; 33621da177e4SLinus Torvalds 33631da177e4SLinus Torvalds DEB( 33641da177e4SLinus Torvalds if (debugging && !STp->in_use) { 3365b30d8bcaSHannes Reinecke st_printk(ST_DEB_MSG, STp, "Incorrect device.\n"); 33661da177e4SLinus Torvalds retval = (-EIO); 33671da177e4SLinus Torvalds goto out; 33681da177e4SLinus Torvalds } ) /* end DEB */ 33691da177e4SLinus Torvalds 33701da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 33711da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 33721da177e4SLinus Torvalds 33731da177e4SLinus Torvalds /* 33741da177e4SLinus Torvalds * If we are in the middle of error recovery, don't let anyone 33751da177e4SLinus Torvalds * else try and use this device. Also, if error recovery fails, it 33761da177e4SLinus Torvalds * may try and take the device offline, in which case all further 33771da177e4SLinus Torvalds * access to the device is prohibited. 33781da177e4SLinus Torvalds */ 3379906d15fbSChristoph Hellwig retval = scsi_ioctl_block_when_processing_errors(STp->device, cmd_in, 338083ff6fe8SAl Viro file->f_flags & O_NDELAY); 3381906d15fbSChristoph Hellwig if (retval) 33821da177e4SLinus Torvalds goto out; 33831da177e4SLinus Torvalds 33841da177e4SLinus Torvalds cmd_type = _IOC_TYPE(cmd_in); 33851da177e4SLinus Torvalds cmd_nr = _IOC_NR(cmd_in); 33861da177e4SLinus Torvalds 33871da177e4SLinus Torvalds if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) { 33881da177e4SLinus Torvalds struct mtop mtc; 33891da177e4SLinus Torvalds 33901da177e4SLinus Torvalds if (_IOC_SIZE(cmd_in) != sizeof(mtc)) { 33911da177e4SLinus Torvalds retval = (-EINVAL); 33921da177e4SLinus Torvalds goto out; 33931da177e4SLinus Torvalds } 33941da177e4SLinus Torvalds 33951da177e4SLinus Torvalds i = copy_from_user(&mtc, p, sizeof(struct mtop)); 33961da177e4SLinus Torvalds if (i) { 33971da177e4SLinus Torvalds retval = (-EFAULT); 33981da177e4SLinus Torvalds goto out; 33991da177e4SLinus Torvalds } 34001da177e4SLinus Torvalds 34011da177e4SLinus Torvalds if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) { 3402b30d8bcaSHannes Reinecke st_printk(KERN_WARNING, STp, 3403b30d8bcaSHannes Reinecke "MTSETDRVBUFFER only allowed for root.\n"); 34041da177e4SLinus Torvalds retval = (-EPERM); 34051da177e4SLinus Torvalds goto out; 34061da177e4SLinus Torvalds } 34071da177e4SLinus Torvalds if (!STm->defined && 34081da177e4SLinus Torvalds (mtc.mt_op != MTSETDRVBUFFER && 34091da177e4SLinus Torvalds (mtc.mt_count & MT_ST_OPTIONS) == 0)) { 34101da177e4SLinus Torvalds retval = (-ENXIO); 34111da177e4SLinus Torvalds goto out; 34121da177e4SLinus Torvalds } 34131da177e4SLinus Torvalds 34141da177e4SLinus Torvalds if (!STp->pos_unknown) { 34151da177e4SLinus Torvalds 34161da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) { 34171da177e4SLinus Torvalds if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 34181da177e4SLinus Torvalds mtc.mt_op == MTEOM) { 34191da177e4SLinus Torvalds mtc.mt_count -= 1; 34201da177e4SLinus Torvalds if (STps->drv_file >= 0) 34211da177e4SLinus Torvalds STps->drv_file += 1; 34221da177e4SLinus Torvalds } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) { 34231da177e4SLinus Torvalds mtc.mt_count += 1; 34241da177e4SLinus Torvalds if (STps->drv_file >= 0) 34251da177e4SLinus Torvalds STps->drv_file += 1; 34261da177e4SLinus Torvalds } 34271da177e4SLinus Torvalds } 34281da177e4SLinus Torvalds 34291da177e4SLinus Torvalds if (mtc.mt_op == MTSEEK) { 34301da177e4SLinus Torvalds /* Old position must be restored if partition will be 34311da177e4SLinus Torvalds changed */ 34321da177e4SLinus Torvalds i = !STp->can_partitions || 34331da177e4SLinus Torvalds (STp->new_partition != STp->partition); 34341da177e4SLinus Torvalds } else { 34351da177e4SLinus Torvalds i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 34361da177e4SLinus Torvalds mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM || 34371da177e4SLinus Torvalds mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD || 34381da177e4SLinus Torvalds mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 34391da177e4SLinus Torvalds mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM || 34401da177e4SLinus Torvalds mtc.mt_op == MTCOMPRESSION; 34411da177e4SLinus Torvalds } 34421da177e4SLinus Torvalds i = flush_buffer(STp, i); 34431da177e4SLinus Torvalds if (i < 0) { 34441da177e4SLinus Torvalds retval = i; 34451da177e4SLinus Torvalds goto out; 34461da177e4SLinus Torvalds } 34471da177e4SLinus Torvalds if (STps->rw == ST_WRITING && 34481da177e4SLinus Torvalds (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 34491da177e4SLinus Torvalds mtc.mt_op == MTSEEK || 34501da177e4SLinus Torvalds mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) { 34511da177e4SLinus Torvalds i = st_int_ioctl(STp, MTWEOF, 1); 34521da177e4SLinus Torvalds if (i < 0) { 34531da177e4SLinus Torvalds retval = i; 34541da177e4SLinus Torvalds goto out; 34551da177e4SLinus Torvalds } 34561da177e4SLinus Torvalds if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) 34571da177e4SLinus Torvalds mtc.mt_count++; 34581da177e4SLinus Torvalds STps->rw = ST_IDLE; 34591da177e4SLinus Torvalds } 34601da177e4SLinus Torvalds 34611da177e4SLinus Torvalds } else { 34621da177e4SLinus Torvalds /* 34631da177e4SLinus Torvalds * If there was a bus reset, block further access 34641da177e4SLinus Torvalds * to this device. If the user wants to rewind the tape, 34651da177e4SLinus Torvalds * then reset the flag and allow access again. 34661da177e4SLinus Torvalds */ 34671da177e4SLinus Torvalds if (mtc.mt_op != MTREW && 34681da177e4SLinus Torvalds mtc.mt_op != MTOFFL && 34691da177e4SLinus Torvalds mtc.mt_op != MTRETEN && 34701da177e4SLinus Torvalds mtc.mt_op != MTERASE && 34711da177e4SLinus Torvalds mtc.mt_op != MTSEEK && 34721da177e4SLinus Torvalds mtc.mt_op != MTEOM) { 34731da177e4SLinus Torvalds retval = (-EIO); 34741da177e4SLinus Torvalds goto out; 34751da177e4SLinus Torvalds } 34761da177e4SLinus Torvalds reset_state(STp); 34771da177e4SLinus Torvalds /* remove this when the midlevel properly clears was_reset */ 34781da177e4SLinus Torvalds STp->device->was_reset = 0; 34791da177e4SLinus Torvalds } 34801da177e4SLinus Torvalds 34811da177e4SLinus Torvalds if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK && 34821da177e4SLinus Torvalds mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM && 34831da177e4SLinus Torvalds mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART) 34841da177e4SLinus Torvalds STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */ 34851da177e4SLinus Torvalds 34861da177e4SLinus Torvalds if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED) 34871da177e4SLinus Torvalds do_door_lock(STp, 0); /* Ignore result! */ 34881da177e4SLinus Torvalds 34891da177e4SLinus Torvalds if (mtc.mt_op == MTSETDRVBUFFER && 34901da177e4SLinus Torvalds (mtc.mt_count & MT_ST_OPTIONS) != 0) { 34911da177e4SLinus Torvalds retval = st_set_options(STp, mtc.mt_count); 34921da177e4SLinus Torvalds goto out; 34931da177e4SLinus Torvalds } 34941da177e4SLinus Torvalds 34951da177e4SLinus Torvalds if (mtc.mt_op == MTSETPART) { 34961da177e4SLinus Torvalds if (!STp->can_partitions || 34971da177e4SLinus Torvalds mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) { 34981da177e4SLinus Torvalds retval = (-EINVAL); 34991da177e4SLinus Torvalds goto out; 35001da177e4SLinus Torvalds } 35011da177e4SLinus Torvalds if (mtc.mt_count >= STp->nbr_partitions && 35021da177e4SLinus Torvalds (STp->nbr_partitions = nbr_partitions(STp)) < 0) { 35031da177e4SLinus Torvalds retval = (-EIO); 35041da177e4SLinus Torvalds goto out; 35051da177e4SLinus Torvalds } 35061da177e4SLinus Torvalds if (mtc.mt_count >= STp->nbr_partitions) { 35071da177e4SLinus Torvalds retval = (-EINVAL); 35081da177e4SLinus Torvalds goto out; 35091da177e4SLinus Torvalds } 35101da177e4SLinus Torvalds STp->new_partition = mtc.mt_count; 35111da177e4SLinus Torvalds retval = 0; 35121da177e4SLinus Torvalds goto out; 35131da177e4SLinus Torvalds } 35141da177e4SLinus Torvalds 35151da177e4SLinus Torvalds if (mtc.mt_op == MTMKPART) { 35161da177e4SLinus Torvalds if (!STp->can_partitions) { 35171da177e4SLinus Torvalds retval = (-EINVAL); 35181da177e4SLinus Torvalds goto out; 35191da177e4SLinus Torvalds } 35201da177e4SLinus Torvalds if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 || 35211da177e4SLinus Torvalds (i = partition_tape(STp, mtc.mt_count)) < 0) { 35221da177e4SLinus Torvalds retval = i; 35231da177e4SLinus Torvalds goto out; 35241da177e4SLinus Torvalds } 35251da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 35261da177e4SLinus Torvalds STp->ps[i].rw = ST_IDLE; 35271da177e4SLinus Torvalds STp->ps[i].at_sm = 0; 35281da177e4SLinus Torvalds STp->ps[i].last_block_valid = 0; 35291da177e4SLinus Torvalds } 35301da177e4SLinus Torvalds STp->partition = STp->new_partition = 0; 35311da177e4SLinus Torvalds STp->nbr_partitions = 1; /* Bad guess ?-) */ 35321da177e4SLinus Torvalds STps->drv_block = STps->drv_file = 0; 35331da177e4SLinus Torvalds retval = 0; 35341da177e4SLinus Torvalds goto out; 35351da177e4SLinus Torvalds } 35361da177e4SLinus Torvalds 35371da177e4SLinus Torvalds if (mtc.mt_op == MTSEEK) { 35381da177e4SLinus Torvalds i = set_location(STp, mtc.mt_count, STp->new_partition, 0); 35391da177e4SLinus Torvalds if (!STp->can_partitions) 35401da177e4SLinus Torvalds STp->ps[0].rw = ST_IDLE; 35411da177e4SLinus Torvalds retval = i; 35421da177e4SLinus Torvalds goto out; 35431da177e4SLinus Torvalds } 35441da177e4SLinus Torvalds 35451da177e4SLinus Torvalds if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) { 35461da177e4SLinus Torvalds retval = do_load_unload(STp, file, 0); 35471da177e4SLinus Torvalds goto out; 35481da177e4SLinus Torvalds } 35491da177e4SLinus Torvalds 35501da177e4SLinus Torvalds if (mtc.mt_op == MTLOAD) { 35511da177e4SLinus Torvalds retval = do_load_unload(STp, file, max(1, mtc.mt_count)); 35521da177e4SLinus Torvalds goto out; 35531da177e4SLinus Torvalds } 35541da177e4SLinus Torvalds 35551da177e4SLinus Torvalds if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) { 35561da177e4SLinus Torvalds retval = do_door_lock(STp, (mtc.mt_op == MTLOCK)); 35571da177e4SLinus Torvalds goto out; 35581da177e4SLinus Torvalds } 35591da177e4SLinus Torvalds 35601da177e4SLinus Torvalds if (STp->can_partitions && STp->ready == ST_READY && 35611da177e4SLinus Torvalds (i = switch_partition(STp)) < 0) { 35621da177e4SLinus Torvalds retval = i; 35631da177e4SLinus Torvalds goto out; 35641da177e4SLinus Torvalds } 35651da177e4SLinus Torvalds 35661da177e4SLinus Torvalds if (mtc.mt_op == MTCOMPRESSION) 35671da177e4SLinus Torvalds retval = st_compression(STp, (mtc.mt_count & 1)); 35681da177e4SLinus Torvalds else 35691da177e4SLinus Torvalds retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count); 35701da177e4SLinus Torvalds goto out; 35711da177e4SLinus Torvalds } 35721da177e4SLinus Torvalds if (!STm->defined) { 35731da177e4SLinus Torvalds retval = (-ENXIO); 35741da177e4SLinus Torvalds goto out; 35751da177e4SLinus Torvalds } 35761da177e4SLinus Torvalds 35771da177e4SLinus Torvalds if ((i = flush_buffer(STp, 0)) < 0) { 35781da177e4SLinus Torvalds retval = i; 35791da177e4SLinus Torvalds goto out; 35801da177e4SLinus Torvalds } 35811da177e4SLinus Torvalds if (STp->can_partitions && 35821da177e4SLinus Torvalds (i = switch_partition(STp)) < 0) { 35831da177e4SLinus Torvalds retval = i; 35841da177e4SLinus Torvalds goto out; 35851da177e4SLinus Torvalds } 35861da177e4SLinus Torvalds 35871da177e4SLinus Torvalds if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) { 35881da177e4SLinus Torvalds struct mtget mt_status; 35891da177e4SLinus Torvalds 35901da177e4SLinus Torvalds if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) { 35911da177e4SLinus Torvalds retval = (-EINVAL); 35921da177e4SLinus Torvalds goto out; 35931da177e4SLinus Torvalds } 35941da177e4SLinus Torvalds 35951da177e4SLinus Torvalds mt_status.mt_type = STp->tape_type; 35961da177e4SLinus Torvalds mt_status.mt_dsreg = 35971da177e4SLinus Torvalds ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) | 35981da177e4SLinus Torvalds ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK); 35991da177e4SLinus Torvalds mt_status.mt_blkno = STps->drv_block; 36001da177e4SLinus Torvalds mt_status.mt_fileno = STps->drv_file; 36011da177e4SLinus Torvalds if (STp->block_size != 0) { 36021da177e4SLinus Torvalds if (STps->rw == ST_WRITING) 36031da177e4SLinus Torvalds mt_status.mt_blkno += 36041da177e4SLinus Torvalds (STp->buffer)->buffer_bytes / STp->block_size; 36051da177e4SLinus Torvalds else if (STps->rw == ST_READING) 36061da177e4SLinus Torvalds mt_status.mt_blkno -= 36071da177e4SLinus Torvalds ((STp->buffer)->buffer_bytes + 36081da177e4SLinus Torvalds STp->block_size - 1) / STp->block_size; 36091da177e4SLinus Torvalds } 36101da177e4SLinus Torvalds 36111da177e4SLinus Torvalds mt_status.mt_gstat = 0; 36121da177e4SLinus Torvalds if (STp->drv_write_prot) 36131da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff); 36141da177e4SLinus Torvalds if (mt_status.mt_blkno == 0) { 36151da177e4SLinus Torvalds if (mt_status.mt_fileno == 0) 36161da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_BOT(0xffffffff); 36171da177e4SLinus Torvalds else 36181da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_EOF(0xffffffff); 36191da177e4SLinus Torvalds } 36201da177e4SLinus Torvalds mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT); 36211da177e4SLinus Torvalds mt_status.mt_resid = STp->partition; 36221da177e4SLinus Torvalds if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR) 36231da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_EOT(0xffffffff); 36241da177e4SLinus Torvalds else if (STps->eof >= ST_EOM_OK) 36251da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_EOD(0xffffffff); 36261da177e4SLinus Torvalds if (STp->density == 1) 36271da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_D_800(0xffffffff); 36281da177e4SLinus Torvalds else if (STp->density == 2) 36291da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_D_1600(0xffffffff); 36301da177e4SLinus Torvalds else if (STp->density == 3) 36311da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_D_6250(0xffffffff); 36321da177e4SLinus Torvalds if (STp->ready == ST_READY) 36331da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_ONLINE(0xffffffff); 36341da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 36351da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff); 36361da177e4SLinus Torvalds if (STps->at_sm) 36371da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_SM(0xffffffff); 36381da177e4SLinus Torvalds if (STm->do_async_writes || 36391da177e4SLinus Torvalds (STm->do_buffer_writes && STp->block_size != 0) || 36401da177e4SLinus Torvalds STp->drv_buffer != 0) 36411da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff); 36421da177e4SLinus Torvalds if (STp->cleaning_req) 36431da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_CLN(0xffffffff); 36441da177e4SLinus Torvalds 36451da177e4SLinus Torvalds i = copy_to_user(p, &mt_status, sizeof(struct mtget)); 36461da177e4SLinus Torvalds if (i) { 36471da177e4SLinus Torvalds retval = (-EFAULT); 36481da177e4SLinus Torvalds goto out; 36491da177e4SLinus Torvalds } 36501da177e4SLinus Torvalds 36511da177e4SLinus Torvalds STp->recover_reg = 0; /* Clear after read */ 36521da177e4SLinus Torvalds retval = 0; 36531da177e4SLinus Torvalds goto out; 36541da177e4SLinus Torvalds } /* End of MTIOCGET */ 36551da177e4SLinus Torvalds if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) { 36561da177e4SLinus Torvalds struct mtpos mt_pos; 36571da177e4SLinus Torvalds if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) { 36581da177e4SLinus Torvalds retval = (-EINVAL); 36591da177e4SLinus Torvalds goto out; 36601da177e4SLinus Torvalds } 36611da177e4SLinus Torvalds if ((i = get_location(STp, &blk, &bt, 0)) < 0) { 36621da177e4SLinus Torvalds retval = i; 36631da177e4SLinus Torvalds goto out; 36641da177e4SLinus Torvalds } 36651da177e4SLinus Torvalds mt_pos.mt_blkno = blk; 36661da177e4SLinus Torvalds i = copy_to_user(p, &mt_pos, sizeof(struct mtpos)); 36671da177e4SLinus Torvalds if (i) 36681da177e4SLinus Torvalds retval = (-EFAULT); 36691da177e4SLinus Torvalds goto out; 36701da177e4SLinus Torvalds } 367128f85009SMatthias Kaehlcke mutex_unlock(&STp->lock); 36721da177e4SLinus Torvalds switch (cmd_in) { 36731da177e4SLinus Torvalds case SCSI_IOCTL_GET_IDLUN: 36741da177e4SLinus Torvalds case SCSI_IOCTL_GET_BUS_NUMBER: 36751da177e4SLinus Torvalds break; 36761da177e4SLinus Torvalds default: 367716c4b3e2SKai Makisara if ((cmd_in == SG_IO || 367816c4b3e2SKai Makisara cmd_in == SCSI_IOCTL_SEND_COMMAND || 367916c4b3e2SKai Makisara cmd_in == CDROM_SEND_PACKET) && 368016c4b3e2SKai Makisara !capable(CAP_SYS_RAWIO)) 36811da177e4SLinus Torvalds i = -EPERM; 36821da177e4SLinus Torvalds else 368374f3c8afSAl Viro i = scsi_cmd_ioctl(STp->disk->queue, STp->disk, 368474f3c8afSAl Viro file->f_mode, cmd_in, p); 36851da177e4SLinus Torvalds if (i != -ENOTTY) 36861da177e4SLinus Torvalds return i; 36871da177e4SLinus Torvalds break; 36881da177e4SLinus Torvalds } 368916c4b3e2SKai Makisara retval = scsi_ioctl(STp->device, cmd_in, p); 369016c4b3e2SKai Makisara if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */ 369116c4b3e2SKai Makisara STp->rew_at_close = 0; 369216c4b3e2SKai Makisara STp->ready = ST_NO_TAPE; 369316c4b3e2SKai Makisara } 369416c4b3e2SKai Makisara return retval; 36951da177e4SLinus Torvalds 36961da177e4SLinus Torvalds out: 369728f85009SMatthias Kaehlcke mutex_unlock(&STp->lock); 36981da177e4SLinus Torvalds return retval; 36991da177e4SLinus Torvalds } 37001da177e4SLinus Torvalds 37011da177e4SLinus Torvalds #ifdef CONFIG_COMPAT 37021da177e4SLinus Torvalds static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 37031da177e4SLinus Torvalds { 37041da177e4SLinus Torvalds struct scsi_tape *STp = file->private_data; 37051da177e4SLinus Torvalds struct scsi_device *sdev = STp->device; 37061da177e4SLinus Torvalds int ret = -ENOIOCTLCMD; 37071da177e4SLinus Torvalds if (sdev->host->hostt->compat_ioctl) { 37081da177e4SLinus Torvalds 37091da177e4SLinus Torvalds ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg); 37101da177e4SLinus Torvalds 37111da177e4SLinus Torvalds } 37121da177e4SLinus Torvalds return ret; 37131da177e4SLinus Torvalds } 37141da177e4SLinus Torvalds #endif 37151da177e4SLinus Torvalds 37161da177e4SLinus Torvalds 37171da177e4SLinus Torvalds 37181da177e4SLinus Torvalds /* Try to allocate a new tape buffer. Calling function must not hold 37191da177e4SLinus Torvalds dev_arr_lock. */ 3720f409d6ccSFUJITA Tomonori static struct st_buffer *new_tape_buffer(int need_dma, int max_sg) 37211da177e4SLinus Torvalds { 37221da177e4SLinus Torvalds struct st_buffer *tb; 37231da177e4SLinus Torvalds 3724f409d6ccSFUJITA Tomonori tb = kzalloc(sizeof(struct st_buffer), GFP_ATOMIC); 37251da177e4SLinus Torvalds if (!tb) { 37261da177e4SLinus Torvalds printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n"); 37271da177e4SLinus Torvalds return NULL; 37281da177e4SLinus Torvalds } 37291ac63cf5SFUJITA Tomonori tb->frp_segs = 0; 37301da177e4SLinus Torvalds tb->use_sg = max_sg; 37311da177e4SLinus Torvalds tb->dma = need_dma; 3732f409d6ccSFUJITA Tomonori tb->buffer_size = 0; 37331da177e4SLinus Torvalds 3734f409d6ccSFUJITA Tomonori tb->reserved_pages = kzalloc(max_sg * sizeof(struct page *), 3735f409d6ccSFUJITA Tomonori GFP_ATOMIC); 3736d0e1ae31SFUJITA Tomonori if (!tb->reserved_pages) { 3737d0e1ae31SFUJITA Tomonori kfree(tb); 3738d0e1ae31SFUJITA Tomonori return NULL; 3739d0e1ae31SFUJITA Tomonori } 3740d0e1ae31SFUJITA Tomonori 37411da177e4SLinus Torvalds return tb; 37421da177e4SLinus Torvalds } 37431da177e4SLinus Torvalds 37441da177e4SLinus Torvalds 37451da177e4SLinus Torvalds /* Try to allocate enough space in the tape buffer */ 37468f78fc5eSKai Makisara #define ST_MAX_ORDER 6 37478f78fc5eSKai Makisara 37481da177e4SLinus Torvalds static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma) 37491da177e4SLinus Torvalds { 3750769989a4SBodo Stroesser int segs, max_segs, b_size, order, got; 3751c53033f6SAl Viro gfp_t priority; 37521da177e4SLinus Torvalds 37531da177e4SLinus Torvalds if (new_size <= STbuffer->buffer_size) 37541da177e4SLinus Torvalds return 1; 37551da177e4SLinus Torvalds 37561da177e4SLinus Torvalds if (STbuffer->buffer_size <= PAGE_SIZE) 37571da177e4SLinus Torvalds normalize_buffer(STbuffer); /* Avoid extra segment */ 37581da177e4SLinus Torvalds 37591da177e4SLinus Torvalds max_segs = STbuffer->use_sg; 37601da177e4SLinus Torvalds 37611da177e4SLinus Torvalds priority = GFP_KERNEL | __GFP_NOWARN; 37621da177e4SLinus Torvalds if (need_dma) 37631da177e4SLinus Torvalds priority |= GFP_DMA; 37649c905966SFUJITA Tomonori 376508c95832SFUJITA Tomonori if (STbuffer->cleared) 376608c95832SFUJITA Tomonori priority |= __GFP_ZERO; 376708c95832SFUJITA Tomonori 37689c905966SFUJITA Tomonori if (STbuffer->frp_segs) { 3769c982c368SFUJITA Tomonori order = STbuffer->reserved_page_order; 377008c95832SFUJITA Tomonori b_size = PAGE_SIZE << order; 37719c905966SFUJITA Tomonori } else { 37729c905966SFUJITA Tomonori for (b_size = PAGE_SIZE, order = 0; 377346081b16SFUJITA Tomonori order < ST_MAX_ORDER && 377446081b16SFUJITA Tomonori max_segs * (PAGE_SIZE << order) < new_size; 37758f78fc5eSKai Makisara order++, b_size *= 2) 37761da177e4SLinus Torvalds ; /* empty */ 3777373daacfSKai Makisara STbuffer->reserved_page_order = order; 37789c905966SFUJITA Tomonori } 37798f78fc5eSKai Makisara if (max_segs * (PAGE_SIZE << order) < new_size) { 37808f78fc5eSKai Makisara if (order == ST_MAX_ORDER) 37818f78fc5eSKai Makisara return 0; 37828f78fc5eSKai Makisara normalize_buffer(STbuffer); 37838f78fc5eSKai Makisara return enlarge_buffer(STbuffer, new_size, need_dma); 37848f78fc5eSKai Makisara } 37851da177e4SLinus Torvalds 37861da177e4SLinus Torvalds for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size; 37871da177e4SLinus Torvalds segs < max_segs && got < new_size;) { 378808c95832SFUJITA Tomonori struct page *page; 378908c95832SFUJITA Tomonori 379008c95832SFUJITA Tomonori page = alloc_pages(priority, order); 379108c95832SFUJITA Tomonori if (!page) { 37921da177e4SLinus Torvalds DEB(STbuffer->buffer_size = got); 37931da177e4SLinus Torvalds normalize_buffer(STbuffer); 37941da177e4SLinus Torvalds return 0; 37951da177e4SLinus Torvalds } 379608c95832SFUJITA Tomonori 37971da177e4SLinus Torvalds STbuffer->frp_segs += 1; 37981da177e4SLinus Torvalds got += b_size; 37991da177e4SLinus Torvalds STbuffer->buffer_size = got; 380008c95832SFUJITA Tomonori STbuffer->reserved_pages[segs] = page; 38011da177e4SLinus Torvalds segs++; 38021da177e4SLinus Torvalds } 380308c95832SFUJITA Tomonori STbuffer->b_data = page_address(STbuffer->reserved_pages[0]); 38041da177e4SLinus Torvalds 38051da177e4SLinus Torvalds return 1; 38061da177e4SLinus Torvalds } 38071da177e4SLinus Torvalds 38081da177e4SLinus Torvalds 380940f6b36cSKai Makisara /* Make sure that no data from previous user is in the internal buffer */ 381040f6b36cSKai Makisara static void clear_buffer(struct st_buffer * st_bp) 381140f6b36cSKai Makisara { 381240f6b36cSKai Makisara int i; 381340f6b36cSKai Makisara 381440f6b36cSKai Makisara for (i=0; i < st_bp->frp_segs; i++) 381508c95832SFUJITA Tomonori memset(page_address(st_bp->reserved_pages[i]), 0, 3816c982c368SFUJITA Tomonori PAGE_SIZE << st_bp->reserved_page_order); 381740f6b36cSKai Makisara st_bp->cleared = 1; 381840f6b36cSKai Makisara } 381940f6b36cSKai Makisara 382040f6b36cSKai Makisara 38211da177e4SLinus Torvalds /* Release the extra buffer */ 38221da177e4SLinus Torvalds static void normalize_buffer(struct st_buffer * STbuffer) 38231da177e4SLinus Torvalds { 3824c982c368SFUJITA Tomonori int i, order = STbuffer->reserved_page_order; 38251da177e4SLinus Torvalds 38261ac63cf5SFUJITA Tomonori for (i = 0; i < STbuffer->frp_segs; i++) { 382708c95832SFUJITA Tomonori __free_pages(STbuffer->reserved_pages[i], order); 382808c95832SFUJITA Tomonori STbuffer->buffer_size -= (PAGE_SIZE << order); 38291da177e4SLinus Torvalds } 38301ac63cf5SFUJITA Tomonori STbuffer->frp_segs = 0; 38318b05b773SMike Christie STbuffer->sg_segs = 0; 3832c982c368SFUJITA Tomonori STbuffer->reserved_page_order = 0; 3833d0e1ae31SFUJITA Tomonori STbuffer->map_data.offset = 0; 38341da177e4SLinus Torvalds } 38351da177e4SLinus Torvalds 38361da177e4SLinus Torvalds 38371da177e4SLinus Torvalds /* Move data from the user buffer to the tape buffer. Returns zero (success) or 38381da177e4SLinus Torvalds negative error code. */ 38391da177e4SLinus Torvalds static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count) 38401da177e4SLinus Torvalds { 38411da177e4SLinus Torvalds int i, cnt, res, offset; 3842c982c368SFUJITA Tomonori int length = PAGE_SIZE << st_bp->reserved_page_order; 38431da177e4SLinus Torvalds 38441da177e4SLinus Torvalds for (i = 0, offset = st_bp->buffer_bytes; 384508c95832SFUJITA Tomonori i < st_bp->frp_segs && offset >= length; i++) 384608c95832SFUJITA Tomonori offset -= length; 38471da177e4SLinus Torvalds if (i == st_bp->frp_segs) { /* Should never happen */ 38481da177e4SLinus Torvalds printk(KERN_WARNING "st: append_to_buffer offset overflow.\n"); 38491da177e4SLinus Torvalds return (-EIO); 38501da177e4SLinus Torvalds } 38511da177e4SLinus Torvalds for (; i < st_bp->frp_segs && do_count > 0; i++) { 385208c95832SFUJITA Tomonori struct page *page = st_bp->reserved_pages[i]; 385308c95832SFUJITA Tomonori cnt = length - offset < do_count ? length - offset : do_count; 385408c95832SFUJITA Tomonori res = copy_from_user(page_address(page) + offset, ubp, cnt); 38551da177e4SLinus Torvalds if (res) 38561da177e4SLinus Torvalds return (-EFAULT); 38571da177e4SLinus Torvalds do_count -= cnt; 38581da177e4SLinus Torvalds st_bp->buffer_bytes += cnt; 38591da177e4SLinus Torvalds ubp += cnt; 38601da177e4SLinus Torvalds offset = 0; 38611da177e4SLinus Torvalds } 38621da177e4SLinus Torvalds if (do_count) /* Should never happen */ 38631da177e4SLinus Torvalds return (-EIO); 38641da177e4SLinus Torvalds 38651da177e4SLinus Torvalds return 0; 38661da177e4SLinus Torvalds } 38671da177e4SLinus Torvalds 38681da177e4SLinus Torvalds 38691da177e4SLinus Torvalds /* Move data from the tape buffer to the user buffer. Returns zero (success) or 38701da177e4SLinus Torvalds negative error code. */ 38711da177e4SLinus Torvalds static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count) 38721da177e4SLinus Torvalds { 38731da177e4SLinus Torvalds int i, cnt, res, offset; 3874c982c368SFUJITA Tomonori int length = PAGE_SIZE << st_bp->reserved_page_order; 38751da177e4SLinus Torvalds 38761da177e4SLinus Torvalds for (i = 0, offset = st_bp->read_pointer; 387708c95832SFUJITA Tomonori i < st_bp->frp_segs && offset >= length; i++) 387808c95832SFUJITA Tomonori offset -= length; 38791da177e4SLinus Torvalds if (i == st_bp->frp_segs) { /* Should never happen */ 38801da177e4SLinus Torvalds printk(KERN_WARNING "st: from_buffer offset overflow.\n"); 38811da177e4SLinus Torvalds return (-EIO); 38821da177e4SLinus Torvalds } 38831da177e4SLinus Torvalds for (; i < st_bp->frp_segs && do_count > 0; i++) { 388408c95832SFUJITA Tomonori struct page *page = st_bp->reserved_pages[i]; 388508c95832SFUJITA Tomonori cnt = length - offset < do_count ? length - offset : do_count; 388608c95832SFUJITA Tomonori res = copy_to_user(ubp, page_address(page) + offset, cnt); 38871da177e4SLinus Torvalds if (res) 38881da177e4SLinus Torvalds return (-EFAULT); 38891da177e4SLinus Torvalds do_count -= cnt; 38901da177e4SLinus Torvalds st_bp->buffer_bytes -= cnt; 38911da177e4SLinus Torvalds st_bp->read_pointer += cnt; 38921da177e4SLinus Torvalds ubp += cnt; 38931da177e4SLinus Torvalds offset = 0; 38941da177e4SLinus Torvalds } 38951da177e4SLinus Torvalds if (do_count) /* Should never happen */ 38961da177e4SLinus Torvalds return (-EIO); 38971da177e4SLinus Torvalds 38981da177e4SLinus Torvalds return 0; 38991da177e4SLinus Torvalds } 39001da177e4SLinus Torvalds 39011da177e4SLinus Torvalds 39021da177e4SLinus Torvalds /* Move data towards start of buffer */ 39031da177e4SLinus Torvalds static void move_buffer_data(struct st_buffer * st_bp, int offset) 39041da177e4SLinus Torvalds { 39051da177e4SLinus Torvalds int src_seg, dst_seg, src_offset = 0, dst_offset; 39061da177e4SLinus Torvalds int count, total; 3907c982c368SFUJITA Tomonori int length = PAGE_SIZE << st_bp->reserved_page_order; 39081da177e4SLinus Torvalds 39091da177e4SLinus Torvalds if (offset == 0) 39101da177e4SLinus Torvalds return; 39111da177e4SLinus Torvalds 39121da177e4SLinus Torvalds total=st_bp->buffer_bytes - offset; 39131da177e4SLinus Torvalds for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) { 39141da177e4SLinus Torvalds src_offset = offset; 391508c95832SFUJITA Tomonori if (src_offset < length) 39161da177e4SLinus Torvalds break; 391708c95832SFUJITA Tomonori offset -= length; 39181da177e4SLinus Torvalds } 39191da177e4SLinus Torvalds 39201da177e4SLinus Torvalds st_bp->buffer_bytes = st_bp->read_pointer = total; 39211da177e4SLinus Torvalds for (dst_seg=dst_offset=0; total > 0; ) { 392208c95832SFUJITA Tomonori struct page *dpage = st_bp->reserved_pages[dst_seg]; 392308c95832SFUJITA Tomonori struct page *spage = st_bp->reserved_pages[src_seg]; 392408c95832SFUJITA Tomonori 392508c95832SFUJITA Tomonori count = min(length - dst_offset, length - src_offset); 392608c95832SFUJITA Tomonori memmove(page_address(dpage) + dst_offset, 392708c95832SFUJITA Tomonori page_address(spage) + src_offset, count); 39281da177e4SLinus Torvalds src_offset += count; 392908c95832SFUJITA Tomonori if (src_offset >= length) { 39301da177e4SLinus Torvalds src_seg++; 39311da177e4SLinus Torvalds src_offset = 0; 39321da177e4SLinus Torvalds } 39331da177e4SLinus Torvalds dst_offset += count; 393408c95832SFUJITA Tomonori if (dst_offset >= length) { 39351da177e4SLinus Torvalds dst_seg++; 39361da177e4SLinus Torvalds dst_offset = 0; 39371da177e4SLinus Torvalds } 39381da177e4SLinus Torvalds total -= count; 39391da177e4SLinus Torvalds } 39401da177e4SLinus Torvalds } 39411da177e4SLinus Torvalds 39421da177e4SLinus Torvalds /* Validate the options from command line or module parameters */ 39431da177e4SLinus Torvalds static void validate_options(void) 39441da177e4SLinus Torvalds { 39451da177e4SLinus Torvalds if (buffer_kbs > 0) 39461da177e4SLinus Torvalds st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE; 39471da177e4SLinus Torvalds if (max_sg_segs >= ST_FIRST_SG) 39481da177e4SLinus Torvalds st_max_sg_segs = max_sg_segs; 39491da177e4SLinus Torvalds } 39501da177e4SLinus Torvalds 39511da177e4SLinus Torvalds #ifndef MODULE 39521da177e4SLinus Torvalds /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt. 39531da177e4SLinus Torvalds */ 39541da177e4SLinus Torvalds static int __init st_setup(char *str) 39551da177e4SLinus Torvalds { 39561da177e4SLinus Torvalds int i, len, ints[5]; 39571da177e4SLinus Torvalds char *stp; 39581da177e4SLinus Torvalds 39591da177e4SLinus Torvalds stp = get_options(str, ARRAY_SIZE(ints), ints); 39601da177e4SLinus Torvalds 39611da177e4SLinus Torvalds if (ints[0] > 0) { 39621da177e4SLinus Torvalds for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++) 39631da177e4SLinus Torvalds if (parms[i].val) 39641da177e4SLinus Torvalds *parms[i].val = ints[i + 1]; 39651da177e4SLinus Torvalds } else { 39661da177e4SLinus Torvalds while (stp != NULL) { 39671da177e4SLinus Torvalds for (i = 0; i < ARRAY_SIZE(parms); i++) { 39681da177e4SLinus Torvalds len = strlen(parms[i].name); 39691da177e4SLinus Torvalds if (!strncmp(stp, parms[i].name, len) && 39701da177e4SLinus Torvalds (*(stp + len) == ':' || *(stp + len) == '=')) { 39711da177e4SLinus Torvalds if (parms[i].val) 39721da177e4SLinus Torvalds *parms[i].val = 39731da177e4SLinus Torvalds simple_strtoul(stp + len + 1, NULL, 0); 39741da177e4SLinus Torvalds else 39751da177e4SLinus Torvalds printk(KERN_WARNING "st: Obsolete parameter %s\n", 39761da177e4SLinus Torvalds parms[i].name); 39771da177e4SLinus Torvalds break; 39781da177e4SLinus Torvalds } 39791da177e4SLinus Torvalds } 39806391a113STobias Klauser if (i >= ARRAY_SIZE(parms)) 39811da177e4SLinus Torvalds printk(KERN_WARNING "st: invalid parameter in '%s'\n", 39821da177e4SLinus Torvalds stp); 39831da177e4SLinus Torvalds stp = strchr(stp, ','); 39841da177e4SLinus Torvalds if (stp) 39851da177e4SLinus Torvalds stp++; 39861da177e4SLinus Torvalds } 39871da177e4SLinus Torvalds } 39881da177e4SLinus Torvalds 39891da177e4SLinus Torvalds validate_options(); 39901da177e4SLinus Torvalds 39911da177e4SLinus Torvalds return 1; 39921da177e4SLinus Torvalds } 39931da177e4SLinus Torvalds 39941da177e4SLinus Torvalds __setup("st=", st_setup); 39951da177e4SLinus Torvalds 39961da177e4SLinus Torvalds #endif 39971da177e4SLinus Torvalds 399800977a59SArjan van de Ven static const struct file_operations st_fops = 39991da177e4SLinus Torvalds { 40001da177e4SLinus Torvalds .owner = THIS_MODULE, 40011da177e4SLinus Torvalds .read = st_read, 40021da177e4SLinus Torvalds .write = st_write, 4003fd66c1b4SKai Makisara .unlocked_ioctl = st_ioctl, 40041da177e4SLinus Torvalds #ifdef CONFIG_COMPAT 40051da177e4SLinus Torvalds .compat_ioctl = st_compat_ioctl, 40061da177e4SLinus Torvalds #endif 40071da177e4SLinus Torvalds .open = st_open, 40081da177e4SLinus Torvalds .flush = st_flush, 40091da177e4SLinus Torvalds .release = st_release, 4010b4d878e2SJan Blunck .llseek = noop_llseek, 40111da177e4SLinus Torvalds }; 40121da177e4SLinus Torvalds 401326898afdSJeff Mahoney static int create_one_cdev(struct scsi_tape *tape, int mode, int rew) 401426898afdSJeff Mahoney { 401526898afdSJeff Mahoney int i, error; 401626898afdSJeff Mahoney dev_t cdev_devno; 401726898afdSJeff Mahoney struct cdev *cdev; 401826898afdSJeff Mahoney struct device *dev; 401926898afdSJeff Mahoney struct st_modedef *STm = &(tape->modes[mode]); 402026898afdSJeff Mahoney char name[10]; 402126898afdSJeff Mahoney int dev_num = tape->index; 402226898afdSJeff Mahoney 402326898afdSJeff Mahoney cdev_devno = MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, rew)); 402426898afdSJeff Mahoney 402526898afdSJeff Mahoney cdev = cdev_alloc(); 402626898afdSJeff Mahoney if (!cdev) { 402726898afdSJeff Mahoney pr_err("st%d: out of memory. Device not attached.\n", dev_num); 402826898afdSJeff Mahoney error = -ENOMEM; 402926898afdSJeff Mahoney goto out; 403026898afdSJeff Mahoney } 403126898afdSJeff Mahoney cdev->owner = THIS_MODULE; 403226898afdSJeff Mahoney cdev->ops = &st_fops; 403326898afdSJeff Mahoney 403426898afdSJeff Mahoney error = cdev_add(cdev, cdev_devno, 1); 403526898afdSJeff Mahoney if (error) { 403626898afdSJeff Mahoney pr_err("st%d: Can't add %s-rewind mode %d\n", dev_num, 403726898afdSJeff Mahoney rew ? "non" : "auto", mode); 403826898afdSJeff Mahoney pr_err("st%d: Device not attached.\n", dev_num); 403926898afdSJeff Mahoney goto out_free; 404026898afdSJeff Mahoney } 404126898afdSJeff Mahoney STm->cdevs[rew] = cdev; 404226898afdSJeff Mahoney 404326898afdSJeff Mahoney i = mode << (4 - ST_NBR_MODE_BITS); 404426898afdSJeff Mahoney snprintf(name, 10, "%s%s%s", rew ? "n" : "", 404526898afdSJeff Mahoney tape->disk->disk_name, st_formats[i]); 404626898afdSJeff Mahoney 404726898afdSJeff Mahoney dev = device_create(&st_sysfs_class, &tape->device->sdev_gendev, 404826898afdSJeff Mahoney cdev_devno, &tape->modes[mode], "%s", name); 404926898afdSJeff Mahoney if (IS_ERR(dev)) { 405026898afdSJeff Mahoney pr_err("st%d: device_create failed\n", dev_num); 405126898afdSJeff Mahoney error = PTR_ERR(dev); 405226898afdSJeff Mahoney goto out_free; 405326898afdSJeff Mahoney } 405426898afdSJeff Mahoney 405526898afdSJeff Mahoney STm->devs[rew] = dev; 405626898afdSJeff Mahoney 405726898afdSJeff Mahoney return 0; 405826898afdSJeff Mahoney out_free: 405926898afdSJeff Mahoney cdev_del(STm->cdevs[rew]); 406026898afdSJeff Mahoney STm->cdevs[rew] = NULL; 406126898afdSJeff Mahoney out: 406226898afdSJeff Mahoney return error; 406326898afdSJeff Mahoney } 406426898afdSJeff Mahoney 406526898afdSJeff Mahoney static int create_cdevs(struct scsi_tape *tape) 406626898afdSJeff Mahoney { 406726898afdSJeff Mahoney int mode, error; 406826898afdSJeff Mahoney for (mode = 0; mode < ST_NBR_MODES; ++mode) { 406926898afdSJeff Mahoney error = create_one_cdev(tape, mode, 0); 407026898afdSJeff Mahoney if (error) 407126898afdSJeff Mahoney return error; 407226898afdSJeff Mahoney error = create_one_cdev(tape, mode, 1); 407326898afdSJeff Mahoney if (error) 407426898afdSJeff Mahoney return error; 407526898afdSJeff Mahoney } 407626898afdSJeff Mahoney 407726898afdSJeff Mahoney return sysfs_create_link(&tape->device->sdev_gendev.kobj, 407826898afdSJeff Mahoney &tape->modes[0].devs[0]->kobj, "tape"); 407926898afdSJeff Mahoney } 408026898afdSJeff Mahoney 408126898afdSJeff Mahoney static void remove_cdevs(struct scsi_tape *tape) 408226898afdSJeff Mahoney { 408326898afdSJeff Mahoney int mode, rew; 408426898afdSJeff Mahoney sysfs_remove_link(&tape->device->sdev_gendev.kobj, "tape"); 408526898afdSJeff Mahoney for (mode = 0; mode < ST_NBR_MODES; mode++) { 408626898afdSJeff Mahoney struct st_modedef *STm = &(tape->modes[mode]); 408726898afdSJeff Mahoney for (rew = 0; rew < 2; rew++) { 408826898afdSJeff Mahoney if (STm->cdevs[rew]) 408926898afdSJeff Mahoney cdev_del(STm->cdevs[rew]); 409026898afdSJeff Mahoney if (STm->devs[rew]) 409126898afdSJeff Mahoney device_unregister(STm->devs[rew]); 409226898afdSJeff Mahoney } 409326898afdSJeff Mahoney } 409426898afdSJeff Mahoney } 409526898afdSJeff Mahoney 40961da177e4SLinus Torvalds static int st_probe(struct device *dev) 40971da177e4SLinus Torvalds { 40981da177e4SLinus Torvalds struct scsi_device *SDp = to_scsi_device(dev); 40991da177e4SLinus Torvalds struct gendisk *disk = NULL; 41001da177e4SLinus Torvalds struct scsi_tape *tpnt = NULL; 41011da177e4SLinus Torvalds struct st_modedef *STm; 41021da177e4SLinus Torvalds struct st_partstat *STps; 41031da177e4SLinus Torvalds struct st_buffer *buffer; 4104b98c52b5STejun Heo int i, error; 41051da177e4SLinus Torvalds char *stp; 41061da177e4SLinus Torvalds 41071da177e4SLinus Torvalds if (SDp->type != TYPE_TAPE) 41081da177e4SLinus Torvalds return -ENODEV; 41091da177e4SLinus Torvalds if ((stp = st_incompatible(SDp))) { 41103bf743e7SJeff Garzik sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n"); 4111b30d8bcaSHannes Reinecke sdev_printk(KERN_INFO, SDp, 4112b30d8bcaSHannes Reinecke "st: The suggested driver is %s.\n", stp); 41131da177e4SLinus Torvalds return -ENODEV; 41141da177e4SLinus Torvalds } 41151da177e4SLinus Torvalds 41166fe8c1dbSSubhash Jadavani scsi_autopm_get_device(SDp); 41178a78362cSMartin K. Petersen i = queue_max_segments(SDp->request_queue); 41181da177e4SLinus Torvalds if (st_max_sg_segs < i) 41191da177e4SLinus Torvalds i = st_max_sg_segs; 4120f409d6ccSFUJITA Tomonori buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i); 41211da177e4SLinus Torvalds if (buffer == NULL) { 4122b30d8bcaSHannes Reinecke sdev_printk(KERN_ERR, SDp, 4123b30d8bcaSHannes Reinecke "st: Can't allocate new tape buffer. " 4124b30d8bcaSHannes Reinecke "Device not attached.\n"); 41251da177e4SLinus Torvalds goto out; 41261da177e4SLinus Torvalds } 41271da177e4SLinus Torvalds 41281da177e4SLinus Torvalds disk = alloc_disk(1); 41291da177e4SLinus Torvalds if (!disk) { 4130b30d8bcaSHannes Reinecke sdev_printk(KERN_ERR, SDp, 4131b30d8bcaSHannes Reinecke "st: out of memory. Device not attached.\n"); 41321da177e4SLinus Torvalds goto out_buffer_free; 41331da177e4SLinus Torvalds } 41341da177e4SLinus Torvalds 413524669f75SJes Sorensen tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC); 41361da177e4SLinus Torvalds if (tpnt == NULL) { 4137b30d8bcaSHannes Reinecke sdev_printk(KERN_ERR, SDp, 4138b30d8bcaSHannes Reinecke "st: Can't allocate device descriptor.\n"); 41391da177e4SLinus Torvalds goto out_put_disk; 41401da177e4SLinus Torvalds } 4141f03a5670SKai Makisara kref_init(&tpnt->kref); 41421da177e4SLinus Torvalds tpnt->disk = disk; 41431da177e4SLinus Torvalds disk->private_data = &tpnt->driver; 41441da177e4SLinus Torvalds disk->queue = SDp->request_queue; 41452b5bebccSJoe Lawrence /* SCSI tape doesn't register this gendisk via add_disk(). Manually 41462b5bebccSJoe Lawrence * take queue reference that release_disk() expects. */ 41472b5bebccSJoe Lawrence if (!blk_get_queue(disk->queue)) 41482b5bebccSJoe Lawrence goto out_put_disk; 41491da177e4SLinus Torvalds tpnt->driver = &st_template; 41501da177e4SLinus Torvalds 41511da177e4SLinus Torvalds tpnt->device = SDp; 41521da177e4SLinus Torvalds if (SDp->scsi_level <= 2) 41531da177e4SLinus Torvalds tpnt->tape_type = MT_ISSCSI1; 41541da177e4SLinus Torvalds else 41551da177e4SLinus Torvalds tpnt->tape_type = MT_ISSCSI2; 41561da177e4SLinus Torvalds 41571da177e4SLinus Torvalds tpnt->buffer = buffer; 4158f03a5670SKai Makisara tpnt->buffer->last_SRpnt = NULL; 41591da177e4SLinus Torvalds 41601da177e4SLinus Torvalds tpnt->inited = 0; 41611da177e4SLinus Torvalds tpnt->dirty = 0; 41621da177e4SLinus Torvalds tpnt->in_use = 0; 41631da177e4SLinus Torvalds tpnt->drv_buffer = 1; /* Try buffering if no mode sense */ 41641da177e4SLinus Torvalds tpnt->restr_dma = (SDp->host)->unchecked_isa_dma; 41651da177e4SLinus Torvalds tpnt->use_pf = (SDp->scsi_level >= SCSI_2); 41661da177e4SLinus Torvalds tpnt->density = 0; 41671da177e4SLinus Torvalds tpnt->do_auto_lock = ST_AUTO_LOCK; 41681da177e4SLinus Torvalds tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */ 41691da177e4SLinus Torvalds tpnt->can_partitions = 0; 41701da177e4SLinus Torvalds tpnt->two_fm = ST_TWO_FM; 41711da177e4SLinus Torvalds tpnt->fast_mteom = ST_FAST_MTEOM; 41721da177e4SLinus Torvalds tpnt->scsi2_logical = ST_SCSI2LOGICAL; 417340f6b36cSKai Makisara tpnt->sili = ST_SILI; 41741da177e4SLinus Torvalds tpnt->immediate = ST_NOWAIT; 4175c743e44fSLee Duncan tpnt->immediate_filemark = 0; 41761da177e4SLinus Torvalds tpnt->default_drvbuffer = 0xff; /* No forced buffering */ 41771da177e4SLinus Torvalds tpnt->partition = 0; 41781da177e4SLinus Torvalds tpnt->new_partition = 0; 41791da177e4SLinus Torvalds tpnt->nbr_partitions = 0; 4180a02488edSJames Bottomley blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT); 41811da177e4SLinus Torvalds tpnt->long_timeout = ST_LONG_TIMEOUT; 41821da177e4SLinus Torvalds tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma; 41831da177e4SLinus Torvalds 41841da177e4SLinus Torvalds for (i = 0; i < ST_NBR_MODES; i++) { 41851da177e4SLinus Torvalds STm = &(tpnt->modes[i]); 41861da177e4SLinus Torvalds STm->defined = 0; 41871da177e4SLinus Torvalds STm->sysv = ST_SYSV; 41881da177e4SLinus Torvalds STm->defaults_for_writes = 0; 41891da177e4SLinus Torvalds STm->do_async_writes = ST_ASYNC_WRITES; 41901da177e4SLinus Torvalds STm->do_buffer_writes = ST_BUFFER_WRITES; 41911da177e4SLinus Torvalds STm->do_read_ahead = ST_READ_AHEAD; 41921da177e4SLinus Torvalds STm->default_compression = ST_DONT_TOUCH; 41931da177e4SLinus Torvalds STm->default_blksize = (-1); /* No forced size */ 41941da177e4SLinus Torvalds STm->default_density = (-1); /* No forced density */ 41956c648d95SJeff Mahoney STm->tape = tpnt; 41961da177e4SLinus Torvalds } 41971da177e4SLinus Torvalds 41981da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 41991da177e4SLinus Torvalds STps = &(tpnt->ps[i]); 42001da177e4SLinus Torvalds STps->rw = ST_IDLE; 42011da177e4SLinus Torvalds STps->eof = ST_NOEOF; 42021da177e4SLinus Torvalds STps->at_sm = 0; 42031da177e4SLinus Torvalds STps->last_block_valid = 0; 42041da177e4SLinus Torvalds STps->drv_block = (-1); 42051da177e4SLinus Torvalds STps->drv_file = (-1); 42061da177e4SLinus Torvalds } 42071da177e4SLinus Torvalds 42081da177e4SLinus Torvalds tpnt->current_mode = 0; 42091da177e4SLinus Torvalds tpnt->modes[0].defined = 1; 42101da177e4SLinus Torvalds 42111da177e4SLinus Torvalds tpnt->density_changed = tpnt->compression_changed = 42121da177e4SLinus Torvalds tpnt->blksize_changed = 0; 421328f85009SMatthias Kaehlcke mutex_init(&tpnt->lock); 42141da177e4SLinus Torvalds 4215b98c52b5STejun Heo idr_preload(GFP_KERNEL); 42166c648d95SJeff Mahoney spin_lock(&st_index_lock); 4217b98c52b5STejun Heo error = idr_alloc(&st_index_idr, tpnt, 0, ST_MAX_TAPES + 1, GFP_NOWAIT); 42186c648d95SJeff Mahoney spin_unlock(&st_index_lock); 4219b98c52b5STejun Heo idr_preload_end(); 4220b98c52b5STejun Heo if (error < 0) { 42216c648d95SJeff Mahoney pr_warn("st: idr allocation failed: %d\n", error); 42222b5bebccSJoe Lawrence goto out_put_queue; 42236c648d95SJeff Mahoney } 4224b98c52b5STejun Heo tpnt->index = error; 4225b98c52b5STejun Heo sprintf(disk->disk_name, "st%d", tpnt->index); 42266c648d95SJeff Mahoney 42276c648d95SJeff Mahoney dev_set_drvdata(dev, tpnt); 42281da177e4SLinus Torvalds 42291da177e4SLinus Torvalds 423026898afdSJeff Mahoney error = create_cdevs(tpnt); 423113026a6bSJeff Garzik if (error) 423226898afdSJeff Mahoney goto out_remove_devs; 423346a243f7SOliver Neukum scsi_autopm_put_device(SDp); 42341da177e4SLinus Torvalds 423542252854SKai Makisara sdev_printk(KERN_NOTICE, SDp, 42368b1ea24cSRene Herman "Attached scsi tape %s\n", tape_name(tpnt)); 423742252854SKai Makisara sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n", 42381da177e4SLinus Torvalds tape_name(tpnt), tpnt->try_dio ? "yes" : "no", 42398b05b773SMike Christie queue_dma_alignment(SDp->request_queue) + 1); 42401da177e4SLinus Torvalds 42411da177e4SLinus Torvalds return 0; 42421da177e4SLinus Torvalds 424326898afdSJeff Mahoney out_remove_devs: 424426898afdSJeff Mahoney remove_cdevs(tpnt); 42456c648d95SJeff Mahoney spin_lock(&st_index_lock); 4246b98c52b5STejun Heo idr_remove(&st_index_idr, tpnt->index); 42476c648d95SJeff Mahoney spin_unlock(&st_index_lock); 42482b5bebccSJoe Lawrence out_put_queue: 42492b5bebccSJoe Lawrence blk_put_queue(disk->queue); 42501da177e4SLinus Torvalds out_put_disk: 42511da177e4SLinus Torvalds put_disk(disk); 42521da177e4SLinus Torvalds kfree(tpnt); 42531da177e4SLinus Torvalds out_buffer_free: 42541da177e4SLinus Torvalds kfree(buffer); 42551da177e4SLinus Torvalds out: 42566fe8c1dbSSubhash Jadavani scsi_autopm_put_device(SDp); 42571da177e4SLinus Torvalds return -ENODEV; 42581da177e4SLinus Torvalds }; 42591da177e4SLinus Torvalds 42601da177e4SLinus Torvalds 42611da177e4SLinus Torvalds static int st_remove(struct device *dev) 42621da177e4SLinus Torvalds { 42636c648d95SJeff Mahoney struct scsi_tape *tpnt = dev_get_drvdata(dev); 42646c648d95SJeff Mahoney int index = tpnt->index; 42651da177e4SLinus Torvalds 42666c648d95SJeff Mahoney scsi_autopm_get_device(to_scsi_device(dev)); 426726898afdSJeff Mahoney remove_cdevs(tpnt); 4268f03a5670SKai Makisara 42690b950672SArjan van de Ven mutex_lock(&st_ref_mutex); 4270f03a5670SKai Makisara kref_put(&tpnt->kref, scsi_tape_release); 42710b950672SArjan van de Ven mutex_unlock(&st_ref_mutex); 42726c648d95SJeff Mahoney spin_lock(&st_index_lock); 42736c648d95SJeff Mahoney idr_remove(&st_index_idr, index); 42746c648d95SJeff Mahoney spin_unlock(&st_index_lock); 4275f03a5670SKai Makisara return 0; 4276f03a5670SKai Makisara } 4277f03a5670SKai Makisara 4278f03a5670SKai Makisara /** 4279f03a5670SKai Makisara * scsi_tape_release - Called to free the Scsi_Tape structure 4280f03a5670SKai Makisara * @kref: pointer to embedded kref 4281f03a5670SKai Makisara * 42820b950672SArjan van de Ven * st_ref_mutex must be held entering this routine. Because it is 4283f03a5670SKai Makisara * called on last put, you should always use the scsi_tape_get() 4284f03a5670SKai Makisara * scsi_tape_put() helpers which manipulate the semaphore directly 4285f03a5670SKai Makisara * and never do a direct kref_put(). 4286f03a5670SKai Makisara **/ 4287f03a5670SKai Makisara static void scsi_tape_release(struct kref *kref) 4288f03a5670SKai Makisara { 4289f03a5670SKai Makisara struct scsi_tape *tpnt = to_scsi_tape(kref); 4290f03a5670SKai Makisara struct gendisk *disk = tpnt->disk; 4291f03a5670SKai Makisara 42921da177e4SLinus Torvalds tpnt->device = NULL; 42931da177e4SLinus Torvalds 42941da177e4SLinus Torvalds if (tpnt->buffer) { 42951da177e4SLinus Torvalds normalize_buffer(tpnt->buffer); 4296d0e1ae31SFUJITA Tomonori kfree(tpnt->buffer->reserved_pages); 42971da177e4SLinus Torvalds kfree(tpnt->buffer); 42981da177e4SLinus Torvalds } 42991da177e4SLinus Torvalds 4300f03a5670SKai Makisara disk->private_data = NULL; 4301f03a5670SKai Makisara put_disk(disk); 4302f03a5670SKai Makisara kfree(tpnt); 4303f03a5670SKai Makisara return; 43041da177e4SLinus Torvalds } 43051da177e4SLinus Torvalds 4306af23782bSJeff Mahoney static struct class st_sysfs_class = { 4307af23782bSJeff Mahoney .name = "scsi_tape", 4308c69c6be5SGreg Kroah-Hartman .dev_groups = st_dev_groups, 4309af23782bSJeff Mahoney }; 4310af23782bSJeff Mahoney 43111da177e4SLinus Torvalds static int __init init_st(void) 43121da177e4SLinus Torvalds { 431313026a6bSJeff Garzik int err; 431413026a6bSJeff Garzik 43151da177e4SLinus Torvalds validate_options(); 43161da177e4SLinus Torvalds 431713026a6bSJeff Garzik printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n", 43181da177e4SLinus Torvalds verstr, st_fixed_buffer_size, st_max_sg_segs); 43191da177e4SLinus Torvalds 43202bec708aSLaurence Oberman debugging = (debug_flag > 0) ? debug_flag : NO_DEBUG; 43212bec708aSLaurence Oberman if (debugging) { 43222bec708aSLaurence Oberman printk(KERN_INFO "st: Debugging enabled debug_flag = %d\n", 43232bec708aSLaurence Oberman debugging); 43242bec708aSLaurence Oberman } 43252bec708aSLaurence Oberman 4326af23782bSJeff Mahoney err = class_register(&st_sysfs_class); 4327af23782bSJeff Mahoney if (err) { 4328af23782bSJeff Mahoney pr_err("Unable register sysfs class for SCSI tapes\n"); 4329af23782bSJeff Mahoney return err; 43301da177e4SLinus Torvalds } 43311da177e4SLinus Torvalds 433213026a6bSJeff Garzik err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 433313026a6bSJeff Garzik ST_MAX_TAPE_ENTRIES, "st"); 433413026a6bSJeff Garzik if (err) { 433513026a6bSJeff Garzik printk(KERN_ERR "Unable to get major %d for SCSI tapes\n", 433613026a6bSJeff Garzik SCSI_TAPE_MAJOR); 433713026a6bSJeff Garzik goto err_class; 43381da177e4SLinus Torvalds } 433913026a6bSJeff Garzik 434013026a6bSJeff Garzik err = scsi_register_driver(&st_template.gendrv); 434113026a6bSJeff Garzik if (err) 434213026a6bSJeff Garzik goto err_chrdev; 434313026a6bSJeff Garzik 4344405ae7d3SRobert P. J. Day err = do_create_sysfs_files(); 434513026a6bSJeff Garzik if (err) 434613026a6bSJeff Garzik goto err_scsidrv; 434713026a6bSJeff Garzik 434813026a6bSJeff Garzik return 0; 434913026a6bSJeff Garzik 435013026a6bSJeff Garzik err_scsidrv: 435113026a6bSJeff Garzik scsi_unregister_driver(&st_template.gendrv); 435213026a6bSJeff Garzik err_chrdev: 43531da177e4SLinus Torvalds unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 43541da177e4SLinus Torvalds ST_MAX_TAPE_ENTRIES); 435513026a6bSJeff Garzik err_class: 4356af23782bSJeff Mahoney class_unregister(&st_sysfs_class); 435713026a6bSJeff Garzik return err; 43581da177e4SLinus Torvalds } 43591da177e4SLinus Torvalds 43601da177e4SLinus Torvalds static void __exit exit_st(void) 43611da177e4SLinus Torvalds { 4362405ae7d3SRobert P. J. Day do_remove_sysfs_files(); 43631da177e4SLinus Torvalds scsi_unregister_driver(&st_template.gendrv); 43641da177e4SLinus Torvalds unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 43651da177e4SLinus Torvalds ST_MAX_TAPE_ENTRIES); 4366af23782bSJeff Mahoney class_unregister(&st_sysfs_class); 43671da177e4SLinus Torvalds printk(KERN_INFO "st: Unloaded.\n"); 43681da177e4SLinus Torvalds } 43691da177e4SLinus Torvalds 43701da177e4SLinus Torvalds module_init(init_st); 43711da177e4SLinus Torvalds module_exit(exit_st); 43721da177e4SLinus Torvalds 43731da177e4SLinus Torvalds 43741da177e4SLinus Torvalds /* The sysfs driver interface. Read-only at the moment */ 43751da177e4SLinus Torvalds static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf) 43761da177e4SLinus Torvalds { 43771da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io); 43781da177e4SLinus Torvalds } 43791da177e4SLinus Torvalds static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL); 43801da177e4SLinus Torvalds 43811da177e4SLinus Torvalds static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf) 43821da177e4SLinus Torvalds { 43831da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size); 43841da177e4SLinus Torvalds } 43851da177e4SLinus Torvalds static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL); 43861da177e4SLinus Torvalds 43871da177e4SLinus Torvalds static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf) 43881da177e4SLinus Torvalds { 43891da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs); 43901da177e4SLinus Torvalds } 43911da177e4SLinus Torvalds static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL); 43921da177e4SLinus Torvalds 43931da177e4SLinus Torvalds static ssize_t st_version_show(struct device_driver *ddd, char *buf) 43941da177e4SLinus Torvalds { 43951da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr); 43961da177e4SLinus Torvalds } 43971da177e4SLinus Torvalds static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL); 43981da177e4SLinus Torvalds 4399405ae7d3SRobert P. J. Day static int do_create_sysfs_files(void) 44001da177e4SLinus Torvalds { 4401405ae7d3SRobert P. J. Day struct device_driver *sysfs = &st_template.gendrv; 440213026a6bSJeff Garzik int err; 44031da177e4SLinus Torvalds 4404405ae7d3SRobert P. J. Day err = driver_create_file(sysfs, &driver_attr_try_direct_io); 440513026a6bSJeff Garzik if (err) 440613026a6bSJeff Garzik return err; 4407405ae7d3SRobert P. J. Day err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size); 440813026a6bSJeff Garzik if (err) 440913026a6bSJeff Garzik goto err_try_direct_io; 4410405ae7d3SRobert P. J. Day err = driver_create_file(sysfs, &driver_attr_max_sg_segs); 441113026a6bSJeff Garzik if (err) 441213026a6bSJeff Garzik goto err_attr_fixed_buf; 4413405ae7d3SRobert P. J. Day err = driver_create_file(sysfs, &driver_attr_version); 441413026a6bSJeff Garzik if (err) 441513026a6bSJeff Garzik goto err_attr_max_sg; 441613026a6bSJeff Garzik 441713026a6bSJeff Garzik return 0; 441813026a6bSJeff Garzik 441913026a6bSJeff Garzik err_attr_max_sg: 4420405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_max_sg_segs); 442113026a6bSJeff Garzik err_attr_fixed_buf: 4422405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_fixed_buffer_size); 442313026a6bSJeff Garzik err_try_direct_io: 4424405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_try_direct_io); 442513026a6bSJeff Garzik return err; 44261da177e4SLinus Torvalds } 44271da177e4SLinus Torvalds 4428405ae7d3SRobert P. J. Day static void do_remove_sysfs_files(void) 44291da177e4SLinus Torvalds { 4430405ae7d3SRobert P. J. Day struct device_driver *sysfs = &st_template.gendrv; 44311da177e4SLinus Torvalds 4432405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_version); 4433405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_max_sg_segs); 4434405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_fixed_buffer_size); 4435405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_try_direct_io); 44361da177e4SLinus Torvalds } 44371da177e4SLinus Torvalds 44381da177e4SLinus Torvalds /* The sysfs simple class interface */ 4439ee959b00STony Jones static ssize_t 4440af23782bSJeff Mahoney defined_show(struct device *dev, struct device_attribute *attr, char *buf) 44411da177e4SLinus Torvalds { 44427d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 44431da177e4SLinus Torvalds ssize_t l = 0; 44441da177e4SLinus Torvalds 44451da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined); 44461da177e4SLinus Torvalds return l; 44471da177e4SLinus Torvalds } 4448c69c6be5SGreg Kroah-Hartman static DEVICE_ATTR_RO(defined); 44491da177e4SLinus Torvalds 4450ee959b00STony Jones static ssize_t 4451af23782bSJeff Mahoney default_blksize_show(struct device *dev, struct device_attribute *attr, 4452af23782bSJeff Mahoney char *buf) 44531da177e4SLinus Torvalds { 44547d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 44551da177e4SLinus Torvalds ssize_t l = 0; 44561da177e4SLinus Torvalds 44571da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize); 44581da177e4SLinus Torvalds return l; 44591da177e4SLinus Torvalds } 4460c69c6be5SGreg Kroah-Hartman static DEVICE_ATTR_RO(default_blksize); 44611da177e4SLinus Torvalds 4462ee959b00STony Jones static ssize_t 4463af23782bSJeff Mahoney default_density_show(struct device *dev, struct device_attribute *attr, 4464af23782bSJeff Mahoney char *buf) 44651da177e4SLinus Torvalds { 44667d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 44671da177e4SLinus Torvalds ssize_t l = 0; 44681da177e4SLinus Torvalds char *fmt; 44691da177e4SLinus Torvalds 44701da177e4SLinus Torvalds fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n"; 44711da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density); 44721da177e4SLinus Torvalds return l; 44731da177e4SLinus Torvalds } 4474c69c6be5SGreg Kroah-Hartman static DEVICE_ATTR_RO(default_density); 44751da177e4SLinus Torvalds 4476ee959b00STony Jones static ssize_t 4477af23782bSJeff Mahoney default_compression_show(struct device *dev, struct device_attribute *attr, 4478ee959b00STony Jones char *buf) 44791da177e4SLinus Torvalds { 44807d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 44811da177e4SLinus Torvalds ssize_t l = 0; 44821da177e4SLinus Torvalds 44831da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1); 44841da177e4SLinus Torvalds return l; 44851da177e4SLinus Torvalds } 4486c69c6be5SGreg Kroah-Hartman static DEVICE_ATTR_RO(default_compression); 44871da177e4SLinus Torvalds 4488ee959b00STony Jones static ssize_t 4489af23782bSJeff Mahoney options_show(struct device *dev, struct device_attribute *attr, char *buf) 4490b174be02SKai Makisara { 44917d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 44926c648d95SJeff Mahoney struct scsi_tape *STp = STm->tape; 44936c648d95SJeff Mahoney int options; 4494b174be02SKai Makisara ssize_t l = 0; 4495b174be02SKai Makisara 4496b174be02SKai Makisara options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0; 4497b174be02SKai Makisara options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0; 4498b174be02SKai Makisara options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0; 4499b174be02SKai Makisara DEB( options |= debugging ? MT_ST_DEBUGGING : 0 ); 4500b174be02SKai Makisara options |= STp->two_fm ? MT_ST_TWO_FM : 0; 4501b174be02SKai Makisara options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0; 4502b174be02SKai Makisara options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0; 4503b174be02SKai Makisara options |= STp->can_bsr ? MT_ST_CAN_BSR : 0; 4504b174be02SKai Makisara options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0; 4505b174be02SKai Makisara options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0; 4506b174be02SKai Makisara options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0; 4507b174be02SKai Makisara options |= STm->sysv ? MT_ST_SYSV : 0; 4508b174be02SKai Makisara options |= STp->immediate ? MT_ST_NOWAIT : 0; 4509c743e44fSLee Duncan options |= STp->immediate_filemark ? MT_ST_NOWAIT_EOF : 0; 4510b174be02SKai Makisara options |= STp->sili ? MT_ST_SILI : 0; 4511b174be02SKai Makisara 4512b174be02SKai Makisara l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options); 4513b174be02SKai Makisara return l; 4514b174be02SKai Makisara } 4515c69c6be5SGreg Kroah-Hartman static DEVICE_ATTR_RO(options); 4516b174be02SKai Makisara 4517c69c6be5SGreg Kroah-Hartman static struct attribute *st_dev_attrs[] = { 4518c69c6be5SGreg Kroah-Hartman &dev_attr_defined.attr, 4519c69c6be5SGreg Kroah-Hartman &dev_attr_default_blksize.attr, 4520c69c6be5SGreg Kroah-Hartman &dev_attr_default_density.attr, 4521c69c6be5SGreg Kroah-Hartman &dev_attr_default_compression.attr, 4522c69c6be5SGreg Kroah-Hartman &dev_attr_options.attr, 4523c69c6be5SGreg Kroah-Hartman NULL, 4524af23782bSJeff Mahoney }; 4525c69c6be5SGreg Kroah-Hartman ATTRIBUTE_GROUPS(st_dev); 4526b174be02SKai Makisara 45271da177e4SLinus Torvalds /* The following functions may be useful for a larger audience. */ 45286620742fSFUJITA Tomonori static int sgl_map_user_pages(struct st_buffer *STbp, 45296620742fSFUJITA Tomonori const unsigned int max_pages, unsigned long uaddr, 45306620742fSFUJITA Tomonori size_t count, int rw) 45311da177e4SLinus Torvalds { 453207542b83SJames Bottomley unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT; 453307542b83SJames Bottomley unsigned long start = uaddr >> PAGE_SHIFT; 453407542b83SJames Bottomley const int nr_pages = end - start; 45351da177e4SLinus Torvalds int res, i, j; 45361da177e4SLinus Torvalds struct page **pages; 45376620742fSFUJITA Tomonori struct rq_map_data *mdata = &STbp->map_data; 45381da177e4SLinus Torvalds 45391da177e4SLinus Torvalds /* User attempted Overflow! */ 45401da177e4SLinus Torvalds if ((uaddr + count) < uaddr) 45411da177e4SLinus Torvalds return -EINVAL; 45421da177e4SLinus Torvalds 45431da177e4SLinus Torvalds /* Too big */ 45441da177e4SLinus Torvalds if (nr_pages > max_pages) 45451da177e4SLinus Torvalds return -ENOMEM; 45461da177e4SLinus Torvalds 45471da177e4SLinus Torvalds /* Hmm? */ 45481da177e4SLinus Torvalds if (count == 0) 45491da177e4SLinus Torvalds return 0; 45501da177e4SLinus Torvalds 45511da177e4SLinus Torvalds if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL) 45521da177e4SLinus Torvalds return -ENOMEM; 45531da177e4SLinus Torvalds 45541da177e4SLinus Torvalds /* Try to fault in all of the necessary pages */ 45551da177e4SLinus Torvalds down_read(¤t->mm->mmap_sem); 45561da177e4SLinus Torvalds /* rw==READ means read from drive, write into memory area */ 45571da177e4SLinus Torvalds res = get_user_pages( 45581da177e4SLinus Torvalds current, 45591da177e4SLinus Torvalds current->mm, 45601da177e4SLinus Torvalds uaddr, 45611da177e4SLinus Torvalds nr_pages, 45621da177e4SLinus Torvalds rw == READ, 45631da177e4SLinus Torvalds 0, /* don't force */ 45641da177e4SLinus Torvalds pages, 45651da177e4SLinus Torvalds NULL); 45661da177e4SLinus Torvalds up_read(¤t->mm->mmap_sem); 45671da177e4SLinus Torvalds 45681da177e4SLinus Torvalds /* Errors and no page mapped should return here */ 45691da177e4SLinus Torvalds if (res < nr_pages) 45701da177e4SLinus Torvalds goto out_unmap; 45711da177e4SLinus Torvalds 45721da177e4SLinus Torvalds for (i=0; i < nr_pages; i++) { 45731da177e4SLinus Torvalds /* FIXME: flush superflous for rw==READ, 45741da177e4SLinus Torvalds * probably wrong function for rw==WRITE 45751da177e4SLinus Torvalds */ 45761da177e4SLinus Torvalds flush_dcache_page(pages[i]); 45771da177e4SLinus Torvalds } 45781da177e4SLinus Torvalds 45796620742fSFUJITA Tomonori mdata->offset = uaddr & ~PAGE_MASK; 45806620742fSFUJITA Tomonori STbp->mapped_pages = pages; 45811da177e4SLinus Torvalds 45821da177e4SLinus Torvalds return nr_pages; 45831da177e4SLinus Torvalds out_unmap: 45841da177e4SLinus Torvalds if (res > 0) { 45851da177e4SLinus Torvalds for (j=0; j < res; j++) 45861da177e4SLinus Torvalds page_cache_release(pages[j]); 45876bc733e9SHugh Dickins res = 0; 45881da177e4SLinus Torvalds } 45891da177e4SLinus Torvalds kfree(pages); 45901da177e4SLinus Torvalds return res; 45911da177e4SLinus Torvalds } 45921da177e4SLinus Torvalds 45931da177e4SLinus Torvalds 45941da177e4SLinus Torvalds /* And unmap them... */ 45956620742fSFUJITA Tomonori static int sgl_unmap_user_pages(struct st_buffer *STbp, 45966620742fSFUJITA Tomonori const unsigned int nr_pages, int dirtied) 45971da177e4SLinus Torvalds { 45981da177e4SLinus Torvalds int i; 45991da177e4SLinus Torvalds 46001da177e4SLinus Torvalds for (i=0; i < nr_pages; i++) { 46016620742fSFUJITA Tomonori struct page *page = STbp->mapped_pages[i]; 4602b5810039SNick Piggin 4603b5810039SNick Piggin if (dirtied) 4604b5810039SNick Piggin SetPageDirty(page); 46051da177e4SLinus Torvalds /* FIXME: cache flush missing for rw==READ 46061da177e4SLinus Torvalds * FIXME: call the correct reference counting function 46071da177e4SLinus Torvalds */ 4608b5810039SNick Piggin page_cache_release(page); 46091da177e4SLinus Torvalds } 46106620742fSFUJITA Tomonori kfree(STbp->mapped_pages); 46116620742fSFUJITA Tomonori STbp->mapped_pages = NULL; 46121da177e4SLinus Torvalds 46131da177e4SLinus Torvalds return 0; 46141da177e4SLinus Torvalds } 4615