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 12fd66c1b4SKai Makisara Copyright 1992 - 2008 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 20626dcb1eSKai Makisara static const char *verstr = "20080504"; 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> 301da177e4SLinus Torvalds #include <linux/errno.h> 311da177e4SLinus Torvalds #include <linux/mtio.h> 3216c4b3e2SKai Makisara #include <linux/cdrom.h> 331da177e4SLinus Torvalds #include <linux/ioctl.h> 341da177e4SLinus Torvalds #include <linux/fcntl.h> 351da177e4SLinus Torvalds #include <linux/spinlock.h> 361da177e4SLinus Torvalds #include <linux/blkdev.h> 371da177e4SLinus Torvalds #include <linux/moduleparam.h> 381da177e4SLinus Torvalds #include <linux/cdev.h> 391da177e4SLinus Torvalds #include <linux/delay.h> 400b950672SArjan van de Ven #include <linux/mutex.h> 41b3369c68SJonathan Corbet #include <linux/smp_lock.h> 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds #include <asm/uaccess.h> 441da177e4SLinus Torvalds #include <asm/dma.h> 451da177e4SLinus Torvalds #include <asm/system.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. */ 591da177e4SLinus Torvalds #define DEBUG 0 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds #if DEBUG 621da177e4SLinus Torvalds /* The message level for the debug messages is currently set to KERN_NOTICE 631da177e4SLinus Torvalds so that people can easily see the messages. Later when the debugging messages 641da177e4SLinus Torvalds in the drivers are more widely classified, this may be changed to KERN_DEBUG. */ 651da177e4SLinus Torvalds #define ST_DEB_MSG KERN_NOTICE 661da177e4SLinus Torvalds #define DEB(a) a 671da177e4SLinus Torvalds #define DEBC(a) if (debugging) { a ; } 681da177e4SLinus Torvalds #else 691da177e4SLinus Torvalds #define DEB(a) 701da177e4SLinus Torvalds #define DEBC(a) 711da177e4SLinus Torvalds #endif 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds #define ST_KILOBYTE 1024 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds #include "st_options.h" 761da177e4SLinus Torvalds #include "st.h" 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds static int buffer_kbs; 791da177e4SLinus Torvalds static int max_sg_segs; 801da177e4SLinus Torvalds static int try_direct_io = TRY_DIRECT_IO; 811da177e4SLinus Torvalds static int try_rdio = 1; 821da177e4SLinus Torvalds static int try_wdio = 1; 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds static int st_dev_max; 851da177e4SLinus Torvalds static int st_nr_dev; 861da177e4SLinus Torvalds 87d253878bSgregkh@suse.de static struct class *st_sysfs_class; 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)"); 1051da177e4SLinus Torvalds 1061da177e4SLinus Torvalds /* Extra parameters for testing */ 1071da177e4SLinus Torvalds module_param_named(try_rdio, try_rdio, int, 0); 1081da177e4SLinus Torvalds MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible"); 1091da177e4SLinus Torvalds module_param_named(try_wdio, try_wdio, int, 0); 1101da177e4SLinus Torvalds MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible"); 1111da177e4SLinus Torvalds 1121da177e4SLinus Torvalds #ifndef MODULE 1131da177e4SLinus Torvalds static int write_threshold_kbs; /* retained for compatibility */ 1141da177e4SLinus Torvalds static struct st_dev_parm { 1151da177e4SLinus Torvalds char *name; 1161da177e4SLinus Torvalds int *val; 1171da177e4SLinus Torvalds } parms[] __initdata = { 1181da177e4SLinus Torvalds { 1191da177e4SLinus Torvalds "buffer_kbs", &buffer_kbs 1201da177e4SLinus Torvalds }, 1211da177e4SLinus Torvalds { /* Retained for compatibility with 2.4 */ 1221da177e4SLinus Torvalds "write_threshold_kbs", &write_threshold_kbs 1231da177e4SLinus Torvalds }, 1241da177e4SLinus Torvalds { 1251da177e4SLinus Torvalds "max_sg_segs", NULL 1261da177e4SLinus Torvalds }, 1271da177e4SLinus Torvalds { 1281da177e4SLinus Torvalds "try_direct_io", &try_direct_io 1291da177e4SLinus Torvalds } 1301da177e4SLinus Torvalds }; 1311da177e4SLinus Torvalds #endif 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds /* Restrict the number of modes so that names for all are assigned */ 1341da177e4SLinus Torvalds #if ST_NBR_MODES > 16 1351da177e4SLinus Torvalds #error "Maximum number of modes is 16" 1361da177e4SLinus Torvalds #endif 1371da177e4SLinus Torvalds /* Bit reversed order to get same names for same minors with all 1381da177e4SLinus Torvalds mode counts */ 1390ad78200SArjan van de Ven static const char *st_formats[] = { 1401da177e4SLinus Torvalds "", "r", "k", "s", "l", "t", "o", "u", 1411da177e4SLinus Torvalds "m", "v", "p", "x", "a", "y", "q", "z"}; 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds /* The default definitions have been moved to st_options.h */ 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE) 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds /* The buffer size should fit into the 24 bits for length in the 1481da177e4SLinus Torvalds 6-byte SCSI read and write commands. */ 1491da177e4SLinus Torvalds #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1) 1501da177e4SLinus Torvalds #error "Buffer size should not exceed (2 << 24 - 1) bytes!" 1511da177e4SLinus Torvalds #endif 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds static int debugging = DEBUG; 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds #define MAX_RETRIES 0 1561da177e4SLinus Torvalds #define MAX_WRITE_RETRIES 0 1571da177e4SLinus Torvalds #define MAX_READY_RETRIES 0 1581da177e4SLinus Torvalds #define NO_TAPE NOT_READY 1591da177e4SLinus Torvalds 1601da177e4SLinus Torvalds #define ST_TIMEOUT (900 * HZ) 1611da177e4SLinus Torvalds #define ST_LONG_TIMEOUT (14000 * HZ) 1621da177e4SLinus Torvalds 1631da177e4SLinus Torvalds /* Remove mode bits and auto-rewind bit (7) */ 1641da177e4SLinus Torvalds #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \ 1651da177e4SLinus Torvalds (iminor(x) & ~(-1 << ST_MODE_SHIFT)) ) 1661da177e4SLinus Torvalds #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT) 1671da177e4SLinus Torvalds 1681da177e4SLinus Torvalds /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */ 1691da177e4SLinus Torvalds #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \ 1701da177e4SLinus Torvalds (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) ) 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower 1731da177e4SLinus Torvalds 24 bits) */ 1741da177e4SLinus Torvalds #define SET_DENS_AND_BLK 0x10001 1751da177e4SLinus Torvalds 1761da177e4SLinus Torvalds static DEFINE_RWLOCK(st_dev_arr_lock); 1771da177e4SLinus Torvalds 1781da177e4SLinus Torvalds static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE; 1791da177e4SLinus Torvalds static int st_max_sg_segs = ST_MAX_SG; 1801da177e4SLinus Torvalds 1811da177e4SLinus Torvalds static struct scsi_tape **scsi_tapes = NULL; 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds static int modes_defined; 1841da177e4SLinus Torvalds 1851da177e4SLinus Torvalds static struct st_buffer *new_tape_buffer(int, int, int); 1861da177e4SLinus Torvalds static int enlarge_buffer(struct st_buffer *, int, int); 18740f6b36cSKai Makisara static void clear_buffer(struct st_buffer *); 1881da177e4SLinus Torvalds static void normalize_buffer(struct st_buffer *); 1891da177e4SLinus Torvalds static int append_to_buffer(const char __user *, struct st_buffer *, int); 1901da177e4SLinus Torvalds static int from_buffer(struct st_buffer *, char __user *, int); 1911da177e4SLinus Torvalds static void move_buffer_data(struct st_buffer *, int); 1921da177e4SLinus Torvalds static void buf_to_sg(struct st_buffer *, unsigned int); 1931da177e4SLinus Torvalds 1941da177e4SLinus Torvalds static int sgl_map_user_pages(struct scatterlist *, const unsigned int, 1951da177e4SLinus Torvalds unsigned long, size_t, int); 1961da177e4SLinus Torvalds static int sgl_unmap_user_pages(struct scatterlist *, 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); 20313026a6bSJeff Garzik static int do_create_class_files(struct scsi_tape *, int, int); 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds static struct scsi_driver st_template = { 2061da177e4SLinus Torvalds .owner = THIS_MODULE, 2071da177e4SLinus Torvalds .gendrv = { 2081da177e4SLinus Torvalds .name = "st", 2091da177e4SLinus Torvalds .probe = st_probe, 2101da177e4SLinus Torvalds .remove = st_remove, 2111da177e4SLinus Torvalds }, 2121da177e4SLinus Torvalds }; 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds static int st_compression(struct scsi_tape *, int); 2151da177e4SLinus Torvalds 2161da177e4SLinus Torvalds static int find_partition(struct scsi_tape *); 2171da177e4SLinus Torvalds static int switch_partition(struct scsi_tape *); 2181da177e4SLinus Torvalds 2191da177e4SLinus Torvalds static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long); 2201da177e4SLinus Torvalds 221f03a5670SKai Makisara static void scsi_tape_release(struct kref *); 222f03a5670SKai Makisara 223f03a5670SKai Makisara #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref) 224f03a5670SKai Makisara 2250b950672SArjan van de Ven static DEFINE_MUTEX(st_ref_mutex); 226f03a5670SKai Makisara 2271da177e4SLinus Torvalds 2281da177e4SLinus Torvalds #include "osst_detect.h" 2291da177e4SLinus Torvalds #ifndef SIGS_FROM_OSST 2301da177e4SLinus Torvalds #define SIGS_FROM_OSST \ 2311da177e4SLinus Torvalds {"OnStream", "SC-", "", "osst"}, \ 2321da177e4SLinus Torvalds {"OnStream", "DI-", "", "osst"}, \ 2331da177e4SLinus Torvalds {"OnStream", "DP-", "", "osst"}, \ 2341da177e4SLinus Torvalds {"OnStream", "USB", "", "osst"}, \ 2351da177e4SLinus Torvalds {"OnStream", "FW-", "", "osst"} 2361da177e4SLinus Torvalds #endif 2371da177e4SLinus Torvalds 238f03a5670SKai Makisara static struct scsi_tape *scsi_tape_get(int dev) 239f03a5670SKai Makisara { 240f03a5670SKai Makisara struct scsi_tape *STp = NULL; 241f03a5670SKai Makisara 2420b950672SArjan van de Ven mutex_lock(&st_ref_mutex); 243f03a5670SKai Makisara write_lock(&st_dev_arr_lock); 244f03a5670SKai Makisara 245f03a5670SKai Makisara if (dev < st_dev_max && scsi_tapes != NULL) 246f03a5670SKai Makisara STp = scsi_tapes[dev]; 247f03a5670SKai Makisara if (!STp) goto out; 248f03a5670SKai Makisara 249f03a5670SKai Makisara kref_get(&STp->kref); 250f03a5670SKai Makisara 251f03a5670SKai Makisara if (!STp->device) 252f03a5670SKai Makisara goto out_put; 253f03a5670SKai Makisara 254f03a5670SKai Makisara if (scsi_device_get(STp->device)) 255f03a5670SKai Makisara goto out_put; 256f03a5670SKai Makisara 257f03a5670SKai Makisara goto out; 258f03a5670SKai Makisara 259f03a5670SKai Makisara out_put: 260f03a5670SKai Makisara kref_put(&STp->kref, scsi_tape_release); 261f03a5670SKai Makisara STp = NULL; 262f03a5670SKai Makisara out: 263f03a5670SKai Makisara write_unlock(&st_dev_arr_lock); 2640b950672SArjan van de Ven mutex_unlock(&st_ref_mutex); 265f03a5670SKai Makisara return STp; 266f03a5670SKai Makisara } 267f03a5670SKai Makisara 268f03a5670SKai Makisara static void scsi_tape_put(struct scsi_tape *STp) 269f03a5670SKai Makisara { 270f03a5670SKai Makisara struct scsi_device *sdev = STp->device; 271f03a5670SKai Makisara 2720b950672SArjan van de Ven mutex_lock(&st_ref_mutex); 273f03a5670SKai Makisara kref_put(&STp->kref, scsi_tape_release); 274f03a5670SKai Makisara scsi_device_put(sdev); 2750b950672SArjan van de Ven mutex_unlock(&st_ref_mutex); 276f03a5670SKai Makisara } 277f03a5670SKai Makisara 2781da177e4SLinus Torvalds struct st_reject_data { 2791da177e4SLinus Torvalds char *vendor; 2801da177e4SLinus Torvalds char *model; 2811da177e4SLinus Torvalds char *rev; 2821da177e4SLinus Torvalds char *driver_hint; /* Name of the correct driver, NULL if unknown */ 2831da177e4SLinus Torvalds }; 2841da177e4SLinus Torvalds 2851da177e4SLinus Torvalds static struct st_reject_data reject_list[] = { 2861da177e4SLinus Torvalds /* {"XXX", "Yy-", "", NULL}, example */ 2871da177e4SLinus Torvalds SIGS_FROM_OSST, 2881da177e4SLinus Torvalds {NULL, }}; 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds /* If the device signature is on the list of incompatible drives, the 2911da177e4SLinus Torvalds function returns a pointer to the name of the correct driver (if known) */ 2921da177e4SLinus Torvalds static char * st_incompatible(struct scsi_device* SDp) 2931da177e4SLinus Torvalds { 2941da177e4SLinus Torvalds struct st_reject_data *rp; 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds for (rp=&(reject_list[0]); rp->vendor != NULL; rp++) 2971da177e4SLinus Torvalds if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) && 2981da177e4SLinus Torvalds !strncmp(rp->model, SDp->model, strlen(rp->model)) && 2991da177e4SLinus Torvalds !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) { 3001da177e4SLinus Torvalds if (rp->driver_hint) 3011da177e4SLinus Torvalds return rp->driver_hint; 3021da177e4SLinus Torvalds else 3031da177e4SLinus Torvalds return "unknown"; 3041da177e4SLinus Torvalds } 3051da177e4SLinus Torvalds return NULL; 3061da177e4SLinus Torvalds } 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds 3091da177e4SLinus Torvalds static inline char *tape_name(struct scsi_tape *tape) 3101da177e4SLinus Torvalds { 3111da177e4SLinus Torvalds return tape->disk->disk_name; 3121da177e4SLinus Torvalds } 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds 3158b05b773SMike Christie static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s) 3161da177e4SLinus Torvalds { 3171da177e4SLinus Torvalds const u8 *ucp; 3188b05b773SMike Christie const u8 *sense = SRpnt->sense; 3191da177e4SLinus Torvalds 3208b05b773SMike Christie s->have_sense = scsi_normalize_sense(SRpnt->sense, 3218b05b773SMike Christie SCSI_SENSE_BUFFERSIZE, &s->sense_hdr); 3221da177e4SLinus Torvalds s->flags = 0; 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds if (s->have_sense) { 3251da177e4SLinus Torvalds s->deferred = 0; 3261da177e4SLinus Torvalds s->remainder_valid = 3271da177e4SLinus Torvalds scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64); 3281da177e4SLinus Torvalds switch (sense[0] & 0x7f) { 3291da177e4SLinus Torvalds case 0x71: 3301da177e4SLinus Torvalds s->deferred = 1; 3311da177e4SLinus Torvalds case 0x70: 3321da177e4SLinus Torvalds s->fixed_format = 1; 3331da177e4SLinus Torvalds s->flags = sense[2] & 0xe0; 3341da177e4SLinus Torvalds break; 3351da177e4SLinus Torvalds case 0x73: 3361da177e4SLinus Torvalds s->deferred = 1; 3371da177e4SLinus Torvalds case 0x72: 3381da177e4SLinus Torvalds s->fixed_format = 0; 3391da177e4SLinus Torvalds ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4); 3401da177e4SLinus Torvalds s->flags = ucp ? (ucp[3] & 0xe0) : 0; 3411da177e4SLinus Torvalds break; 3421da177e4SLinus Torvalds } 3431da177e4SLinus Torvalds } 3441da177e4SLinus Torvalds } 3451da177e4SLinus Torvalds 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds /* Convert the result to success code */ 3488b05b773SMike Christie static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt) 3491da177e4SLinus Torvalds { 3508b05b773SMike Christie int result = SRpnt->result; 3511da177e4SLinus Torvalds u8 scode; 3521da177e4SLinus Torvalds DEB(const char *stp;) 3531da177e4SLinus Torvalds char *name = tape_name(STp); 3541da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp; 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds if (!result) 3571da177e4SLinus Torvalds return 0; 3581da177e4SLinus Torvalds 3591da177e4SLinus Torvalds cmdstatp = &STp->buffer->cmdstat; 360f03a5670SKai Makisara st_analyze_sense(SRpnt, cmdstatp); 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds if (cmdstatp->have_sense) 3631da177e4SLinus Torvalds scode = STp->buffer->cmdstat.sense_hdr.sense_key; 3641da177e4SLinus Torvalds else 3651da177e4SLinus Torvalds scode = 0; 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds DEB( 3681da177e4SLinus Torvalds if (debugging) { 3698b05b773SMike Christie printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n", 3701da177e4SLinus Torvalds name, result, 3718b05b773SMike Christie SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2], 3728b05b773SMike Christie SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]); 3731da177e4SLinus Torvalds if (cmdstatp->have_sense) 3744e73ea7bSLuben Tuikov __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE); 3751da177e4SLinus Torvalds } ) /* end DEB */ 3761da177e4SLinus Torvalds if (!debugging) { /* Abnormal conditions for tape */ 3771da177e4SLinus Torvalds if (!cmdstatp->have_sense) 3781da177e4SLinus Torvalds printk(KERN_WARNING 3791da177e4SLinus Torvalds "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n", 3801da177e4SLinus Torvalds name, result, suggestion(result), 3811da177e4SLinus Torvalds driver_byte(result) & DRIVER_MASK, host_byte(result)); 3821da177e4SLinus Torvalds else if (cmdstatp->have_sense && 3831da177e4SLinus Torvalds scode != NO_SENSE && 3841da177e4SLinus Torvalds scode != RECOVERED_ERROR && 3851da177e4SLinus Torvalds /* scode != UNIT_ATTENTION && */ 3861da177e4SLinus Torvalds scode != BLANK_CHECK && 3871da177e4SLinus Torvalds scode != VOLUME_OVERFLOW && 3888b05b773SMike Christie SRpnt->cmd[0] != MODE_SENSE && 3898b05b773SMike Christie SRpnt->cmd[0] != TEST_UNIT_READY) { 3904e73ea7bSLuben Tuikov 3914e73ea7bSLuben Tuikov __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE); 3921da177e4SLinus Torvalds } 3931da177e4SLinus Torvalds } 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds if (cmdstatp->fixed_format && 3961da177e4SLinus Torvalds STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */ 3971da177e4SLinus Torvalds if (STp->cln_sense_value) 3988b05b773SMike Christie STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] & 3991da177e4SLinus Torvalds STp->cln_sense_mask) == STp->cln_sense_value); 4001da177e4SLinus Torvalds else 4018b05b773SMike Christie STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] & 4021da177e4SLinus Torvalds STp->cln_sense_mask) != 0); 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds if (cmdstatp->have_sense && 4051da177e4SLinus Torvalds cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17) 4061da177e4SLinus Torvalds STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */ 4071da177e4SLinus Torvalds 4081da177e4SLinus Torvalds STp->pos_unknown |= STp->device->was_reset; 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds if (cmdstatp->have_sense && 4111da177e4SLinus Torvalds scode == RECOVERED_ERROR 4121da177e4SLinus Torvalds #if ST_RECOVERED_WRITE_FATAL 4138b05b773SMike Christie && SRpnt->cmd[0] != WRITE_6 4148b05b773SMike Christie && SRpnt->cmd[0] != WRITE_FILEMARKS 4151da177e4SLinus Torvalds #endif 4161da177e4SLinus Torvalds ) { 4171da177e4SLinus Torvalds STp->recover_count++; 4181da177e4SLinus Torvalds STp->recover_reg++; 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds DEB( 4211da177e4SLinus Torvalds if (debugging) { 4228b05b773SMike Christie if (SRpnt->cmd[0] == READ_6) 4231da177e4SLinus Torvalds stp = "read"; 4248b05b773SMike Christie else if (SRpnt->cmd[0] == WRITE_6) 4251da177e4SLinus Torvalds stp = "write"; 4261da177e4SLinus Torvalds else 4271da177e4SLinus Torvalds stp = "ioctl"; 4281da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp, 4291da177e4SLinus Torvalds STp->recover_count); 4301da177e4SLinus Torvalds } ) /* end DEB */ 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds if (cmdstatp->flags == 0) 4331da177e4SLinus Torvalds return 0; 4341da177e4SLinus Torvalds } 4351da177e4SLinus Torvalds return (-EIO); 4361da177e4SLinus Torvalds } 4371da177e4SLinus Torvalds 4381da177e4SLinus Torvalds 4391da177e4SLinus Torvalds /* Wakeup from interrupt */ 4408b05b773SMike Christie static void st_sleep_done(void *data, char *sense, int result, int resid) 4411da177e4SLinus Torvalds { 4428b05b773SMike Christie struct st_request *SRpnt = data; 4438b05b773SMike Christie struct scsi_tape *STp = SRpnt->stp; 4441da177e4SLinus Torvalds 4458b05b773SMike Christie memcpy(SRpnt->sense, sense, SCSI_SENSE_BUFFERSIZE); 4468b05b773SMike Christie (STp->buffer)->cmdstat.midlevel_result = SRpnt->result = result; 44740f6b36cSKai Makisara (STp->buffer)->cmdstat.residual = resid; 4481da177e4SLinus Torvalds DEB( STp->write_pending = 0; ) 4491da177e4SLinus Torvalds 4508b05b773SMike Christie if (SRpnt->waiting) 4518b05b773SMike Christie complete(SRpnt->waiting); 4528b05b773SMike Christie } 4538b05b773SMike Christie 4544deba245SFUJITA Tomonori static struct st_request *st_allocate_request(struct scsi_tape *stp) 4558b05b773SMike Christie { 4564deba245SFUJITA Tomonori struct st_request *streq; 4574deba245SFUJITA Tomonori 4584deba245SFUJITA Tomonori streq = kzalloc(sizeof(*streq), GFP_KERNEL); 4594deba245SFUJITA Tomonori if (streq) 4604deba245SFUJITA Tomonori streq->stp = stp; 4614deba245SFUJITA Tomonori else { 4624deba245SFUJITA Tomonori DEBC(printk(KERN_ERR "%s: Can't get SCSI request.\n", 4634deba245SFUJITA Tomonori tape_name(stp));); 4644deba245SFUJITA Tomonori if (signal_pending(current)) 4654deba245SFUJITA Tomonori stp->buffer->syscall_result = -EINTR; 4664deba245SFUJITA Tomonori else 4674deba245SFUJITA Tomonori stp->buffer->syscall_result = -EBUSY; 4684deba245SFUJITA Tomonori } 4694deba245SFUJITA Tomonori 4704deba245SFUJITA Tomonori return streq; 4718b05b773SMike Christie } 4728b05b773SMike Christie 4738b05b773SMike Christie static void st_release_request(struct st_request *streq) 4748b05b773SMike Christie { 4758b05b773SMike Christie kfree(streq); 4761da177e4SLinus Torvalds } 4771da177e4SLinus Torvalds 4781da177e4SLinus Torvalds /* Do the scsi command. Waits until command performed if do_wait is true. 4791da177e4SLinus Torvalds Otherwise write_behind_check() is used to check that the command 4801da177e4SLinus Torvalds has finished. */ 4818b05b773SMike Christie static struct st_request * 4828b05b773SMike Christie st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd, 4831da177e4SLinus Torvalds int bytes, int direction, int timeout, int retries, int do_wait) 4841da177e4SLinus Torvalds { 485f03a5670SKai Makisara struct completion *waiting; 4861da177e4SLinus Torvalds 487f03a5670SKai Makisara /* if async, make sure there's no command outstanding */ 488f03a5670SKai Makisara if (!do_wait && ((STp->buffer)->last_SRpnt)) { 489f03a5670SKai Makisara printk(KERN_ERR "%s: Async command already active.\n", 490f03a5670SKai Makisara tape_name(STp)); 491f03a5670SKai Makisara if (signal_pending(current)) 492f03a5670SKai Makisara (STp->buffer)->syscall_result = (-EINTR); 493f03a5670SKai Makisara else 494f03a5670SKai Makisara (STp->buffer)->syscall_result = (-EBUSY); 495f03a5670SKai Makisara return NULL; 496f03a5670SKai Makisara } 497f03a5670SKai Makisara 4984deba245SFUJITA Tomonori if (!SRpnt) { 4994deba245SFUJITA Tomonori SRpnt = st_allocate_request(STp); 5004deba245SFUJITA Tomonori if (!SRpnt) 5011da177e4SLinus Torvalds return NULL; 5021da177e4SLinus Torvalds } 5031da177e4SLinus Torvalds 504f03a5670SKai Makisara /* If async IO, set last_SRpnt. This ptr tells write_behind_check 505f03a5670SKai Makisara which IO is outstanding. It's nulled out when the IO completes. */ 506f03a5670SKai Makisara if (!do_wait) 507f03a5670SKai Makisara (STp->buffer)->last_SRpnt = SRpnt; 508f03a5670SKai Makisara 509f03a5670SKai Makisara waiting = &STp->wait; 510f03a5670SKai Makisara init_completion(waiting); 5118b05b773SMike Christie SRpnt->waiting = waiting; 5128b05b773SMike Christie 5131da177e4SLinus Torvalds if (!STp->buffer->do_dio) 5141da177e4SLinus Torvalds buf_to_sg(STp->buffer, bytes); 5158b05b773SMike Christie 5168b05b773SMike Christie memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd)); 5171da177e4SLinus Torvalds STp->buffer->cmdstat.have_sense = 0; 5188b05b773SMike Christie STp->buffer->syscall_result = 0; 5191da177e4SLinus Torvalds 520bb1d1073Sbrking@us.ibm.com if (scsi_execute_async(STp->device, cmd, COMMAND_SIZE(cmd[0]), direction, 5218b05b773SMike Christie &((STp->buffer)->sg[0]), bytes, (STp->buffer)->sg_segs, 522787926b1SKai Makisara timeout, retries, SRpnt, st_sleep_done, GFP_KERNEL)) { 5238b05b773SMike Christie /* could not allocate the buffer or request was too large */ 5248b05b773SMike Christie (STp->buffer)->syscall_result = (-EBUSY); 525787926b1SKai Makisara (STp->buffer)->last_SRpnt = NULL; 526787926b1SKai Makisara } 5278b05b773SMike Christie else if (do_wait) { 528f03a5670SKai Makisara wait_for_completion(waiting); 5298b05b773SMike Christie SRpnt->waiting = NULL; 5301da177e4SLinus Torvalds (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt); 5311da177e4SLinus Torvalds } 5328b05b773SMike Christie 5331da177e4SLinus Torvalds return SRpnt; 5341da177e4SLinus Torvalds } 5351da177e4SLinus Torvalds 536ffb43494SFUJITA Tomonori static int st_scsi_kern_execute(struct st_request *streq, 537ffb43494SFUJITA Tomonori const unsigned char *cmd, int data_direction, 538ffb43494SFUJITA Tomonori void *buffer, unsigned bufflen, int timeout, 539ffb43494SFUJITA Tomonori int retries) 540ffb43494SFUJITA Tomonori { 541ffb43494SFUJITA Tomonori struct scsi_tape *stp = streq->stp; 542ffb43494SFUJITA Tomonori int ret, resid; 543ffb43494SFUJITA Tomonori 544ffb43494SFUJITA Tomonori stp->buffer->cmdstat.have_sense = 0; 545ffb43494SFUJITA Tomonori memcpy(streq->cmd, cmd, sizeof(streq->cmd)); 546ffb43494SFUJITA Tomonori 547ffb43494SFUJITA Tomonori ret = scsi_execute(stp->device, cmd, data_direction, buffer, bufflen, 548ffb43494SFUJITA Tomonori streq->sense, timeout, retries, 0, &resid); 549ffb43494SFUJITA Tomonori if (driver_byte(ret) & DRIVER_ERROR) 550ffb43494SFUJITA Tomonori return -EBUSY; 551ffb43494SFUJITA Tomonori 552ffb43494SFUJITA Tomonori stp->buffer->cmdstat.midlevel_result = streq->result = ret; 553ffb43494SFUJITA Tomonori stp->buffer->cmdstat.residual = resid; 554ffb43494SFUJITA Tomonori stp->buffer->syscall_result = st_chk_result(stp, streq); 555ffb43494SFUJITA Tomonori 556ffb43494SFUJITA Tomonori return 0; 557ffb43494SFUJITA Tomonori } 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if 5601da177e4SLinus Torvalds write has been correct but EOM early warning reached, -EIO if write ended in 5611da177e4SLinus Torvalds error or zero if write successful. Asynchronous writes are used only in 5621da177e4SLinus Torvalds variable block mode. */ 5631da177e4SLinus Torvalds static int write_behind_check(struct scsi_tape * STp) 5641da177e4SLinus Torvalds { 5651da177e4SLinus Torvalds int retval = 0; 5661da177e4SLinus Torvalds struct st_buffer *STbuffer; 5671da177e4SLinus Torvalds struct st_partstat *STps; 5681da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp; 5698b05b773SMike Christie struct st_request *SRpnt; 5701da177e4SLinus Torvalds 5711da177e4SLinus Torvalds STbuffer = STp->buffer; 5721da177e4SLinus Torvalds if (!STbuffer->writing) 5731da177e4SLinus Torvalds return 0; 5741da177e4SLinus Torvalds 5751da177e4SLinus Torvalds DEB( 5761da177e4SLinus Torvalds if (STp->write_pending) 5771da177e4SLinus Torvalds STp->nbr_waits++; 5781da177e4SLinus Torvalds else 5791da177e4SLinus Torvalds STp->nbr_finished++; 5801da177e4SLinus Torvalds ) /* end DEB */ 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds wait_for_completion(&(STp->wait)); 583f03a5670SKai Makisara SRpnt = STbuffer->last_SRpnt; 584f03a5670SKai Makisara STbuffer->last_SRpnt = NULL; 5858b05b773SMike Christie SRpnt->waiting = NULL; 5861da177e4SLinus Torvalds 587f03a5670SKai Makisara (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt); 5888b05b773SMike Christie st_release_request(SRpnt); 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds STbuffer->buffer_bytes -= STbuffer->writing; 5911da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 5921da177e4SLinus Torvalds if (STps->drv_block >= 0) { 5931da177e4SLinus Torvalds if (STp->block_size == 0) 5941da177e4SLinus Torvalds STps->drv_block++; 5951da177e4SLinus Torvalds else 5961da177e4SLinus Torvalds STps->drv_block += STbuffer->writing / STp->block_size; 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds cmdstatp = &STbuffer->cmdstat; 6001da177e4SLinus Torvalds if (STbuffer->syscall_result) { 6011da177e4SLinus Torvalds retval = -EIO; 6021da177e4SLinus Torvalds if (cmdstatp->have_sense && !cmdstatp->deferred && 6031da177e4SLinus Torvalds (cmdstatp->flags & SENSE_EOM) && 6041da177e4SLinus Torvalds (cmdstatp->sense_hdr.sense_key == NO_SENSE || 6051da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) { 6061da177e4SLinus Torvalds /* EOM at write-behind, has all data been written? */ 6071da177e4SLinus Torvalds if (!cmdstatp->remainder_valid || 6081da177e4SLinus Torvalds cmdstatp->uremainder64 == 0) 6091da177e4SLinus Torvalds retval = -ENOSPC; 6101da177e4SLinus Torvalds } 6111da177e4SLinus Torvalds if (retval == -EIO) 6121da177e4SLinus Torvalds STps->drv_block = -1; 6131da177e4SLinus Torvalds } 6141da177e4SLinus Torvalds STbuffer->writing = 0; 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds DEB(if (debugging && retval) 6171da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n", 6181da177e4SLinus Torvalds tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */ 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds return retval; 6211da177e4SLinus Torvalds } 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds /* Step over EOF if it has been inadvertently crossed (ioctl not used because 6251da177e4SLinus Torvalds it messes up the block number). */ 6261da177e4SLinus Torvalds static int cross_eof(struct scsi_tape * STp, int forward) 6271da177e4SLinus Torvalds { 6288b05b773SMike Christie struct st_request *SRpnt; 6291da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 6301da177e4SLinus Torvalds 6311da177e4SLinus Torvalds cmd[0] = SPACE; 6321da177e4SLinus Torvalds cmd[1] = 0x01; /* Space FileMarks */ 6331da177e4SLinus Torvalds if (forward) { 6341da177e4SLinus Torvalds cmd[2] = cmd[3] = 0; 6351da177e4SLinus Torvalds cmd[4] = 1; 6361da177e4SLinus Torvalds } else 6371da177e4SLinus Torvalds cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */ 6381da177e4SLinus Torvalds cmd[5] = 0; 6391da177e4SLinus Torvalds 6401da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n", 6411da177e4SLinus Torvalds tape_name(STp), forward ? "forward" : "backward")); 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE, 644a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 645a02488edSJames Bottomley MAX_RETRIES, 1); 6461da177e4SLinus Torvalds if (!SRpnt) 6471da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 6481da177e4SLinus Torvalds 6498b05b773SMike Christie st_release_request(SRpnt); 6501da177e4SLinus Torvalds SRpnt = NULL; 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds if ((STp->buffer)->cmdstat.midlevel_result != 0) 6531da177e4SLinus Torvalds printk(KERN_ERR "%s: Stepping over filemark %s failed.\n", 6541da177e4SLinus Torvalds tape_name(STp), forward ? "forward" : "backward"); 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 6571da177e4SLinus Torvalds } 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds 6601da177e4SLinus Torvalds /* Flush the write buffer (never need to write if variable blocksize). */ 6618ef8d594SAdrian Bunk static int st_flush_write_buffer(struct scsi_tape * STp) 6621da177e4SLinus Torvalds { 663786231afSKai Makisara int transfer, blks; 6641da177e4SLinus Torvalds int result; 6651da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 6668b05b773SMike Christie struct st_request *SRpnt; 6671da177e4SLinus Torvalds struct st_partstat *STps; 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds result = write_behind_check(STp); 6701da177e4SLinus Torvalds if (result) 6711da177e4SLinus Torvalds return result; 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds result = 0; 6741da177e4SLinus Torvalds if (STp->dirty == 1) { 6751da177e4SLinus Torvalds 676786231afSKai Makisara transfer = STp->buffer->buffer_bytes; 6771da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n", 6781da177e4SLinus Torvalds tape_name(STp), transfer)); 6791da177e4SLinus Torvalds 6801da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 6811da177e4SLinus Torvalds cmd[0] = WRITE_6; 6821da177e4SLinus Torvalds cmd[1] = 1; 6831da177e4SLinus Torvalds blks = transfer / STp->block_size; 6841da177e4SLinus Torvalds cmd[2] = blks >> 16; 6851da177e4SLinus Torvalds cmd[3] = blks >> 8; 6861da177e4SLinus Torvalds cmd[4] = blks; 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE, 689a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 690a02488edSJames Bottomley MAX_WRITE_RETRIES, 1); 6911da177e4SLinus Torvalds if (!SRpnt) 6921da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 6931da177e4SLinus Torvalds 6941da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 6951da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0) { 6961da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds if (cmdstatp->have_sense && !cmdstatp->deferred && 6991da177e4SLinus Torvalds (cmdstatp->flags & SENSE_EOM) && 7001da177e4SLinus Torvalds (cmdstatp->sense_hdr.sense_key == NO_SENSE || 7011da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) && 7021da177e4SLinus Torvalds (!cmdstatp->remainder_valid || 7031da177e4SLinus Torvalds cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */ 7041da177e4SLinus Torvalds STp->dirty = 0; 7051da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = 0; 7061da177e4SLinus Torvalds if (STps->drv_block >= 0) 7071da177e4SLinus Torvalds STps->drv_block += blks; 7081da177e4SLinus Torvalds result = (-ENOSPC); 7091da177e4SLinus Torvalds } else { 7101da177e4SLinus Torvalds printk(KERN_ERR "%s: Error on flush.\n", 7111da177e4SLinus Torvalds tape_name(STp)); 7121da177e4SLinus Torvalds STps->drv_block = (-1); 7131da177e4SLinus Torvalds result = (-EIO); 7141da177e4SLinus Torvalds } 7151da177e4SLinus Torvalds } else { 7161da177e4SLinus Torvalds if (STps->drv_block >= 0) 7171da177e4SLinus Torvalds STps->drv_block += blks; 7181da177e4SLinus Torvalds STp->dirty = 0; 7191da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = 0; 7201da177e4SLinus Torvalds } 7218b05b773SMike Christie st_release_request(SRpnt); 7221da177e4SLinus Torvalds SRpnt = NULL; 7231da177e4SLinus Torvalds } 7241da177e4SLinus Torvalds return result; 7251da177e4SLinus Torvalds } 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds 7281da177e4SLinus Torvalds /* Flush the tape buffer. The tape will be positioned correctly unless 7291da177e4SLinus Torvalds seek_next is true. */ 7301da177e4SLinus Torvalds static int flush_buffer(struct scsi_tape *STp, int seek_next) 7311da177e4SLinus Torvalds { 7321da177e4SLinus Torvalds int backspace, result; 7331da177e4SLinus Torvalds struct st_buffer *STbuffer; 7341da177e4SLinus Torvalds struct st_partstat *STps; 7351da177e4SLinus Torvalds 7361da177e4SLinus Torvalds STbuffer = STp->buffer; 7371da177e4SLinus Torvalds 7381da177e4SLinus Torvalds /* 7391da177e4SLinus Torvalds * If there was a bus reset, block further access 7401da177e4SLinus Torvalds * to this device. 7411da177e4SLinus Torvalds */ 7421da177e4SLinus Torvalds if (STp->pos_unknown) 7431da177e4SLinus Torvalds return (-EIO); 7441da177e4SLinus Torvalds 7451da177e4SLinus Torvalds if (STp->ready != ST_READY) 7461da177e4SLinus Torvalds return 0; 7471da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 7481da177e4SLinus Torvalds if (STps->rw == ST_WRITING) /* Writing */ 7498ef8d594SAdrian Bunk return st_flush_write_buffer(STp); 7501da177e4SLinus Torvalds 7511da177e4SLinus Torvalds if (STp->block_size == 0) 7521da177e4SLinus Torvalds return 0; 7531da177e4SLinus Torvalds 7541da177e4SLinus Torvalds backspace = ((STp->buffer)->buffer_bytes + 7551da177e4SLinus Torvalds (STp->buffer)->read_pointer) / STp->block_size - 7561da177e4SLinus Torvalds ((STp->buffer)->read_pointer + STp->block_size - 1) / 7571da177e4SLinus Torvalds STp->block_size; 7581da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = 0; 7591da177e4SLinus Torvalds (STp->buffer)->read_pointer = 0; 7601da177e4SLinus Torvalds result = 0; 7611da177e4SLinus Torvalds if (!seek_next) { 7621da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) { 7631da177e4SLinus Torvalds result = cross_eof(STp, 0); /* Back over the EOF hit */ 7641da177e4SLinus Torvalds if (!result) 7651da177e4SLinus Torvalds STps->eof = ST_NOEOF; 7661da177e4SLinus Torvalds else { 7671da177e4SLinus Torvalds if (STps->drv_file >= 0) 7681da177e4SLinus Torvalds STps->drv_file++; 7691da177e4SLinus Torvalds STps->drv_block = 0; 7701da177e4SLinus Torvalds } 7711da177e4SLinus Torvalds } 7721da177e4SLinus Torvalds if (!result && backspace > 0) 7731da177e4SLinus Torvalds result = st_int_ioctl(STp, MTBSR, backspace); 7741da177e4SLinus Torvalds } else if (STps->eof == ST_FM_HIT) { 7751da177e4SLinus Torvalds if (STps->drv_file >= 0) 7761da177e4SLinus Torvalds STps->drv_file++; 7771da177e4SLinus Torvalds STps->drv_block = 0; 7781da177e4SLinus Torvalds STps->eof = ST_NOEOF; 7791da177e4SLinus Torvalds } 7801da177e4SLinus Torvalds return result; 7811da177e4SLinus Torvalds 7821da177e4SLinus Torvalds } 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds /* Set the mode parameters */ 7851da177e4SLinus Torvalds static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm) 7861da177e4SLinus Torvalds { 7871da177e4SLinus Torvalds int set_it = 0; 7881da177e4SLinus Torvalds unsigned long arg; 7891da177e4SLinus Torvalds char *name = tape_name(STp); 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds if (!STp->density_changed && 7921da177e4SLinus Torvalds STm->default_density >= 0 && 7931da177e4SLinus Torvalds STm->default_density != STp->density) { 7941da177e4SLinus Torvalds arg = STm->default_density; 7951da177e4SLinus Torvalds set_it = 1; 7961da177e4SLinus Torvalds } else 7971da177e4SLinus Torvalds arg = STp->density; 7981da177e4SLinus Torvalds arg <<= MT_ST_DENSITY_SHIFT; 7991da177e4SLinus Torvalds if (!STp->blksize_changed && 8001da177e4SLinus Torvalds STm->default_blksize >= 0 && 8011da177e4SLinus Torvalds STm->default_blksize != STp->block_size) { 8021da177e4SLinus Torvalds arg |= STm->default_blksize; 8031da177e4SLinus Torvalds set_it = 1; 8041da177e4SLinus Torvalds } else 8051da177e4SLinus Torvalds arg |= STp->block_size; 8061da177e4SLinus Torvalds if (set_it && 8071da177e4SLinus Torvalds st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) { 8081da177e4SLinus Torvalds printk(KERN_WARNING 8091da177e4SLinus Torvalds "%s: Can't set default block size to %d bytes and density %x.\n", 8101da177e4SLinus Torvalds name, STm->default_blksize, STm->default_density); 8111da177e4SLinus Torvalds if (modes_defined) 8121da177e4SLinus Torvalds return (-EINVAL); 8131da177e4SLinus Torvalds } 8141da177e4SLinus Torvalds return 0; 8151da177e4SLinus Torvalds } 8161da177e4SLinus Torvalds 8171da177e4SLinus Torvalds 8188b05b773SMike Christie /* Lock or unlock the drive door. Don't use when st_request allocated. */ 8191da177e4SLinus Torvalds static int do_door_lock(struct scsi_tape * STp, int do_lock) 8201da177e4SLinus Torvalds { 8211da177e4SLinus Torvalds int retval, cmd; 8221da177e4SLinus Torvalds DEB(char *name = tape_name(STp);) 8231da177e4SLinus Torvalds 8241da177e4SLinus Torvalds 8251da177e4SLinus Torvalds cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK; 8261da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name, 8271da177e4SLinus Torvalds do_lock ? "L" : "Unl")); 8281da177e4SLinus Torvalds retval = scsi_ioctl(STp->device, cmd, NULL); 8291da177e4SLinus Torvalds if (!retval) { 8301da177e4SLinus Torvalds STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED; 8311da177e4SLinus Torvalds } 8321da177e4SLinus Torvalds else { 8331da177e4SLinus Torvalds STp->door_locked = ST_LOCK_FAILS; 8341da177e4SLinus Torvalds } 8351da177e4SLinus Torvalds return retval; 8361da177e4SLinus Torvalds } 8371da177e4SLinus Torvalds 8381da177e4SLinus Torvalds 8391da177e4SLinus Torvalds /* Set the internal state after reset */ 8401da177e4SLinus Torvalds static void reset_state(struct scsi_tape *STp) 8411da177e4SLinus Torvalds { 8421da177e4SLinus Torvalds int i; 8431da177e4SLinus Torvalds struct st_partstat *STps; 8441da177e4SLinus Torvalds 8451da177e4SLinus Torvalds STp->pos_unknown = 0; 8461da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 8471da177e4SLinus Torvalds STps = &(STp->ps[i]); 8481da177e4SLinus Torvalds STps->rw = ST_IDLE; 8491da177e4SLinus Torvalds STps->eof = ST_NOEOF; 8501da177e4SLinus Torvalds STps->at_sm = 0; 8511da177e4SLinus Torvalds STps->last_block_valid = 0; 8521da177e4SLinus Torvalds STps->drv_block = -1; 8531da177e4SLinus Torvalds STps->drv_file = -1; 8541da177e4SLinus Torvalds } 8551da177e4SLinus Torvalds if (STp->can_partitions) { 8561da177e4SLinus Torvalds STp->partition = find_partition(STp); 8571da177e4SLinus Torvalds if (STp->partition < 0) 8581da177e4SLinus Torvalds STp->partition = 0; 8591da177e4SLinus Torvalds STp->new_partition = STp->partition; 8601da177e4SLinus Torvalds } 8611da177e4SLinus Torvalds } 8621da177e4SLinus Torvalds 8631da177e4SLinus Torvalds /* Test if the drive is ready. Returns either one of the codes below or a negative system 8641da177e4SLinus Torvalds error code. */ 8651da177e4SLinus Torvalds #define CHKRES_READY 0 8661da177e4SLinus Torvalds #define CHKRES_NEW_SESSION 1 8671da177e4SLinus Torvalds #define CHKRES_NOT_READY 2 8681da177e4SLinus Torvalds #define CHKRES_NO_TAPE 3 8691da177e4SLinus Torvalds 8701da177e4SLinus Torvalds #define MAX_ATTENTIONS 10 8711da177e4SLinus Torvalds 8721da177e4SLinus Torvalds static int test_ready(struct scsi_tape *STp, int do_wait) 8731da177e4SLinus Torvalds { 8741da177e4SLinus Torvalds int attentions, waits, max_wait, scode; 8751da177e4SLinus Torvalds int retval = CHKRES_READY, new_session = 0; 8761da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 8778b05b773SMike Christie struct st_request *SRpnt = NULL; 8781da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 8791da177e4SLinus Torvalds 8801da177e4SLinus Torvalds max_wait = do_wait ? ST_BLOCK_SECONDS : 0; 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds for (attentions=waits=0; ; ) { 8831da177e4SLinus Torvalds memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 8841da177e4SLinus Torvalds cmd[0] = TEST_UNIT_READY; 8851da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, 8861da177e4SLinus Torvalds STp->long_timeout, MAX_READY_RETRIES, 1); 8871da177e4SLinus Torvalds 8881da177e4SLinus Torvalds if (!SRpnt) { 8891da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 8901da177e4SLinus Torvalds break; 8911da177e4SLinus Torvalds } 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds if (cmdstatp->have_sense) { 8941da177e4SLinus Torvalds 8951da177e4SLinus Torvalds scode = cmdstatp->sense_hdr.sense_key; 8961da177e4SLinus Torvalds 8971da177e4SLinus Torvalds if (scode == UNIT_ATTENTION) { /* New media? */ 8981da177e4SLinus Torvalds new_session = 1; 8991da177e4SLinus Torvalds if (attentions < MAX_ATTENTIONS) { 9001da177e4SLinus Torvalds attentions++; 9011da177e4SLinus Torvalds continue; 9021da177e4SLinus Torvalds } 9031da177e4SLinus Torvalds else { 9041da177e4SLinus Torvalds retval = (-EIO); 9051da177e4SLinus Torvalds break; 9061da177e4SLinus Torvalds } 9071da177e4SLinus Torvalds } 9081da177e4SLinus Torvalds 9091da177e4SLinus Torvalds if (scode == NOT_READY) { 9101da177e4SLinus Torvalds if (waits < max_wait) { 9111da177e4SLinus Torvalds if (msleep_interruptible(1000)) { 9121da177e4SLinus Torvalds retval = (-EINTR); 9131da177e4SLinus Torvalds break; 9141da177e4SLinus Torvalds } 9151da177e4SLinus Torvalds waits++; 9161da177e4SLinus Torvalds continue; 9171da177e4SLinus Torvalds } 9181da177e4SLinus Torvalds else { 9191da177e4SLinus Torvalds if ((STp->device)->scsi_level >= SCSI_2 && 9201da177e4SLinus Torvalds cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */ 9211da177e4SLinus Torvalds retval = CHKRES_NO_TAPE; 9221da177e4SLinus Torvalds else 9231da177e4SLinus Torvalds retval = CHKRES_NOT_READY; 9241da177e4SLinus Torvalds break; 9251da177e4SLinus Torvalds } 9261da177e4SLinus Torvalds } 9271da177e4SLinus Torvalds } 9281da177e4SLinus Torvalds 9291da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 9301da177e4SLinus Torvalds if (!retval) 9311da177e4SLinus Torvalds retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY; 9321da177e4SLinus Torvalds break; 9331da177e4SLinus Torvalds } 9341da177e4SLinus Torvalds 9351da177e4SLinus Torvalds if (SRpnt != NULL) 9368b05b773SMike Christie st_release_request(SRpnt); 9371da177e4SLinus Torvalds return retval; 9381da177e4SLinus Torvalds } 9391da177e4SLinus Torvalds 9401da177e4SLinus Torvalds 9411da177e4SLinus Torvalds /* See if the drive is ready and gather information about the tape. Return values: 9421da177e4SLinus Torvalds < 0 negative error code from errno.h 9431da177e4SLinus Torvalds 0 drive ready 9441da177e4SLinus Torvalds 1 drive not ready (possibly no tape) 9451da177e4SLinus Torvalds */ 9461da177e4SLinus Torvalds static int check_tape(struct scsi_tape *STp, struct file *filp) 9471da177e4SLinus Torvalds { 9481da177e4SLinus Torvalds int i, retval, new_session = 0, do_wait; 9491da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning; 9501da177e4SLinus Torvalds unsigned short st_flags = filp->f_flags; 9518b05b773SMike Christie struct st_request *SRpnt = NULL; 9521da177e4SLinus Torvalds struct st_modedef *STm; 9531da177e4SLinus Torvalds struct st_partstat *STps; 9541da177e4SLinus Torvalds char *name = tape_name(STp); 9557ac6207bSJosef Sipek struct inode *inode = filp->f_path.dentry->d_inode; 9561da177e4SLinus Torvalds int mode = TAPE_MODE(inode); 9571da177e4SLinus Torvalds 9581da177e4SLinus Torvalds STp->ready = ST_READY; 9591da177e4SLinus Torvalds 9601da177e4SLinus Torvalds if (mode != STp->current_mode) { 9611da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n", 9621da177e4SLinus Torvalds name, STp->current_mode, mode)); 9631da177e4SLinus Torvalds new_session = 1; 9641da177e4SLinus Torvalds STp->current_mode = mode; 9651da177e4SLinus Torvalds } 9661da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 9671da177e4SLinus Torvalds 9681da177e4SLinus Torvalds saved_cleaning = STp->cleaning_req; 9691da177e4SLinus Torvalds STp->cleaning_req = 0; 9701da177e4SLinus Torvalds 9711da177e4SLinus Torvalds do_wait = ((filp->f_flags & O_NONBLOCK) == 0); 9721da177e4SLinus Torvalds retval = test_ready(STp, do_wait); 9731da177e4SLinus Torvalds 9741da177e4SLinus Torvalds if (retval < 0) 9751da177e4SLinus Torvalds goto err_out; 9761da177e4SLinus Torvalds 9771da177e4SLinus Torvalds if (retval == CHKRES_NEW_SESSION) { 9781da177e4SLinus Torvalds STp->pos_unknown = 0; 9791da177e4SLinus Torvalds STp->partition = STp->new_partition = 0; 9801da177e4SLinus Torvalds if (STp->can_partitions) 9811da177e4SLinus Torvalds STp->nbr_partitions = 1; /* This guess will be updated later 9821da177e4SLinus Torvalds if necessary */ 9831da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 9841da177e4SLinus Torvalds STps = &(STp->ps[i]); 9851da177e4SLinus Torvalds STps->rw = ST_IDLE; 9861da177e4SLinus Torvalds STps->eof = ST_NOEOF; 9871da177e4SLinus Torvalds STps->at_sm = 0; 9881da177e4SLinus Torvalds STps->last_block_valid = 0; 9891da177e4SLinus Torvalds STps->drv_block = 0; 9901da177e4SLinus Torvalds STps->drv_file = 0; 9911da177e4SLinus Torvalds } 9921da177e4SLinus Torvalds new_session = 1; 9931da177e4SLinus Torvalds } 9941da177e4SLinus Torvalds else { 9951da177e4SLinus Torvalds STp->cleaning_req |= saved_cleaning; 9961da177e4SLinus Torvalds 9971da177e4SLinus Torvalds if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) { 9981da177e4SLinus Torvalds if (retval == CHKRES_NO_TAPE) 9991da177e4SLinus Torvalds STp->ready = ST_NO_TAPE; 10001da177e4SLinus Torvalds else 10011da177e4SLinus Torvalds STp->ready = ST_NOT_READY; 10021da177e4SLinus Torvalds 10031da177e4SLinus Torvalds STp->density = 0; /* Clear the erroneous "residue" */ 10041da177e4SLinus Torvalds STp->write_prot = 0; 10051da177e4SLinus Torvalds STp->block_size = 0; 10061da177e4SLinus Torvalds STp->ps[0].drv_file = STp->ps[0].drv_block = (-1); 10071da177e4SLinus Torvalds STp->partition = STp->new_partition = 0; 10081da177e4SLinus Torvalds STp->door_locked = ST_UNLOCKED; 10091da177e4SLinus Torvalds return CHKRES_NOT_READY; 10101da177e4SLinus Torvalds } 10111da177e4SLinus Torvalds } 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds if (STp->omit_blklims) 10141da177e4SLinus Torvalds STp->min_block = STp->max_block = (-1); 10151da177e4SLinus Torvalds else { 10161da177e4SLinus Torvalds memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 10171da177e4SLinus Torvalds cmd[0] = READ_BLOCK_LIMITS; 10181da177e4SLinus Torvalds 10191da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE, 1020a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 1021a02488edSJames Bottomley MAX_READY_RETRIES, 1); 10221da177e4SLinus Torvalds if (!SRpnt) { 10231da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 10241da177e4SLinus Torvalds goto err_out; 10251da177e4SLinus Torvalds } 10261da177e4SLinus Torvalds 10278b05b773SMike Christie if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) { 10281da177e4SLinus Torvalds STp->max_block = ((STp->buffer)->b_data[1] << 16) | 10291da177e4SLinus Torvalds ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3]; 10301da177e4SLinus Torvalds STp->min_block = ((STp->buffer)->b_data[4] << 8) | 10311da177e4SLinus Torvalds (STp->buffer)->b_data[5]; 10321da177e4SLinus Torvalds if ( DEB( debugging || ) !STp->inited) 103342252854SKai Makisara printk(KERN_INFO 10341da177e4SLinus Torvalds "%s: Block limits %d - %d bytes.\n", name, 10351da177e4SLinus Torvalds STp->min_block, STp->max_block); 10361da177e4SLinus Torvalds } else { 10371da177e4SLinus Torvalds STp->min_block = STp->max_block = (-1); 10381da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n", 10391da177e4SLinus Torvalds name)); 10401da177e4SLinus Torvalds } 10411da177e4SLinus Torvalds } 10421da177e4SLinus Torvalds 10431da177e4SLinus Torvalds memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 10441da177e4SLinus Torvalds cmd[0] = MODE_SENSE; 10451da177e4SLinus Torvalds cmd[4] = 12; 10461da177e4SLinus Torvalds 10471da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE, 1048a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 1049a02488edSJames Bottomley MAX_READY_RETRIES, 1); 10501da177e4SLinus Torvalds if (!SRpnt) { 10511da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 10521da177e4SLinus Torvalds goto err_out; 10531da177e4SLinus Torvalds } 10541da177e4SLinus Torvalds 10551da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0) { 10561da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name)); 10571da177e4SLinus Torvalds STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */ 10581da177e4SLinus Torvalds (STp->buffer)->syscall_result = 0; /* Prevent error propagation */ 10591da177e4SLinus Torvalds STp->drv_write_prot = 0; 10601da177e4SLinus Torvalds } else { 10611da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 10621da177e4SLinus Torvalds "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n", 10631da177e4SLinus Torvalds name, 10641da177e4SLinus Torvalds (STp->buffer)->b_data[0], (STp->buffer)->b_data[1], 10651da177e4SLinus Torvalds (STp->buffer)->b_data[2], (STp->buffer)->b_data[3])); 10661da177e4SLinus Torvalds 10671da177e4SLinus Torvalds if ((STp->buffer)->b_data[3] >= 8) { 10681da177e4SLinus Torvalds STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7; 10691da177e4SLinus Torvalds STp->density = (STp->buffer)->b_data[4]; 10701da177e4SLinus Torvalds STp->block_size = (STp->buffer)->b_data[9] * 65536 + 10711da177e4SLinus Torvalds (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11]; 10721da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 10731da177e4SLinus Torvalds "%s: Density %x, tape length: %x, drv buffer: %d\n", 10741da177e4SLinus Torvalds name, STp->density, (STp->buffer)->b_data[5] * 65536 + 10751da177e4SLinus Torvalds (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7], 10761da177e4SLinus Torvalds STp->drv_buffer)); 10771da177e4SLinus Torvalds } 10781da177e4SLinus Torvalds STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0; 10791da177e4SLinus Torvalds } 10808b05b773SMike Christie st_release_request(SRpnt); 10811da177e4SLinus Torvalds SRpnt = NULL; 10821da177e4SLinus Torvalds STp->inited = 1; 10831da177e4SLinus Torvalds 10841da177e4SLinus Torvalds if (STp->block_size > 0) 10851da177e4SLinus Torvalds (STp->buffer)->buffer_blocks = 10861da177e4SLinus Torvalds (STp->buffer)->buffer_size / STp->block_size; 10871da177e4SLinus Torvalds else 10881da177e4SLinus Torvalds (STp->buffer)->buffer_blocks = 1; 10891da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0; 10901da177e4SLinus Torvalds 10911da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 10921da177e4SLinus Torvalds "%s: Block size: %d, buffer size: %d (%d blocks).\n", name, 10931da177e4SLinus Torvalds STp->block_size, (STp->buffer)->buffer_size, 10941da177e4SLinus Torvalds (STp->buffer)->buffer_blocks)); 10951da177e4SLinus Torvalds 10961da177e4SLinus Torvalds if (STp->drv_write_prot) { 10971da177e4SLinus Torvalds STp->write_prot = 1; 10981da177e4SLinus Torvalds 10991da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name)); 11001da177e4SLinus Torvalds 11011da177e4SLinus Torvalds if (do_wait && 11021da177e4SLinus Torvalds ((st_flags & O_ACCMODE) == O_WRONLY || 11031da177e4SLinus Torvalds (st_flags & O_ACCMODE) == O_RDWR)) { 11041da177e4SLinus Torvalds retval = (-EROFS); 11051da177e4SLinus Torvalds goto err_out; 11061da177e4SLinus Torvalds } 11071da177e4SLinus Torvalds } 11081da177e4SLinus Torvalds 11091da177e4SLinus Torvalds if (STp->can_partitions && STp->nbr_partitions < 1) { 11101da177e4SLinus Torvalds /* This code is reached when the device is opened for the first time 11111da177e4SLinus Torvalds after the driver has been initialized with tape in the drive and the 11121da177e4SLinus Torvalds partition support has been enabled. */ 11131da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 11141da177e4SLinus Torvalds "%s: Updating partition number in status.\n", name)); 11151da177e4SLinus Torvalds if ((STp->partition = find_partition(STp)) < 0) { 11161da177e4SLinus Torvalds retval = STp->partition; 11171da177e4SLinus Torvalds goto err_out; 11181da177e4SLinus Torvalds } 11191da177e4SLinus Torvalds STp->new_partition = STp->partition; 11201da177e4SLinus Torvalds STp->nbr_partitions = 1; /* This guess will be updated when necessary */ 11211da177e4SLinus Torvalds } 11221da177e4SLinus Torvalds 11231da177e4SLinus Torvalds if (new_session) { /* Change the drive parameters for the new mode */ 11241da177e4SLinus Torvalds STp->density_changed = STp->blksize_changed = 0; 11251da177e4SLinus Torvalds STp->compression_changed = 0; 11261da177e4SLinus Torvalds if (!(STm->defaults_for_writes) && 11271da177e4SLinus Torvalds (retval = set_mode_densblk(STp, STm)) < 0) 11281da177e4SLinus Torvalds goto err_out; 11291da177e4SLinus Torvalds 11301da177e4SLinus Torvalds if (STp->default_drvbuffer != 0xff) { 11311da177e4SLinus Torvalds if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer)) 11321da177e4SLinus Torvalds printk(KERN_WARNING 11331da177e4SLinus Torvalds "%s: Can't set default drive buffering to %d.\n", 11341da177e4SLinus Torvalds name, STp->default_drvbuffer); 11351da177e4SLinus Torvalds } 11361da177e4SLinus Torvalds } 11371da177e4SLinus Torvalds 11381da177e4SLinus Torvalds return CHKRES_READY; 11391da177e4SLinus Torvalds 11401da177e4SLinus Torvalds err_out: 11411da177e4SLinus Torvalds return retval; 11421da177e4SLinus Torvalds } 11431da177e4SLinus Torvalds 11441da177e4SLinus Torvalds 1145b3369c68SJonathan Corbet /* Open the device. Needs to take the BKL only because of incrementing the SCSI host 11461da177e4SLinus Torvalds module count. */ 11471da177e4SLinus Torvalds static int st_open(struct inode *inode, struct file *filp) 11481da177e4SLinus Torvalds { 11491da177e4SLinus Torvalds int i, retval = (-EIO); 11501da177e4SLinus Torvalds struct scsi_tape *STp; 11511da177e4SLinus Torvalds struct st_partstat *STps; 11521da177e4SLinus Torvalds int dev = TAPE_NR(inode); 11531da177e4SLinus Torvalds char *name; 11541da177e4SLinus Torvalds 1155b3369c68SJonathan Corbet lock_kernel(); 11561da177e4SLinus Torvalds /* 11571da177e4SLinus Torvalds * We really want to do nonseekable_open(inode, filp); here, but some 11581da177e4SLinus Torvalds * versions of tar incorrectly call lseek on tapes and bail out if that 11591da177e4SLinus Torvalds * fails. So we disallow pread() and pwrite(), but permit lseeks. 11601da177e4SLinus Torvalds */ 11611da177e4SLinus Torvalds filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE); 11621da177e4SLinus Torvalds 1163b3369c68SJonathan Corbet if (!(STp = scsi_tape_get(dev))) { 1164b3369c68SJonathan Corbet unlock_kernel(); 1165f03a5670SKai Makisara return -ENXIO; 1166b3369c68SJonathan Corbet } 1167f03a5670SKai Makisara 11681da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 11691da177e4SLinus Torvalds filp->private_data = STp; 11701da177e4SLinus Torvalds name = tape_name(STp); 11711da177e4SLinus Torvalds 11721da177e4SLinus Torvalds if (STp->in_use) { 11731da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 1174f03a5670SKai Makisara scsi_tape_put(STp); 1175b3369c68SJonathan Corbet unlock_kernel(); 11761da177e4SLinus Torvalds DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); ) 11771da177e4SLinus Torvalds return (-EBUSY); 11781da177e4SLinus Torvalds } 11791da177e4SLinus Torvalds 11801da177e4SLinus Torvalds STp->in_use = 1; 11811da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 11821da177e4SLinus Torvalds STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0; 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds if (!scsi_block_when_processing_errors(STp->device)) { 11851da177e4SLinus Torvalds retval = (-ENXIO); 11861da177e4SLinus Torvalds goto err_out; 11871da177e4SLinus Torvalds } 11881da177e4SLinus Torvalds 11891da177e4SLinus Torvalds /* See that we have at least a one page buffer available */ 11901da177e4SLinus Torvalds if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) { 11911da177e4SLinus Torvalds printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n", 11921da177e4SLinus Torvalds name); 11931da177e4SLinus Torvalds retval = (-EOVERFLOW); 11941da177e4SLinus Torvalds goto err_out; 11951da177e4SLinus Torvalds } 11961da177e4SLinus Torvalds 119740f6b36cSKai Makisara (STp->buffer)->cleared = 0; 11981da177e4SLinus Torvalds (STp->buffer)->writing = 0; 11991da177e4SLinus Torvalds (STp->buffer)->syscall_result = 0; 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY); 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds STp->dirty = 0; 12041da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 12051da177e4SLinus Torvalds STps = &(STp->ps[i]); 12061da177e4SLinus Torvalds STps->rw = ST_IDLE; 12071da177e4SLinus Torvalds } 12089abe16c6SKai Makisara STp->try_dio_now = STp->try_dio; 12091da177e4SLinus Torvalds STp->recover_count = 0; 12101da177e4SLinus Torvalds DEB( STp->nbr_waits = STp->nbr_finished = 0; 1211deee13dfSKai Makisara STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; ) 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds retval = check_tape(STp, filp); 12141da177e4SLinus Torvalds if (retval < 0) 12151da177e4SLinus Torvalds goto err_out; 12161da177e4SLinus Torvalds if ((filp->f_flags & O_NONBLOCK) == 0 && 12171da177e4SLinus Torvalds retval != CHKRES_READY) { 1218413f7327SKai Makisara if (STp->ready == NO_TAPE) 1219413f7327SKai Makisara retval = (-ENOMEDIUM); 1220413f7327SKai Makisara else 12211da177e4SLinus Torvalds retval = (-EIO); 12221da177e4SLinus Torvalds goto err_out; 12231da177e4SLinus Torvalds } 1224b3369c68SJonathan Corbet unlock_kernel(); 12251da177e4SLinus Torvalds return 0; 12261da177e4SLinus Torvalds 12271da177e4SLinus Torvalds err_out: 12281da177e4SLinus Torvalds normalize_buffer(STp->buffer); 12291da177e4SLinus Torvalds STp->in_use = 0; 1230f03a5670SKai Makisara scsi_tape_put(STp); 1231b3369c68SJonathan Corbet unlock_kernel(); 12321da177e4SLinus Torvalds return retval; 12331da177e4SLinus Torvalds 12341da177e4SLinus Torvalds } 12351da177e4SLinus Torvalds 12361da177e4SLinus Torvalds 12371da177e4SLinus Torvalds /* Flush the tape buffer before close */ 123875e1fcc0SMiklos Szeredi static int st_flush(struct file *filp, fl_owner_t id) 12391da177e4SLinus Torvalds { 12401da177e4SLinus Torvalds int result = 0, result2; 12411da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 12428b05b773SMike Christie struct st_request *SRpnt; 12431da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 12441da177e4SLinus Torvalds struct st_modedef *STm = &(STp->modes[STp->current_mode]); 12451da177e4SLinus Torvalds struct st_partstat *STps = &(STp->ps[STp->partition]); 12461da177e4SLinus Torvalds char *name = tape_name(STp); 12471da177e4SLinus Torvalds 12481da177e4SLinus Torvalds if (file_count(filp) > 1) 12491da177e4SLinus Torvalds return 0; 12501da177e4SLinus Torvalds 12511da177e4SLinus Torvalds if (STps->rw == ST_WRITING && !STp->pos_unknown) { 12528ef8d594SAdrian Bunk result = st_flush_write_buffer(STp); 12531da177e4SLinus Torvalds if (result != 0 && result != (-ENOSPC)) 12541da177e4SLinus Torvalds goto out; 12551da177e4SLinus Torvalds } 12561da177e4SLinus Torvalds 12571da177e4SLinus Torvalds if (STp->can_partitions && 12581da177e4SLinus Torvalds (result2 = switch_partition(STp)) < 0) { 12591da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 12601da177e4SLinus Torvalds "%s: switch_partition at close failed.\n", name)); 12611da177e4SLinus Torvalds if (result == 0) 12621da177e4SLinus Torvalds result = result2; 12631da177e4SLinus Torvalds goto out; 12641da177e4SLinus Torvalds } 12651da177e4SLinus Torvalds 12661da177e4SLinus Torvalds DEBC( if (STp->nbr_requests) 1267deee13dfSKai Makisara printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n", 1268deee13dfSKai Makisara name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages)); 12691da177e4SLinus Torvalds 12701da177e4SLinus Torvalds if (STps->rw == ST_WRITING && !STp->pos_unknown) { 12711da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 12721da177e4SLinus Torvalds 12731da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n", 12741da177e4SLinus Torvalds name, STp->nbr_waits, STp->nbr_finished); 12751da177e4SLinus Torvalds ) 12761da177e4SLinus Torvalds 12771da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 12781da177e4SLinus Torvalds cmd[0] = WRITE_FILEMARKS; 12791da177e4SLinus Torvalds cmd[4] = 1 + STp->two_fm; 12801da177e4SLinus Torvalds 12811da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE, 1282a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 1283a02488edSJames Bottomley MAX_WRITE_RETRIES, 1); 12841da177e4SLinus Torvalds if (!SRpnt) { 12851da177e4SLinus Torvalds result = (STp->buffer)->syscall_result; 12861da177e4SLinus Torvalds goto out; 12871da177e4SLinus Torvalds } 12881da177e4SLinus Torvalds 12891da177e4SLinus Torvalds if (STp->buffer->syscall_result == 0 || 12901da177e4SLinus Torvalds (cmdstatp->have_sense && !cmdstatp->deferred && 12911da177e4SLinus Torvalds (cmdstatp->flags & SENSE_EOM) && 12921da177e4SLinus Torvalds (cmdstatp->sense_hdr.sense_key == NO_SENSE || 12931da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) && 12941da177e4SLinus Torvalds (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) { 12951da177e4SLinus Torvalds /* Write successful at EOM */ 12968b05b773SMike Christie st_release_request(SRpnt); 12971da177e4SLinus Torvalds SRpnt = NULL; 12981da177e4SLinus Torvalds if (STps->drv_file >= 0) 12991da177e4SLinus Torvalds STps->drv_file++; 13001da177e4SLinus Torvalds STps->drv_block = 0; 13011da177e4SLinus Torvalds if (STp->two_fm) 13021da177e4SLinus Torvalds cross_eof(STp, 0); 13031da177e4SLinus Torvalds STps->eof = ST_FM; 13041da177e4SLinus Torvalds } 13051da177e4SLinus Torvalds else { /* Write error */ 13068b05b773SMike Christie st_release_request(SRpnt); 13071da177e4SLinus Torvalds SRpnt = NULL; 13081da177e4SLinus Torvalds printk(KERN_ERR "%s: Error on write filemark.\n", name); 13091da177e4SLinus Torvalds if (result == 0) 13101da177e4SLinus Torvalds result = (-EIO); 13111da177e4SLinus Torvalds } 13121da177e4SLinus Torvalds 13131da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n", 13141da177e4SLinus Torvalds name, cmd[4])); 13151da177e4SLinus Torvalds } else if (!STp->rew_at_close) { 13161da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 13171da177e4SLinus Torvalds if (!STm->sysv || STps->rw != ST_READING) { 13181da177e4SLinus Torvalds if (STp->can_bsr) 13191da177e4SLinus Torvalds result = flush_buffer(STp, 0); 13201da177e4SLinus Torvalds else if (STps->eof == ST_FM_HIT) { 13211da177e4SLinus Torvalds result = cross_eof(STp, 0); 13221da177e4SLinus Torvalds if (result) { 13231da177e4SLinus Torvalds if (STps->drv_file >= 0) 13241da177e4SLinus Torvalds STps->drv_file++; 13251da177e4SLinus Torvalds STps->drv_block = 0; 13261da177e4SLinus Torvalds STps->eof = ST_FM; 13271da177e4SLinus Torvalds } else 13281da177e4SLinus Torvalds STps->eof = ST_NOEOF; 13291da177e4SLinus Torvalds } 13301da177e4SLinus Torvalds } else if ((STps->eof == ST_NOEOF && 13311da177e4SLinus Torvalds !(result = cross_eof(STp, 1))) || 13321da177e4SLinus Torvalds STps->eof == ST_FM_HIT) { 13331da177e4SLinus Torvalds if (STps->drv_file >= 0) 13341da177e4SLinus Torvalds STps->drv_file++; 13351da177e4SLinus Torvalds STps->drv_block = 0; 13361da177e4SLinus Torvalds STps->eof = ST_FM; 13371da177e4SLinus Torvalds } 13381da177e4SLinus Torvalds } 13391da177e4SLinus Torvalds 13401da177e4SLinus Torvalds out: 13411da177e4SLinus Torvalds if (STp->rew_at_close) { 13421da177e4SLinus Torvalds result2 = st_int_ioctl(STp, MTREW, 1); 13431da177e4SLinus Torvalds if (result == 0) 13441da177e4SLinus Torvalds result = result2; 13451da177e4SLinus Torvalds } 13461da177e4SLinus Torvalds return result; 13471da177e4SLinus Torvalds } 13481da177e4SLinus Torvalds 13491da177e4SLinus Torvalds 13501da177e4SLinus Torvalds /* Close the device and release it. BKL is not needed: this is the only thread 13511da177e4SLinus Torvalds accessing this tape. */ 13521da177e4SLinus Torvalds static int st_release(struct inode *inode, struct file *filp) 13531da177e4SLinus Torvalds { 13541da177e4SLinus Torvalds int result = 0; 13551da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 13561da177e4SLinus Torvalds 13571da177e4SLinus Torvalds if (STp->door_locked == ST_LOCKED_AUTO) 13581da177e4SLinus Torvalds do_door_lock(STp, 0); 13591da177e4SLinus Torvalds 13601da177e4SLinus Torvalds normalize_buffer(STp->buffer); 13611da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 13621da177e4SLinus Torvalds STp->in_use = 0; 13631da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 1364f03a5670SKai Makisara scsi_tape_put(STp); 13651da177e4SLinus Torvalds 13661da177e4SLinus Torvalds return result; 13671da177e4SLinus Torvalds } 13681da177e4SLinus Torvalds 13691da177e4SLinus Torvalds /* The checks common to both reading and writing */ 13701da177e4SLinus Torvalds static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count) 13711da177e4SLinus Torvalds { 13721da177e4SLinus Torvalds ssize_t retval = 0; 13731da177e4SLinus Torvalds 13741da177e4SLinus Torvalds /* 13751da177e4SLinus Torvalds * If we are in the middle of error recovery, don't let anyone 13761da177e4SLinus Torvalds * else try and use this device. Also, if error recovery fails, it 13771da177e4SLinus Torvalds * may try and take the device offline, in which case all further 13781da177e4SLinus Torvalds * access to the device is prohibited. 13791da177e4SLinus Torvalds */ 13801da177e4SLinus Torvalds if (!scsi_block_when_processing_errors(STp->device)) { 13811da177e4SLinus Torvalds retval = (-ENXIO); 13821da177e4SLinus Torvalds goto out; 13831da177e4SLinus Torvalds } 13841da177e4SLinus Torvalds 13851da177e4SLinus Torvalds if (STp->ready != ST_READY) { 13861da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 13871da177e4SLinus Torvalds retval = (-ENOMEDIUM); 13881da177e4SLinus Torvalds else 13891da177e4SLinus Torvalds retval = (-EIO); 13901da177e4SLinus Torvalds goto out; 13911da177e4SLinus Torvalds } 13921da177e4SLinus Torvalds 13931da177e4SLinus Torvalds if (! STp->modes[STp->current_mode].defined) { 13941da177e4SLinus Torvalds retval = (-ENXIO); 13951da177e4SLinus Torvalds goto out; 13961da177e4SLinus Torvalds } 13971da177e4SLinus Torvalds 13981da177e4SLinus Torvalds 13991da177e4SLinus Torvalds /* 14001da177e4SLinus Torvalds * If there was a bus reset, block further access 14011da177e4SLinus Torvalds * to this device. 14021da177e4SLinus Torvalds */ 14031da177e4SLinus Torvalds if (STp->pos_unknown) { 14041da177e4SLinus Torvalds retval = (-EIO); 14051da177e4SLinus Torvalds goto out; 14061da177e4SLinus Torvalds } 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds if (count == 0) 14091da177e4SLinus Torvalds goto out; 14101da177e4SLinus Torvalds 14111da177e4SLinus Torvalds DEB( 14121da177e4SLinus Torvalds if (!STp->in_use) { 14131da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp)); 14141da177e4SLinus Torvalds retval = (-EIO); 14151da177e4SLinus Torvalds goto out; 14161da177e4SLinus Torvalds } ) /* end DEB */ 14171da177e4SLinus Torvalds 14181da177e4SLinus Torvalds if (STp->can_partitions && 14191da177e4SLinus Torvalds (retval = switch_partition(STp)) < 0) 14201da177e4SLinus Torvalds goto out; 14211da177e4SLinus Torvalds 14221da177e4SLinus Torvalds if (STp->block_size == 0 && STp->max_block > 0 && 14231da177e4SLinus Torvalds (count < STp->min_block || count > STp->max_block)) { 14241da177e4SLinus Torvalds retval = (-EINVAL); 14251da177e4SLinus Torvalds goto out; 14261da177e4SLinus Torvalds } 14271da177e4SLinus Torvalds 14281da177e4SLinus Torvalds if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && 14291da177e4SLinus Torvalds !do_door_lock(STp, 1)) 14301da177e4SLinus Torvalds STp->door_locked = ST_LOCKED_AUTO; 14311da177e4SLinus Torvalds 14321da177e4SLinus Torvalds out: 14331da177e4SLinus Torvalds return retval; 14341da177e4SLinus Torvalds } 14351da177e4SLinus Torvalds 14361da177e4SLinus Torvalds 14371da177e4SLinus Torvalds static int setup_buffering(struct scsi_tape *STp, const char __user *buf, 14381da177e4SLinus Torvalds size_t count, int is_read) 14391da177e4SLinus Torvalds { 14401da177e4SLinus Torvalds int i, bufsize, retval = 0; 14411da177e4SLinus Torvalds struct st_buffer *STbp = STp->buffer; 14421da177e4SLinus Torvalds 14431da177e4SLinus Torvalds if (is_read) 14449abe16c6SKai Makisara i = STp->try_dio_now && try_rdio; 14451da177e4SLinus Torvalds else 14469abe16c6SKai Makisara i = STp->try_dio_now && try_wdio; 14478b05b773SMike Christie 14481da177e4SLinus Torvalds if (i && ((unsigned long)buf & queue_dma_alignment( 14491da177e4SLinus Torvalds STp->device->request_queue)) == 0) { 14508b05b773SMike Christie i = sgl_map_user_pages(&(STbp->sg[0]), STbp->use_sg, 14518b05b773SMike Christie (unsigned long)buf, count, (is_read ? READ : WRITE)); 14521da177e4SLinus Torvalds if (i > 0) { 14531da177e4SLinus Torvalds STbp->do_dio = i; 14541da177e4SLinus Torvalds STbp->buffer_bytes = 0; /* can be used as transfer counter */ 14551da177e4SLinus Torvalds } 14561da177e4SLinus Torvalds else 14571da177e4SLinus Torvalds STbp->do_dio = 0; /* fall back to buffering with any error */ 14581da177e4SLinus Torvalds STbp->sg_segs = STbp->do_dio; 14591da177e4SLinus Torvalds STbp->frp_sg_current = 0; 14601da177e4SLinus Torvalds DEB( 14611da177e4SLinus Torvalds if (STbp->do_dio) { 14621da177e4SLinus Torvalds STp->nbr_dio++; 14631da177e4SLinus Torvalds STp->nbr_pages += STbp->do_dio; 14641da177e4SLinus Torvalds } 14651da177e4SLinus Torvalds ) 14661da177e4SLinus Torvalds } else 14671da177e4SLinus Torvalds STbp->do_dio = 0; 14681da177e4SLinus Torvalds DEB( STp->nbr_requests++; ) 14691da177e4SLinus Torvalds 14701da177e4SLinus Torvalds if (!STbp->do_dio) { 14711da177e4SLinus Torvalds if (STp->block_size) 14721da177e4SLinus Torvalds bufsize = STp->block_size > st_fixed_buffer_size ? 14731da177e4SLinus Torvalds STp->block_size : st_fixed_buffer_size; 147440f6b36cSKai Makisara else { 14751da177e4SLinus Torvalds bufsize = count; 147640f6b36cSKai Makisara /* Make sure that data from previous user is not leaked even if 147740f6b36cSKai Makisara HBA does not return correct residual */ 147840f6b36cSKai Makisara if (is_read && STp->sili && !STbp->cleared) 147940f6b36cSKai Makisara clear_buffer(STbp); 148040f6b36cSKai Makisara } 148140f6b36cSKai Makisara 14821da177e4SLinus Torvalds if (bufsize > STbp->buffer_size && 14831da177e4SLinus Torvalds !enlarge_buffer(STbp, bufsize, STp->restr_dma)) { 14841da177e4SLinus Torvalds printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n", 14851da177e4SLinus Torvalds tape_name(STp), bufsize); 14861da177e4SLinus Torvalds retval = (-EOVERFLOW); 14871da177e4SLinus Torvalds goto out; 14881da177e4SLinus Torvalds } 14891da177e4SLinus Torvalds if (STp->block_size) 14901da177e4SLinus Torvalds STbp->buffer_blocks = bufsize / STp->block_size; 14911da177e4SLinus Torvalds } 14921da177e4SLinus Torvalds 14931da177e4SLinus Torvalds out: 14941da177e4SLinus Torvalds return retval; 14951da177e4SLinus Torvalds } 14961da177e4SLinus Torvalds 14971da177e4SLinus Torvalds 14981da177e4SLinus Torvalds /* Can be called more than once after each setup_buffer() */ 1499787926b1SKai Makisara static void release_buffering(struct scsi_tape *STp, int is_read) 15001da177e4SLinus Torvalds { 15011da177e4SLinus Torvalds struct st_buffer *STbp; 15021da177e4SLinus Torvalds 15031da177e4SLinus Torvalds STbp = STp->buffer; 15041da177e4SLinus Torvalds if (STbp->do_dio) { 1505787926b1SKai Makisara sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, is_read); 15061da177e4SLinus Torvalds STbp->do_dio = 0; 1507787926b1SKai Makisara STbp->sg_segs = 0; 15081da177e4SLinus Torvalds } 15091da177e4SLinus Torvalds } 15101da177e4SLinus Torvalds 15111da177e4SLinus Torvalds 15121da177e4SLinus Torvalds /* Write command */ 15131da177e4SLinus Torvalds static ssize_t 15141da177e4SLinus Torvalds st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) 15151da177e4SLinus Torvalds { 15161da177e4SLinus Torvalds ssize_t total; 15171da177e4SLinus Torvalds ssize_t i, do_count, blks, transfer; 15181da177e4SLinus Torvalds ssize_t retval; 15191da177e4SLinus Torvalds int undone, retry_eot = 0, scode; 15201da177e4SLinus Torvalds int async_write; 15211da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 15221da177e4SLinus Torvalds const char __user *b_point; 15238b05b773SMike Christie struct st_request *SRpnt = NULL; 15241da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 15251da177e4SLinus Torvalds struct st_modedef *STm; 15261da177e4SLinus Torvalds struct st_partstat *STps; 15271da177e4SLinus Torvalds struct st_buffer *STbp; 15281da177e4SLinus Torvalds char *name = tape_name(STp); 15291da177e4SLinus Torvalds 153028f85009SMatthias Kaehlcke if (mutex_lock_interruptible(&STp->lock)) 15311da177e4SLinus Torvalds return -ERESTARTSYS; 15321da177e4SLinus Torvalds 15331da177e4SLinus Torvalds retval = rw_checks(STp, filp, count); 15341da177e4SLinus Torvalds if (retval || count == 0) 15351da177e4SLinus Torvalds goto out; 15361da177e4SLinus Torvalds 15371da177e4SLinus Torvalds /* Write must be integral number of blocks */ 15381da177e4SLinus Torvalds if (STp->block_size != 0 && (count % STp->block_size) != 0) { 15391da177e4SLinus Torvalds printk(KERN_WARNING "%s: Write not multiple of tape block size.\n", 15401da177e4SLinus Torvalds name); 15411da177e4SLinus Torvalds retval = (-EINVAL); 15421da177e4SLinus Torvalds goto out; 15431da177e4SLinus Torvalds } 15441da177e4SLinus Torvalds 15451da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 15461da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 15471da177e4SLinus Torvalds 15481da177e4SLinus Torvalds if (STp->write_prot) { 15491da177e4SLinus Torvalds retval = (-EACCES); 15501da177e4SLinus Torvalds goto out; 15511da177e4SLinus Torvalds } 15521da177e4SLinus Torvalds 15531da177e4SLinus Torvalds 15541da177e4SLinus Torvalds if (STps->rw == ST_READING) { 15551da177e4SLinus Torvalds retval = flush_buffer(STp, 0); 15561da177e4SLinus Torvalds if (retval) 15571da177e4SLinus Torvalds goto out; 15581da177e4SLinus Torvalds STps->rw = ST_WRITING; 15591da177e4SLinus Torvalds } else if (STps->rw != ST_WRITING && 15601da177e4SLinus Torvalds STps->drv_file == 0 && STps->drv_block == 0) { 15611da177e4SLinus Torvalds if ((retval = set_mode_densblk(STp, STm)) < 0) 15621da177e4SLinus Torvalds goto out; 15631da177e4SLinus Torvalds if (STm->default_compression != ST_DONT_TOUCH && 15641da177e4SLinus Torvalds !(STp->compression_changed)) { 15651da177e4SLinus Torvalds if (st_compression(STp, (STm->default_compression == ST_YES))) { 15661da177e4SLinus Torvalds printk(KERN_WARNING "%s: Can't set default compression.\n", 15671da177e4SLinus Torvalds name); 15681da177e4SLinus Torvalds if (modes_defined) { 15691da177e4SLinus Torvalds retval = (-EINVAL); 15701da177e4SLinus Torvalds goto out; 15711da177e4SLinus Torvalds } 15721da177e4SLinus Torvalds } 15731da177e4SLinus Torvalds } 15741da177e4SLinus Torvalds } 15751da177e4SLinus Torvalds 15761da177e4SLinus Torvalds STbp = STp->buffer; 15771da177e4SLinus Torvalds i = write_behind_check(STp); 15781da177e4SLinus Torvalds if (i) { 15791da177e4SLinus Torvalds if (i == -ENOSPC) 15801da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 15811da177e4SLinus Torvalds else 15821da177e4SLinus Torvalds STps->eof = ST_EOM_ERROR; 15831da177e4SLinus Torvalds } 15841da177e4SLinus Torvalds 15851da177e4SLinus Torvalds if (STps->eof == ST_EOM_OK) { 15861da177e4SLinus Torvalds STps->eof = ST_EOD_1; /* allow next write */ 15871da177e4SLinus Torvalds retval = (-ENOSPC); 15881da177e4SLinus Torvalds goto out; 15891da177e4SLinus Torvalds } 15901da177e4SLinus Torvalds else if (STps->eof == ST_EOM_ERROR) { 15911da177e4SLinus Torvalds retval = (-EIO); 15921da177e4SLinus Torvalds goto out; 15931da177e4SLinus Torvalds } 15941da177e4SLinus Torvalds 15951da177e4SLinus Torvalds /* Check the buffer readability in cases where copy_user might catch 15961da177e4SLinus Torvalds the problems after some tape movement. */ 15971da177e4SLinus Torvalds if (STp->block_size != 0 && 15981da177e4SLinus Torvalds !STbp->do_dio && 15991da177e4SLinus Torvalds (copy_from_user(&i, buf, 1) != 0 || 16001da177e4SLinus Torvalds copy_from_user(&i, buf + count - 1, 1) != 0)) { 16011da177e4SLinus Torvalds retval = (-EFAULT); 16021da177e4SLinus Torvalds goto out; 16031da177e4SLinus Torvalds } 16041da177e4SLinus Torvalds 16051da177e4SLinus Torvalds retval = setup_buffering(STp, buf, count, 0); 16061da177e4SLinus Torvalds if (retval) 16071da177e4SLinus Torvalds goto out; 16081da177e4SLinus Torvalds 16091da177e4SLinus Torvalds total = count; 16101da177e4SLinus Torvalds 16111da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 16121da177e4SLinus Torvalds cmd[0] = WRITE_6; 16131da177e4SLinus Torvalds cmd[1] = (STp->block_size != 0); 16141da177e4SLinus Torvalds 16151da177e4SLinus Torvalds STps->rw = ST_WRITING; 16161da177e4SLinus Torvalds 16171da177e4SLinus Torvalds b_point = buf; 16181da177e4SLinus Torvalds while (count > 0 && !retry_eot) { 16191da177e4SLinus Torvalds 16201da177e4SLinus Torvalds if (STbp->do_dio) { 16211da177e4SLinus Torvalds do_count = count; 16221da177e4SLinus Torvalds } 16231da177e4SLinus Torvalds else { 16241da177e4SLinus Torvalds if (STp->block_size == 0) 16251da177e4SLinus Torvalds do_count = count; 16261da177e4SLinus Torvalds else { 16271da177e4SLinus Torvalds do_count = STbp->buffer_blocks * STp->block_size - 16281da177e4SLinus Torvalds STbp->buffer_bytes; 16291da177e4SLinus Torvalds if (do_count > count) 16301da177e4SLinus Torvalds do_count = count; 16311da177e4SLinus Torvalds } 16321da177e4SLinus Torvalds 16331da177e4SLinus Torvalds i = append_to_buffer(b_point, STbp, do_count); 16341da177e4SLinus Torvalds if (i) { 16351da177e4SLinus Torvalds retval = i; 16361da177e4SLinus Torvalds goto out; 16371da177e4SLinus Torvalds } 16381da177e4SLinus Torvalds } 16391da177e4SLinus Torvalds count -= do_count; 16401da177e4SLinus Torvalds b_point += do_count; 16411da177e4SLinus Torvalds 16421da177e4SLinus Torvalds async_write = STp->block_size == 0 && !STbp->do_dio && 16431da177e4SLinus Torvalds STm->do_async_writes && STps->eof < ST_EOM_OK; 16441da177e4SLinus Torvalds 16451da177e4SLinus Torvalds if (STp->block_size != 0 && STm->do_buffer_writes && 16469abe16c6SKai Makisara !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK && 16471da177e4SLinus Torvalds STbp->buffer_bytes < STbp->buffer_size) { 16481da177e4SLinus Torvalds STp->dirty = 1; 16491da177e4SLinus Torvalds /* Don't write a buffer that is not full enough. */ 16501da177e4SLinus Torvalds if (!async_write && count == 0) 16511da177e4SLinus Torvalds break; 16521da177e4SLinus Torvalds } 16531da177e4SLinus Torvalds 16541da177e4SLinus Torvalds retry_write: 16551da177e4SLinus Torvalds if (STp->block_size == 0) 16561da177e4SLinus Torvalds blks = transfer = do_count; 16571da177e4SLinus Torvalds else { 16581da177e4SLinus Torvalds if (!STbp->do_dio) 16591da177e4SLinus Torvalds blks = STbp->buffer_bytes; 16601da177e4SLinus Torvalds else 16611da177e4SLinus Torvalds blks = do_count; 16621da177e4SLinus Torvalds blks /= STp->block_size; 16631da177e4SLinus Torvalds transfer = blks * STp->block_size; 16641da177e4SLinus Torvalds } 16651da177e4SLinus Torvalds cmd[2] = blks >> 16; 16661da177e4SLinus Torvalds cmd[3] = blks >> 8; 16671da177e4SLinus Torvalds cmd[4] = blks; 16681da177e4SLinus Torvalds 16691da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE, 1670a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 1671a02488edSJames Bottomley MAX_WRITE_RETRIES, !async_write); 16721da177e4SLinus Torvalds if (!SRpnt) { 16731da177e4SLinus Torvalds retval = STbp->syscall_result; 16741da177e4SLinus Torvalds goto out; 16751da177e4SLinus Torvalds } 16768b05b773SMike Christie if (async_write && !STbp->syscall_result) { 16771da177e4SLinus Torvalds STbp->writing = transfer; 16781da177e4SLinus Torvalds STp->dirty = !(STbp->writing == 16791da177e4SLinus Torvalds STbp->buffer_bytes); 16801da177e4SLinus Torvalds SRpnt = NULL; /* Prevent releasing this request! */ 16811da177e4SLinus Torvalds DEB( STp->write_pending = 1; ) 16821da177e4SLinus Torvalds break; 16831da177e4SLinus Torvalds } 16841da177e4SLinus Torvalds 16851da177e4SLinus Torvalds if (STbp->syscall_result != 0) { 16861da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 16871da177e4SLinus Torvalds 16881da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name)); 16891da177e4SLinus Torvalds if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) { 16901da177e4SLinus Torvalds scode = cmdstatp->sense_hdr.sense_key; 16911da177e4SLinus Torvalds if (cmdstatp->remainder_valid) 16921da177e4SLinus Torvalds undone = (int)cmdstatp->uremainder64; 16931da177e4SLinus Torvalds else if (STp->block_size == 0 && 16941da177e4SLinus Torvalds scode == VOLUME_OVERFLOW) 16951da177e4SLinus Torvalds undone = transfer; 16961da177e4SLinus Torvalds else 16971da177e4SLinus Torvalds undone = 0; 16981da177e4SLinus Torvalds if (STp->block_size != 0) 16991da177e4SLinus Torvalds undone *= STp->block_size; 17001da177e4SLinus Torvalds if (undone <= do_count) { 17011da177e4SLinus Torvalds /* Only data from this write is not written */ 17021da177e4SLinus Torvalds count += undone; 1703626dcb1eSKai Makisara b_point -= undone; 17041da177e4SLinus Torvalds do_count -= undone; 17051da177e4SLinus Torvalds if (STp->block_size) 17061da177e4SLinus Torvalds blks = (transfer - undone) / STp->block_size; 17071da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 17081da177e4SLinus Torvalds /* Continue in fixed block mode if all written 17091da177e4SLinus Torvalds in this request but still something left to write 17101da177e4SLinus Torvalds (retval left to zero) 17111da177e4SLinus Torvalds */ 17121da177e4SLinus Torvalds if (STp->block_size == 0 || 17131da177e4SLinus Torvalds undone > 0 || count == 0) 17141da177e4SLinus Torvalds retval = (-ENOSPC); /* EOM within current request */ 17151da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 17161da177e4SLinus Torvalds "%s: EOM with %d bytes unwritten.\n", 17171da177e4SLinus Torvalds name, (int)count)); 17181da177e4SLinus Torvalds } else { 17191da177e4SLinus Torvalds /* EOT within data buffered earlier (possible only 17201da177e4SLinus Torvalds in fixed block mode without direct i/o) */ 17211da177e4SLinus Torvalds if (!retry_eot && !cmdstatp->deferred && 17221da177e4SLinus Torvalds (scode == NO_SENSE || scode == RECOVERED_ERROR)) { 17231da177e4SLinus Torvalds move_buffer_data(STp->buffer, transfer - undone); 17241da177e4SLinus Torvalds retry_eot = 1; 17251da177e4SLinus Torvalds if (STps->drv_block >= 0) { 17261da177e4SLinus Torvalds STps->drv_block += (transfer - undone) / 17271da177e4SLinus Torvalds STp->block_size; 17281da177e4SLinus Torvalds } 17291da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 17301da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 17311da177e4SLinus Torvalds "%s: Retry write of %d bytes at EOM.\n", 17321da177e4SLinus Torvalds name, STp->buffer->buffer_bytes)); 17331da177e4SLinus Torvalds goto retry_write; 17341da177e4SLinus Torvalds } 17351da177e4SLinus Torvalds else { 17361da177e4SLinus Torvalds /* Either error within data buffered by driver or 17371da177e4SLinus Torvalds failed retry */ 17381da177e4SLinus Torvalds count -= do_count; 17391da177e4SLinus Torvalds blks = do_count = 0; 17401da177e4SLinus Torvalds STps->eof = ST_EOM_ERROR; 17411da177e4SLinus Torvalds STps->drv_block = (-1); /* Too cautious? */ 17421da177e4SLinus Torvalds retval = (-EIO); /* EOM for old data */ 17431da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 17441da177e4SLinus Torvalds "%s: EOM with lost data.\n", 17451da177e4SLinus Torvalds name)); 17461da177e4SLinus Torvalds } 17471da177e4SLinus Torvalds } 17481da177e4SLinus Torvalds } else { 17491da177e4SLinus Torvalds count += do_count; 17501da177e4SLinus Torvalds STps->drv_block = (-1); /* Too cautious? */ 17518b05b773SMike Christie retval = STbp->syscall_result; 17521da177e4SLinus Torvalds } 17531da177e4SLinus Torvalds 17541da177e4SLinus Torvalds } 17551da177e4SLinus Torvalds 17561da177e4SLinus Torvalds if (STps->drv_block >= 0) { 17571da177e4SLinus Torvalds if (STp->block_size == 0) 17581da177e4SLinus Torvalds STps->drv_block += (do_count > 0); 17591da177e4SLinus Torvalds else 17601da177e4SLinus Torvalds STps->drv_block += blks; 17611da177e4SLinus Torvalds } 17621da177e4SLinus Torvalds 17631da177e4SLinus Torvalds STbp->buffer_bytes = 0; 17641da177e4SLinus Torvalds STp->dirty = 0; 17651da177e4SLinus Torvalds 17661da177e4SLinus Torvalds if (retval || retry_eot) { 17671da177e4SLinus Torvalds if (count < total) 17681da177e4SLinus Torvalds retval = total - count; 17691da177e4SLinus Torvalds goto out; 17701da177e4SLinus Torvalds } 17711da177e4SLinus Torvalds } 17721da177e4SLinus Torvalds 17731da177e4SLinus Torvalds if (STps->eof == ST_EOD_1) 17741da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 17751da177e4SLinus Torvalds else if (STps->eof != ST_EOM_OK) 17761da177e4SLinus Torvalds STps->eof = ST_NOEOF; 17771da177e4SLinus Torvalds retval = total - count; 17781da177e4SLinus Torvalds 17791da177e4SLinus Torvalds out: 17801da177e4SLinus Torvalds if (SRpnt != NULL) 17818b05b773SMike Christie st_release_request(SRpnt); 1782787926b1SKai Makisara release_buffering(STp, 0); 178328f85009SMatthias Kaehlcke mutex_unlock(&STp->lock); 17841da177e4SLinus Torvalds 17851da177e4SLinus Torvalds return retval; 17861da177e4SLinus Torvalds } 17871da177e4SLinus Torvalds 17881da177e4SLinus Torvalds /* Read data from the tape. Returns zero in the normal case, one if the 17891da177e4SLinus Torvalds eof status has changed, and the negative error code in case of a 17901da177e4SLinus Torvalds fatal error. Otherwise updates the buffer and the eof state. 17911da177e4SLinus Torvalds 17921da177e4SLinus Torvalds Does release user buffer mapping if it is set. 17931da177e4SLinus Torvalds */ 17941da177e4SLinus Torvalds static long read_tape(struct scsi_tape *STp, long count, 17958b05b773SMike Christie struct st_request ** aSRpnt) 17961da177e4SLinus Torvalds { 17971da177e4SLinus Torvalds int transfer, blks, bytes; 17981da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 17998b05b773SMike Christie struct st_request *SRpnt; 18001da177e4SLinus Torvalds struct st_modedef *STm; 18011da177e4SLinus Torvalds struct st_partstat *STps; 18021da177e4SLinus Torvalds struct st_buffer *STbp; 18031da177e4SLinus Torvalds int retval = 0; 18041da177e4SLinus Torvalds char *name = tape_name(STp); 18051da177e4SLinus Torvalds 18061da177e4SLinus Torvalds if (count == 0) 18071da177e4SLinus Torvalds return 0; 18081da177e4SLinus Torvalds 18091da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 18101da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 18111da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) 18121da177e4SLinus Torvalds return 1; 18131da177e4SLinus Torvalds STbp = STp->buffer; 18141da177e4SLinus Torvalds 18151da177e4SLinus Torvalds if (STp->block_size == 0) 18161da177e4SLinus Torvalds blks = bytes = count; 18171da177e4SLinus Torvalds else { 18189abe16c6SKai Makisara if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) { 18191da177e4SLinus Torvalds blks = (STp->buffer)->buffer_blocks; 18201da177e4SLinus Torvalds bytes = blks * STp->block_size; 18211da177e4SLinus Torvalds } else { 18221da177e4SLinus Torvalds bytes = count; 18231da177e4SLinus Torvalds if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size) 18241da177e4SLinus Torvalds bytes = (STp->buffer)->buffer_size; 18251da177e4SLinus Torvalds blks = bytes / STp->block_size; 18261da177e4SLinus Torvalds bytes = blks * STp->block_size; 18271da177e4SLinus Torvalds } 18281da177e4SLinus Torvalds } 18291da177e4SLinus Torvalds 18301da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 18311da177e4SLinus Torvalds cmd[0] = READ_6; 18321da177e4SLinus Torvalds cmd[1] = (STp->block_size != 0); 183340f6b36cSKai Makisara if (!cmd[1] && STp->sili) 183440f6b36cSKai Makisara cmd[1] |= 2; 18351da177e4SLinus Torvalds cmd[2] = blks >> 16; 18361da177e4SLinus Torvalds cmd[3] = blks >> 8; 18371da177e4SLinus Torvalds cmd[4] = blks; 18381da177e4SLinus Torvalds 18391da177e4SLinus Torvalds SRpnt = *aSRpnt; 18401da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE, 1841a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 1842a02488edSJames Bottomley MAX_RETRIES, 1); 1843787926b1SKai Makisara release_buffering(STp, 1); 18441da177e4SLinus Torvalds *aSRpnt = SRpnt; 18451da177e4SLinus Torvalds if (!SRpnt) 18461da177e4SLinus Torvalds return STbp->syscall_result; 18471da177e4SLinus Torvalds 18481da177e4SLinus Torvalds STbp->read_pointer = 0; 18491da177e4SLinus Torvalds STps->at_sm = 0; 18501da177e4SLinus Torvalds 18511da177e4SLinus Torvalds /* Something to check */ 18521da177e4SLinus Torvalds if (STbp->syscall_result) { 18531da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 18541da177e4SLinus Torvalds 18551da177e4SLinus Torvalds retval = 1; 18561da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n", 18571da177e4SLinus Torvalds name, 18588b05b773SMike Christie SRpnt->sense[0], SRpnt->sense[1], 18598b05b773SMike Christie SRpnt->sense[2], SRpnt->sense[3], 18608b05b773SMike Christie SRpnt->sense[4], SRpnt->sense[5], 18618b05b773SMike Christie SRpnt->sense[6], SRpnt->sense[7])); 18621da177e4SLinus Torvalds if (cmdstatp->have_sense) { 18631da177e4SLinus Torvalds 18641da177e4SLinus Torvalds if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK) 18651da177e4SLinus Torvalds cmdstatp->flags &= 0xcf; /* No need for EOM in this case */ 18661da177e4SLinus Torvalds 18671da177e4SLinus Torvalds if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */ 18681da177e4SLinus Torvalds /* Compute the residual count */ 18691da177e4SLinus Torvalds if (cmdstatp->remainder_valid) 18701da177e4SLinus Torvalds transfer = (int)cmdstatp->uremainder64; 18711da177e4SLinus Torvalds else 18721da177e4SLinus Torvalds transfer = 0; 18731da177e4SLinus Torvalds if (STp->block_size == 0 && 18741da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR) 18751da177e4SLinus Torvalds transfer = bytes; 18761da177e4SLinus Torvalds 18771da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_ILI) { /* ILI */ 18781da177e4SLinus Torvalds if (STp->block_size == 0) { 18791da177e4SLinus Torvalds if (transfer <= 0) { 18801da177e4SLinus Torvalds if (transfer < 0) 18811da177e4SLinus Torvalds printk(KERN_NOTICE 18821da177e4SLinus Torvalds "%s: Failed to read %d byte block with %d byte transfer.\n", 18831da177e4SLinus Torvalds name, bytes - transfer, bytes); 18841da177e4SLinus Torvalds if (STps->drv_block >= 0) 18851da177e4SLinus Torvalds STps->drv_block += 1; 18861da177e4SLinus Torvalds STbp->buffer_bytes = 0; 18871da177e4SLinus Torvalds return (-ENOMEM); 18881da177e4SLinus Torvalds } 18891da177e4SLinus Torvalds STbp->buffer_bytes = bytes - transfer; 18901da177e4SLinus Torvalds } else { 18918b05b773SMike Christie st_release_request(SRpnt); 18921da177e4SLinus Torvalds SRpnt = *aSRpnt = NULL; 18931da177e4SLinus Torvalds if (transfer == blks) { /* We did not get anything, error */ 18941da177e4SLinus Torvalds printk(KERN_NOTICE "%s: Incorrect block size.\n", name); 18951da177e4SLinus Torvalds if (STps->drv_block >= 0) 18961da177e4SLinus Torvalds STps->drv_block += blks - transfer + 1; 18971da177e4SLinus Torvalds st_int_ioctl(STp, MTBSR, 1); 18981da177e4SLinus Torvalds return (-EIO); 18991da177e4SLinus Torvalds } 19001da177e4SLinus Torvalds /* We have some data, deliver it */ 19011da177e4SLinus Torvalds STbp->buffer_bytes = (blks - transfer) * 19021da177e4SLinus Torvalds STp->block_size; 19031da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 19041da177e4SLinus Torvalds "%s: ILI but enough data received %ld %d.\n", 19051da177e4SLinus Torvalds name, count, STbp->buffer_bytes)); 19061da177e4SLinus Torvalds if (STps->drv_block >= 0) 19071da177e4SLinus Torvalds STps->drv_block += 1; 19081da177e4SLinus Torvalds if (st_int_ioctl(STp, MTBSR, 1)) 19091da177e4SLinus Torvalds return (-EIO); 19101da177e4SLinus Torvalds } 19111da177e4SLinus Torvalds } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */ 19121da177e4SLinus Torvalds if (STps->eof != ST_FM_HIT) 19131da177e4SLinus Torvalds STps->eof = ST_FM_HIT; 19141da177e4SLinus Torvalds else 19151da177e4SLinus Torvalds STps->eof = ST_EOD_2; 19161da177e4SLinus Torvalds if (STp->block_size == 0) 19171da177e4SLinus Torvalds STbp->buffer_bytes = 0; 19181da177e4SLinus Torvalds else 19191da177e4SLinus Torvalds STbp->buffer_bytes = 19201da177e4SLinus Torvalds bytes - transfer * STp->block_size; 19211da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 19221da177e4SLinus Torvalds "%s: EOF detected (%d bytes read).\n", 19231da177e4SLinus Torvalds name, STbp->buffer_bytes)); 19241da177e4SLinus Torvalds } else if (cmdstatp->flags & SENSE_EOM) { 19251da177e4SLinus Torvalds if (STps->eof == ST_FM) 19261da177e4SLinus Torvalds STps->eof = ST_EOD_1; 19271da177e4SLinus Torvalds else 19281da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 19291da177e4SLinus Torvalds if (STp->block_size == 0) 19301da177e4SLinus Torvalds STbp->buffer_bytes = bytes - transfer; 19311da177e4SLinus Torvalds else 19321da177e4SLinus Torvalds STbp->buffer_bytes = 19331da177e4SLinus Torvalds bytes - transfer * STp->block_size; 19341da177e4SLinus Torvalds 19351da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n", 19361da177e4SLinus Torvalds name, STbp->buffer_bytes)); 19371da177e4SLinus Torvalds } 19381da177e4SLinus Torvalds } 19391da177e4SLinus Torvalds /* end of EOF, EOM, ILI test */ 19401da177e4SLinus Torvalds else { /* nonzero sense key */ 19411da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 19421da177e4SLinus Torvalds "%s: Tape error while reading.\n", name)); 19431da177e4SLinus Torvalds STps->drv_block = (-1); 19441da177e4SLinus Torvalds if (STps->eof == ST_FM && 19451da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == BLANK_CHECK) { 19461da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 19471da177e4SLinus Torvalds "%s: Zero returned for first BLANK CHECK after EOF.\n", 19481da177e4SLinus Torvalds name)); 19491da177e4SLinus Torvalds STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */ 19501da177e4SLinus Torvalds } else /* Some other extended sense code */ 19511da177e4SLinus Torvalds retval = (-EIO); 19521da177e4SLinus Torvalds } 19531da177e4SLinus Torvalds 19541da177e4SLinus Torvalds if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */ 19551da177e4SLinus Torvalds STbp->buffer_bytes = 0; 19561da177e4SLinus Torvalds } 19571da177e4SLinus Torvalds /* End of extended sense test */ 19581da177e4SLinus Torvalds else { /* Non-extended sense */ 19591da177e4SLinus Torvalds retval = STbp->syscall_result; 19601da177e4SLinus Torvalds } 19611da177e4SLinus Torvalds 19621da177e4SLinus Torvalds } 19631da177e4SLinus Torvalds /* End of error handling */ 196440f6b36cSKai Makisara else { /* Read successful */ 19651da177e4SLinus Torvalds STbp->buffer_bytes = bytes; 196640f6b36cSKai Makisara if (STp->sili) /* In fixed block mode residual is always zero here */ 196740f6b36cSKai Makisara STbp->buffer_bytes -= STp->buffer->cmdstat.residual; 196840f6b36cSKai Makisara } 19691da177e4SLinus Torvalds 19701da177e4SLinus Torvalds if (STps->drv_block >= 0) { 19711da177e4SLinus Torvalds if (STp->block_size == 0) 19721da177e4SLinus Torvalds STps->drv_block++; 19731da177e4SLinus Torvalds else 19741da177e4SLinus Torvalds STps->drv_block += STbp->buffer_bytes / STp->block_size; 19751da177e4SLinus Torvalds } 19761da177e4SLinus Torvalds return retval; 19771da177e4SLinus Torvalds } 19781da177e4SLinus Torvalds 19791da177e4SLinus Torvalds 19801da177e4SLinus Torvalds /* Read command */ 19811da177e4SLinus Torvalds static ssize_t 19821da177e4SLinus Torvalds st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos) 19831da177e4SLinus Torvalds { 19841da177e4SLinus Torvalds ssize_t total; 19851da177e4SLinus Torvalds ssize_t retval = 0; 19861da177e4SLinus Torvalds ssize_t i, transfer; 19871da177e4SLinus Torvalds int special, do_dio = 0; 19888b05b773SMike Christie struct st_request *SRpnt = NULL; 19891da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 19901da177e4SLinus Torvalds struct st_modedef *STm; 19911da177e4SLinus Torvalds struct st_partstat *STps; 19921da177e4SLinus Torvalds struct st_buffer *STbp = STp->buffer; 19931da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 19941da177e4SLinus Torvalds 199528f85009SMatthias Kaehlcke if (mutex_lock_interruptible(&STp->lock)) 19961da177e4SLinus Torvalds return -ERESTARTSYS; 19971da177e4SLinus Torvalds 19981da177e4SLinus Torvalds retval = rw_checks(STp, filp, count); 19991da177e4SLinus Torvalds if (retval || count == 0) 20001da177e4SLinus Torvalds goto out; 20011da177e4SLinus Torvalds 20021da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 20039abe16c6SKai Makisara if (STp->block_size != 0 && (count % STp->block_size) != 0) { 20049abe16c6SKai Makisara if (!STm->do_read_ahead) { 20051da177e4SLinus Torvalds retval = (-EINVAL); /* Read must be integral number of blocks */ 20061da177e4SLinus Torvalds goto out; 20071da177e4SLinus Torvalds } 20089abe16c6SKai Makisara STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */ 20099abe16c6SKai Makisara } 20101da177e4SLinus Torvalds 20111da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 20121da177e4SLinus Torvalds if (STps->rw == ST_WRITING) { 20131da177e4SLinus Torvalds retval = flush_buffer(STp, 0); 20141da177e4SLinus Torvalds if (retval) 20151da177e4SLinus Torvalds goto out; 20161da177e4SLinus Torvalds STps->rw = ST_READING; 20171da177e4SLinus Torvalds } 20181da177e4SLinus Torvalds DEB( 20191da177e4SLinus Torvalds if (debugging && STps->eof != ST_NOEOF) 20201da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name, 20211da177e4SLinus Torvalds STps->eof, STbp->buffer_bytes); 20221da177e4SLinus Torvalds ) /* end DEB */ 20231da177e4SLinus Torvalds 20241da177e4SLinus Torvalds retval = setup_buffering(STp, buf, count, 1); 20251da177e4SLinus Torvalds if (retval) 20261da177e4SLinus Torvalds goto out; 20271da177e4SLinus Torvalds do_dio = STbp->do_dio; 20281da177e4SLinus Torvalds 20291da177e4SLinus Torvalds if (STbp->buffer_bytes == 0 && 20301da177e4SLinus Torvalds STps->eof >= ST_EOD_1) { 20311da177e4SLinus Torvalds if (STps->eof < ST_EOD) { 20321da177e4SLinus Torvalds STps->eof += 1; 20331da177e4SLinus Torvalds retval = 0; 20341da177e4SLinus Torvalds goto out; 20351da177e4SLinus Torvalds } 20361da177e4SLinus Torvalds retval = (-EIO); /* EOM or Blank Check */ 20371da177e4SLinus Torvalds goto out; 20381da177e4SLinus Torvalds } 20391da177e4SLinus Torvalds 20401da177e4SLinus Torvalds if (do_dio) { 20411da177e4SLinus Torvalds /* Check the buffer writability before any tape movement. Don't alter 20421da177e4SLinus Torvalds buffer data. */ 20431da177e4SLinus Torvalds if (copy_from_user(&i, buf, 1) != 0 || 20441da177e4SLinus Torvalds copy_to_user(buf, &i, 1) != 0 || 20451da177e4SLinus Torvalds copy_from_user(&i, buf + count - 1, 1) != 0 || 20461da177e4SLinus Torvalds copy_to_user(buf + count - 1, &i, 1) != 0) { 20471da177e4SLinus Torvalds retval = (-EFAULT); 20481da177e4SLinus Torvalds goto out; 20491da177e4SLinus Torvalds } 20501da177e4SLinus Torvalds } 20511da177e4SLinus Torvalds 20521da177e4SLinus Torvalds STps->rw = ST_READING; 20531da177e4SLinus Torvalds 20541da177e4SLinus Torvalds 20551da177e4SLinus Torvalds /* Loop until enough data in buffer or a special condition found */ 20561da177e4SLinus Torvalds for (total = 0, special = 0; total < count && !special;) { 20571da177e4SLinus Torvalds 20581da177e4SLinus Torvalds /* Get new data if the buffer is empty */ 20591da177e4SLinus Torvalds if (STbp->buffer_bytes == 0) { 20601da177e4SLinus Torvalds special = read_tape(STp, count - total, &SRpnt); 20611da177e4SLinus Torvalds if (special < 0) { /* No need to continue read */ 20621da177e4SLinus Torvalds retval = special; 20631da177e4SLinus Torvalds goto out; 20641da177e4SLinus Torvalds } 20651da177e4SLinus Torvalds } 20661da177e4SLinus Torvalds 20671da177e4SLinus Torvalds /* Move the data from driver buffer to user buffer */ 20681da177e4SLinus Torvalds if (STbp->buffer_bytes > 0) { 20691da177e4SLinus Torvalds DEB( 20701da177e4SLinus Torvalds if (debugging && STps->eof != ST_NOEOF) 20711da177e4SLinus Torvalds printk(ST_DEB_MSG 20721da177e4SLinus Torvalds "%s: EOF up (%d). Left %d, needed %d.\n", name, 20731da177e4SLinus Torvalds STps->eof, STbp->buffer_bytes, 20741da177e4SLinus Torvalds (int)(count - total)); 20751da177e4SLinus Torvalds ) /* end DEB */ 20761da177e4SLinus Torvalds transfer = STbp->buffer_bytes < count - total ? 20771da177e4SLinus Torvalds STbp->buffer_bytes : count - total; 20781da177e4SLinus Torvalds if (!do_dio) { 20791da177e4SLinus Torvalds i = from_buffer(STbp, buf, transfer); 20801da177e4SLinus Torvalds if (i) { 20811da177e4SLinus Torvalds retval = i; 20821da177e4SLinus Torvalds goto out; 20831da177e4SLinus Torvalds } 20841da177e4SLinus Torvalds } 20851da177e4SLinus Torvalds buf += transfer; 20861da177e4SLinus Torvalds total += transfer; 20871da177e4SLinus Torvalds } 20881da177e4SLinus Torvalds 20891da177e4SLinus Torvalds if (STp->block_size == 0) 20901da177e4SLinus Torvalds break; /* Read only one variable length block */ 20911da177e4SLinus Torvalds 20921da177e4SLinus Torvalds } /* for (total = 0, special = 0; 20931da177e4SLinus Torvalds total < count && !special; ) */ 20941da177e4SLinus Torvalds 20951da177e4SLinus Torvalds /* Change the eof state if no data from tape or buffer */ 20961da177e4SLinus Torvalds if (total == 0) { 20971da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) { 20981da177e4SLinus Torvalds STps->eof = ST_FM; 20991da177e4SLinus Torvalds STps->drv_block = 0; 21001da177e4SLinus Torvalds if (STps->drv_file >= 0) 21011da177e4SLinus Torvalds STps->drv_file++; 21021da177e4SLinus Torvalds } else if (STps->eof == ST_EOD_1) { 21031da177e4SLinus Torvalds STps->eof = ST_EOD_2; 21041da177e4SLinus Torvalds STps->drv_block = 0; 21051da177e4SLinus Torvalds if (STps->drv_file >= 0) 21061da177e4SLinus Torvalds STps->drv_file++; 21071da177e4SLinus Torvalds } else if (STps->eof == ST_EOD_2) 21081da177e4SLinus Torvalds STps->eof = ST_EOD; 21091da177e4SLinus Torvalds } else if (STps->eof == ST_FM) 21101da177e4SLinus Torvalds STps->eof = ST_NOEOF; 21111da177e4SLinus Torvalds retval = total; 21121da177e4SLinus Torvalds 21131da177e4SLinus Torvalds out: 21141da177e4SLinus Torvalds if (SRpnt != NULL) { 21158b05b773SMike Christie st_release_request(SRpnt); 21161da177e4SLinus Torvalds SRpnt = NULL; 21171da177e4SLinus Torvalds } 21181da177e4SLinus Torvalds if (do_dio) { 2119787926b1SKai Makisara release_buffering(STp, 1); 21201da177e4SLinus Torvalds STbp->buffer_bytes = 0; 21211da177e4SLinus Torvalds } 212228f85009SMatthias Kaehlcke mutex_unlock(&STp->lock); 21231da177e4SLinus Torvalds 21241da177e4SLinus Torvalds return retval; 21251da177e4SLinus Torvalds } 21261da177e4SLinus Torvalds 21271da177e4SLinus Torvalds 21281da177e4SLinus Torvalds 21291da177e4SLinus Torvalds DEB( 21301da177e4SLinus Torvalds /* Set the driver options */ 21311da177e4SLinus Torvalds static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name) 21321da177e4SLinus Torvalds { 21331da177e4SLinus Torvalds if (debugging) { 21341da177e4SLinus Torvalds printk(KERN_INFO 21351da177e4SLinus Torvalds "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n", 21361da177e4SLinus Torvalds name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes, 21371da177e4SLinus Torvalds STm->do_read_ahead); 21381da177e4SLinus Torvalds printk(KERN_INFO 21391da177e4SLinus Torvalds "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n", 21401da177e4SLinus Torvalds name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock); 21411da177e4SLinus Torvalds printk(KERN_INFO 21421da177e4SLinus Torvalds "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n", 21431da177e4SLinus Torvalds name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions, 21441da177e4SLinus Torvalds STp->scsi2_logical); 21451da177e4SLinus Torvalds printk(KERN_INFO 214640f6b36cSKai Makisara "%s: sysv: %d nowait: %d sili: %d\n", name, STm->sysv, STp->immediate, 214740f6b36cSKai Makisara STp->sili); 21481da177e4SLinus Torvalds printk(KERN_INFO "%s: debugging: %d\n", 21491da177e4SLinus Torvalds name, debugging); 21501da177e4SLinus Torvalds } 21511da177e4SLinus Torvalds } 21521da177e4SLinus Torvalds ) 21531da177e4SLinus Torvalds 21541da177e4SLinus Torvalds 21551da177e4SLinus Torvalds static int st_set_options(struct scsi_tape *STp, long options) 21561da177e4SLinus Torvalds { 21571da177e4SLinus Torvalds int value; 21581da177e4SLinus Torvalds long code; 21591da177e4SLinus Torvalds struct st_modedef *STm; 21601da177e4SLinus Torvalds char *name = tape_name(STp); 21611da177e4SLinus Torvalds struct cdev *cd0, *cd1; 21621da177e4SLinus Torvalds 21631da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 21641da177e4SLinus Torvalds if (!STm->defined) { 21651da177e4SLinus Torvalds cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1]; 21661da177e4SLinus Torvalds memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef)); 21671da177e4SLinus Torvalds STm->cdevs[0] = cd0; STm->cdevs[1] = cd1; 21681da177e4SLinus Torvalds modes_defined = 1; 21691da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 21701da177e4SLinus Torvalds "%s: Initialized mode %d definition from mode 0\n", 21711da177e4SLinus Torvalds name, STp->current_mode)); 21721da177e4SLinus Torvalds } 21731da177e4SLinus Torvalds 21741da177e4SLinus Torvalds code = options & MT_ST_OPTIONS; 21751da177e4SLinus Torvalds if (code == MT_ST_BOOLEANS) { 21761da177e4SLinus Torvalds STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0; 21771da177e4SLinus Torvalds STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0; 21781da177e4SLinus Torvalds STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0; 21791da177e4SLinus Torvalds STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0; 21801da177e4SLinus Torvalds STp->two_fm = (options & MT_ST_TWO_FM) != 0; 21811da177e4SLinus Torvalds STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0; 21821da177e4SLinus Torvalds STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0; 21831da177e4SLinus Torvalds STp->can_bsr = (options & MT_ST_CAN_BSR) != 0; 21841da177e4SLinus Torvalds STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0; 21851da177e4SLinus Torvalds if ((STp->device)->scsi_level >= SCSI_2) 21861da177e4SLinus Torvalds STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0; 21871da177e4SLinus Torvalds STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0; 21881da177e4SLinus Torvalds STp->immediate = (options & MT_ST_NOWAIT) != 0; 21891da177e4SLinus Torvalds STm->sysv = (options & MT_ST_SYSV) != 0; 219040f6b36cSKai Makisara STp->sili = (options & MT_ST_SILI) != 0; 21911da177e4SLinus Torvalds DEB( debugging = (options & MT_ST_DEBUGGING) != 0; 21921da177e4SLinus Torvalds st_log_options(STp, STm, name); ) 21931da177e4SLinus Torvalds } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) { 21941da177e4SLinus Torvalds value = (code == MT_ST_SETBOOLEANS); 21951da177e4SLinus Torvalds if ((options & MT_ST_BUFFER_WRITES) != 0) 21961da177e4SLinus Torvalds STm->do_buffer_writes = value; 21971da177e4SLinus Torvalds if ((options & MT_ST_ASYNC_WRITES) != 0) 21981da177e4SLinus Torvalds STm->do_async_writes = value; 21991da177e4SLinus Torvalds if ((options & MT_ST_DEF_WRITES) != 0) 22001da177e4SLinus Torvalds STm->defaults_for_writes = value; 22011da177e4SLinus Torvalds if ((options & MT_ST_READ_AHEAD) != 0) 22021da177e4SLinus Torvalds STm->do_read_ahead = value; 22031da177e4SLinus Torvalds if ((options & MT_ST_TWO_FM) != 0) 22041da177e4SLinus Torvalds STp->two_fm = value; 22051da177e4SLinus Torvalds if ((options & MT_ST_FAST_MTEOM) != 0) 22061da177e4SLinus Torvalds STp->fast_mteom = value; 22071da177e4SLinus Torvalds if ((options & MT_ST_AUTO_LOCK) != 0) 22081da177e4SLinus Torvalds STp->do_auto_lock = value; 22091da177e4SLinus Torvalds if ((options & MT_ST_CAN_BSR) != 0) 22101da177e4SLinus Torvalds STp->can_bsr = value; 22111da177e4SLinus Torvalds if ((options & MT_ST_NO_BLKLIMS) != 0) 22121da177e4SLinus Torvalds STp->omit_blklims = value; 22131da177e4SLinus Torvalds if ((STp->device)->scsi_level >= SCSI_2 && 22141da177e4SLinus Torvalds (options & MT_ST_CAN_PARTITIONS) != 0) 22151da177e4SLinus Torvalds STp->can_partitions = value; 22161da177e4SLinus Torvalds if ((options & MT_ST_SCSI2LOGICAL) != 0) 22171da177e4SLinus Torvalds STp->scsi2_logical = value; 22181da177e4SLinus Torvalds if ((options & MT_ST_NOWAIT) != 0) 22191da177e4SLinus Torvalds STp->immediate = value; 22201da177e4SLinus Torvalds if ((options & MT_ST_SYSV) != 0) 22211da177e4SLinus Torvalds STm->sysv = value; 222240f6b36cSKai Makisara if ((options & MT_ST_SILI) != 0) 222340f6b36cSKai Makisara STp->sili = value; 22241da177e4SLinus Torvalds DEB( 22251da177e4SLinus Torvalds if ((options & MT_ST_DEBUGGING) != 0) 22261da177e4SLinus Torvalds debugging = value; 22271da177e4SLinus Torvalds st_log_options(STp, STm, name); ) 22281da177e4SLinus Torvalds } else if (code == MT_ST_WRITE_THRESHOLD) { 22291da177e4SLinus Torvalds /* Retained for compatibility */ 22301da177e4SLinus Torvalds } else if (code == MT_ST_DEF_BLKSIZE) { 22311da177e4SLinus Torvalds value = (options & ~MT_ST_OPTIONS); 22321da177e4SLinus Torvalds if (value == ~MT_ST_OPTIONS) { 22331da177e4SLinus Torvalds STm->default_blksize = (-1); 22341da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name)); 22351da177e4SLinus Torvalds } else { 22361da177e4SLinus Torvalds STm->default_blksize = value; 22371da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n", 22381da177e4SLinus Torvalds name, STm->default_blksize)); 22391da177e4SLinus Torvalds if (STp->ready == ST_READY) { 22401da177e4SLinus Torvalds STp->blksize_changed = 0; 22411da177e4SLinus Torvalds set_mode_densblk(STp, STm); 22421da177e4SLinus Torvalds } 22431da177e4SLinus Torvalds } 22441da177e4SLinus Torvalds } else if (code == MT_ST_TIMEOUTS) { 22451da177e4SLinus Torvalds value = (options & ~MT_ST_OPTIONS); 22461da177e4SLinus Torvalds if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) { 22471da177e4SLinus Torvalds STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ; 22481da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name, 22491da177e4SLinus Torvalds (value & ~MT_ST_SET_LONG_TIMEOUT))); 22501da177e4SLinus Torvalds } else { 2251a02488edSJames Bottomley blk_queue_rq_timeout(STp->device->request_queue, 2252a02488edSJames Bottomley value * HZ); 22531da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n", 22541da177e4SLinus Torvalds name, value) ); 22551da177e4SLinus Torvalds } 22561da177e4SLinus Torvalds } else if (code == MT_ST_SET_CLN) { 22571da177e4SLinus Torvalds value = (options & ~MT_ST_OPTIONS) & 0xff; 22581da177e4SLinus Torvalds if (value != 0 && 22591da177e4SLinus Torvalds value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE) 22601da177e4SLinus Torvalds return (-EINVAL); 22611da177e4SLinus Torvalds STp->cln_mode = value; 22621da177e4SLinus Torvalds STp->cln_sense_mask = (options >> 8) & 0xff; 22631da177e4SLinus Torvalds STp->cln_sense_value = (options >> 16) & 0xff; 22641da177e4SLinus Torvalds printk(KERN_INFO 22651da177e4SLinus Torvalds "%s: Cleaning request mode %d, mask %02x, value %02x\n", 22661da177e4SLinus Torvalds name, value, STp->cln_sense_mask, STp->cln_sense_value); 22671da177e4SLinus Torvalds } else if (code == MT_ST_DEF_OPTIONS) { 22681da177e4SLinus Torvalds code = (options & ~MT_ST_CLEAR_DEFAULT); 22691da177e4SLinus Torvalds value = (options & MT_ST_CLEAR_DEFAULT); 22701da177e4SLinus Torvalds if (code == MT_ST_DEF_DENSITY) { 22711da177e4SLinus Torvalds if (value == MT_ST_CLEAR_DEFAULT) { 22721da177e4SLinus Torvalds STm->default_density = (-1); 22731da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Density default disabled.\n", 22741da177e4SLinus Torvalds name)); 22751da177e4SLinus Torvalds } else { 22761da177e4SLinus Torvalds STm->default_density = value & 0xff; 22771da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Density default set to %x\n", 22781da177e4SLinus Torvalds name, STm->default_density)); 22791da177e4SLinus Torvalds if (STp->ready == ST_READY) { 22801da177e4SLinus Torvalds STp->density_changed = 0; 22811da177e4SLinus Torvalds set_mode_densblk(STp, STm); 22821da177e4SLinus Torvalds } 22831da177e4SLinus Torvalds } 22841da177e4SLinus Torvalds } else if (code == MT_ST_DEF_DRVBUFFER) { 22851da177e4SLinus Torvalds if (value == MT_ST_CLEAR_DEFAULT) { 22861da177e4SLinus Torvalds STp->default_drvbuffer = 0xff; 22871da177e4SLinus Torvalds DEBC( printk(KERN_INFO 22881da177e4SLinus Torvalds "%s: Drive buffer default disabled.\n", name)); 22891da177e4SLinus Torvalds } else { 22901da177e4SLinus Torvalds STp->default_drvbuffer = value & 7; 22911da177e4SLinus Torvalds DEBC( printk(KERN_INFO 22921da177e4SLinus Torvalds "%s: Drive buffer default set to %x\n", 22931da177e4SLinus Torvalds name, STp->default_drvbuffer)); 22941da177e4SLinus Torvalds if (STp->ready == ST_READY) 22951da177e4SLinus Torvalds st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer); 22961da177e4SLinus Torvalds } 22971da177e4SLinus Torvalds } else if (code == MT_ST_DEF_COMPRESSION) { 22981da177e4SLinus Torvalds if (value == MT_ST_CLEAR_DEFAULT) { 22991da177e4SLinus Torvalds STm->default_compression = ST_DONT_TOUCH; 23001da177e4SLinus Torvalds DEBC( printk(KERN_INFO 23011da177e4SLinus Torvalds "%s: Compression default disabled.\n", name)); 23021da177e4SLinus Torvalds } else { 23031da177e4SLinus Torvalds if ((value & 0xff00) != 0) { 23041da177e4SLinus Torvalds STp->c_algo = (value & 0xff00) >> 8; 23051da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n", 23061da177e4SLinus Torvalds name, STp->c_algo)); 23071da177e4SLinus Torvalds } 23081da177e4SLinus Torvalds if ((value & 0xff) != 0xff) { 23091da177e4SLinus Torvalds STm->default_compression = (value & 1 ? ST_YES : ST_NO); 23101da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Compression default set to %x\n", 23111da177e4SLinus Torvalds name, (value & 1))); 23121da177e4SLinus Torvalds if (STp->ready == ST_READY) { 23131da177e4SLinus Torvalds STp->compression_changed = 0; 23141da177e4SLinus Torvalds st_compression(STp, (STm->default_compression == ST_YES)); 23151da177e4SLinus Torvalds } 23161da177e4SLinus Torvalds } 23171da177e4SLinus Torvalds } 23181da177e4SLinus Torvalds } 23191da177e4SLinus Torvalds } else 23201da177e4SLinus Torvalds return (-EIO); 23211da177e4SLinus Torvalds 23221da177e4SLinus Torvalds return 0; 23231da177e4SLinus Torvalds } 23241da177e4SLinus Torvalds 23251da177e4SLinus Torvalds #define MODE_HEADER_LENGTH 4 23261da177e4SLinus Torvalds 23271da177e4SLinus Torvalds /* Mode header and page byte offsets */ 23281da177e4SLinus Torvalds #define MH_OFF_DATA_LENGTH 0 23291da177e4SLinus Torvalds #define MH_OFF_MEDIUM_TYPE 1 23301da177e4SLinus Torvalds #define MH_OFF_DEV_SPECIFIC 2 23311da177e4SLinus Torvalds #define MH_OFF_BDESCS_LENGTH 3 23321da177e4SLinus Torvalds #define MP_OFF_PAGE_NBR 0 23331da177e4SLinus Torvalds #define MP_OFF_PAGE_LENGTH 1 23341da177e4SLinus Torvalds 23351da177e4SLinus Torvalds /* Mode header and page bit masks */ 23361da177e4SLinus Torvalds #define MH_BIT_WP 0x80 23371da177e4SLinus Torvalds #define MP_MSK_PAGE_NBR 0x3f 23381da177e4SLinus Torvalds 23391da177e4SLinus Torvalds /* Don't return block descriptors */ 23401da177e4SLinus Torvalds #define MODE_SENSE_OMIT_BDESCS 0x08 23411da177e4SLinus Torvalds 23421da177e4SLinus Torvalds #define MODE_SELECT_PAGE_FORMAT 0x10 23431da177e4SLinus Torvalds 23441da177e4SLinus Torvalds /* Read a mode page into the tape buffer. The block descriptors are included 23451da177e4SLinus Torvalds if incl_block_descs is true. The page control is ored to the page number 23461da177e4SLinus Torvalds parameter, if necessary. */ 23471da177e4SLinus Torvalds static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs) 23481da177e4SLinus Torvalds { 23491da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 23508b05b773SMike Christie struct st_request *SRpnt = NULL; 23511da177e4SLinus Torvalds 23521da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 23531da177e4SLinus Torvalds cmd[0] = MODE_SENSE; 23541da177e4SLinus Torvalds if (omit_block_descs) 23551da177e4SLinus Torvalds cmd[1] = MODE_SENSE_OMIT_BDESCS; 23561da177e4SLinus Torvalds cmd[2] = page; 23571da177e4SLinus Torvalds cmd[4] = 255; 23581da177e4SLinus Torvalds 23591da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, 2360a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 0, 1); 23611da177e4SLinus Torvalds if (SRpnt == NULL) 23621da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 23631da177e4SLinus Torvalds 23648b05b773SMike Christie st_release_request(SRpnt); 23651da177e4SLinus Torvalds 23661da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 23671da177e4SLinus Torvalds } 23681da177e4SLinus Torvalds 23691da177e4SLinus Torvalds 23701da177e4SLinus Torvalds /* Send the mode page in the tape buffer to the drive. Assumes that the mode data 23711da177e4SLinus Torvalds in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */ 23721da177e4SLinus Torvalds static int write_mode_page(struct scsi_tape *STp, int page, int slow) 23731da177e4SLinus Torvalds { 23741da177e4SLinus Torvalds int pgo; 23751da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 23768b05b773SMike Christie struct st_request *SRpnt = NULL; 23771da177e4SLinus Torvalds 23781da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 23791da177e4SLinus Torvalds cmd[0] = MODE_SELECT; 23801da177e4SLinus Torvalds cmd[1] = MODE_SELECT_PAGE_FORMAT; 23811da177e4SLinus Torvalds pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH]; 23821da177e4SLinus Torvalds cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2; 23831da177e4SLinus Torvalds 23841da177e4SLinus Torvalds /* Clear reserved fields */ 23851da177e4SLinus Torvalds (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0; 23861da177e4SLinus Torvalds (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0; 23871da177e4SLinus Torvalds (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP; 23881da177e4SLinus Torvalds (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR; 23891da177e4SLinus Torvalds 23901da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, 2391a02488edSJames Bottomley (slow ? STp->long_timeout : STp->device->request_queue->rq_timeout), 0, 1); 23921da177e4SLinus Torvalds if (SRpnt == NULL) 23931da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 23941da177e4SLinus Torvalds 23958b05b773SMike Christie st_release_request(SRpnt); 23961da177e4SLinus Torvalds 23971da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 23981da177e4SLinus Torvalds } 23991da177e4SLinus Torvalds 24001da177e4SLinus Torvalds 24011da177e4SLinus Torvalds #define COMPRESSION_PAGE 0x0f 24021da177e4SLinus Torvalds #define COMPRESSION_PAGE_LENGTH 16 24031da177e4SLinus Torvalds 24041da177e4SLinus Torvalds #define CP_OFF_DCE_DCC 2 24051da177e4SLinus Torvalds #define CP_OFF_C_ALGO 7 24061da177e4SLinus Torvalds 24071da177e4SLinus Torvalds #define DCE_MASK 0x80 24081da177e4SLinus Torvalds #define DCC_MASK 0x40 24091da177e4SLinus Torvalds #define RED_MASK 0x60 24101da177e4SLinus Torvalds 24111da177e4SLinus Torvalds 24121da177e4SLinus Torvalds /* Control the compression with mode page 15. Algorithm not changed if zero. 24131da177e4SLinus Torvalds 24141da177e4SLinus Torvalds The block descriptors are read and written because Sony SDT-7000 does not 24151da177e4SLinus Torvalds work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>). 24161da177e4SLinus Torvalds Including block descriptors should not cause any harm to other drives. */ 24171da177e4SLinus Torvalds 24181da177e4SLinus Torvalds static int st_compression(struct scsi_tape * STp, int state) 24191da177e4SLinus Torvalds { 24201da177e4SLinus Torvalds int retval; 24211da177e4SLinus Torvalds int mpoffs; /* Offset to mode page start */ 24221da177e4SLinus Torvalds unsigned char *b_data = (STp->buffer)->b_data; 24231da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 24241da177e4SLinus Torvalds 24251da177e4SLinus Torvalds if (STp->ready != ST_READY) 24261da177e4SLinus Torvalds return (-EIO); 24271da177e4SLinus Torvalds 24281da177e4SLinus Torvalds /* Read the current page contents */ 24291da177e4SLinus Torvalds retval = read_mode_page(STp, COMPRESSION_PAGE, 0); 24301da177e4SLinus Torvalds if (retval) { 24311da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n", 24321da177e4SLinus Torvalds name)); 24331da177e4SLinus Torvalds return (-EIO); 24341da177e4SLinus Torvalds } 24351da177e4SLinus Torvalds 24361da177e4SLinus Torvalds mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH]; 24371da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name, 24381da177e4SLinus Torvalds (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0))); 24391da177e4SLinus Torvalds 24401da177e4SLinus Torvalds /* Check if compression can be changed */ 24411da177e4SLinus Torvalds if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) { 24421da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name)); 24431da177e4SLinus Torvalds return (-EIO); 24441da177e4SLinus Torvalds } 24451da177e4SLinus Torvalds 24461da177e4SLinus Torvalds /* Do the change */ 24471da177e4SLinus Torvalds if (state) { 24481da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK; 24491da177e4SLinus Torvalds if (STp->c_algo != 0) 24501da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo; 24511da177e4SLinus Torvalds } 24521da177e4SLinus Torvalds else { 24531da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK; 24541da177e4SLinus Torvalds if (STp->c_algo != 0) 24551da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */ 24561da177e4SLinus Torvalds } 24571da177e4SLinus Torvalds 24581da177e4SLinus Torvalds retval = write_mode_page(STp, COMPRESSION_PAGE, 0); 24591da177e4SLinus Torvalds if (retval) { 24601da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name)); 24611da177e4SLinus Torvalds return (-EIO); 24621da177e4SLinus Torvalds } 24631da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n", 24641da177e4SLinus Torvalds name, state)); 24651da177e4SLinus Torvalds 24661da177e4SLinus Torvalds STp->compression_changed = 1; 24671da177e4SLinus Torvalds return 0; 24681da177e4SLinus Torvalds } 24691da177e4SLinus Torvalds 24701da177e4SLinus Torvalds 24711da177e4SLinus Torvalds /* Process the load and unload commands (does unload if the load code is zero) */ 24721da177e4SLinus Torvalds static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code) 24731da177e4SLinus Torvalds { 24741da177e4SLinus Torvalds int retval = (-EIO), timeout; 24751da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 24761da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 24771da177e4SLinus Torvalds struct st_partstat *STps; 24788b05b773SMike Christie struct st_request *SRpnt; 24791da177e4SLinus Torvalds 24801da177e4SLinus Torvalds if (STp->ready != ST_READY && !load_code) { 24811da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 24821da177e4SLinus Torvalds return (-ENOMEDIUM); 24831da177e4SLinus Torvalds else 24841da177e4SLinus Torvalds return (-EIO); 24851da177e4SLinus Torvalds } 24861da177e4SLinus Torvalds 24871da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 24881da177e4SLinus Torvalds cmd[0] = START_STOP; 24891da177e4SLinus Torvalds if (load_code) 24901da177e4SLinus Torvalds cmd[4] |= 1; 24911da177e4SLinus Torvalds /* 24921da177e4SLinus Torvalds * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A 24931da177e4SLinus Torvalds */ 24941da177e4SLinus Torvalds if (load_code >= 1 + MT_ST_HPLOADER_OFFSET 24951da177e4SLinus Torvalds && load_code <= 6 + MT_ST_HPLOADER_OFFSET) { 24961da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n", 24971da177e4SLinus Torvalds name, (cmd[4]) ? "" : "un", 24981da177e4SLinus Torvalds load_code - MT_ST_HPLOADER_OFFSET)); 24991da177e4SLinus Torvalds cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */ 25001da177e4SLinus Torvalds } 25011da177e4SLinus Torvalds if (STp->immediate) { 25021da177e4SLinus Torvalds cmd[1] = 1; /* Don't wait for completion */ 2503a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 25041da177e4SLinus Torvalds } 25051da177e4SLinus Torvalds else 25061da177e4SLinus Torvalds timeout = STp->long_timeout; 25071da177e4SLinus Torvalds 25081da177e4SLinus Torvalds DEBC( 25091da177e4SLinus Torvalds if (!load_code) 25101da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Unloading tape.\n", name); 25111da177e4SLinus Torvalds else 25121da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Loading tape.\n", name); 25131da177e4SLinus Torvalds ); 25141da177e4SLinus Torvalds 25151da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE, 25161da177e4SLinus Torvalds timeout, MAX_RETRIES, 1); 25171da177e4SLinus Torvalds if (!SRpnt) 25181da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 25191da177e4SLinus Torvalds 25201da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 25218b05b773SMike Christie st_release_request(SRpnt); 25221da177e4SLinus Torvalds 25231da177e4SLinus Torvalds if (!retval) { /* SCSI command successful */ 25241da177e4SLinus Torvalds 25251da177e4SLinus Torvalds if (!load_code) { 25261da177e4SLinus Torvalds STp->rew_at_close = 0; 25271da177e4SLinus Torvalds STp->ready = ST_NO_TAPE; 25281da177e4SLinus Torvalds } 25291da177e4SLinus Torvalds else { 25301da177e4SLinus Torvalds STp->rew_at_close = STp->autorew_dev; 25311da177e4SLinus Torvalds retval = check_tape(STp, filp); 25321da177e4SLinus Torvalds if (retval > 0) 25331da177e4SLinus Torvalds retval = 0; 25341da177e4SLinus Torvalds } 25351da177e4SLinus Torvalds } 25361da177e4SLinus Torvalds else { 25371da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 25381da177e4SLinus Torvalds STps->drv_file = STps->drv_block = (-1); 25391da177e4SLinus Torvalds } 25401da177e4SLinus Torvalds 25411da177e4SLinus Torvalds return retval; 25421da177e4SLinus Torvalds } 25431da177e4SLinus Torvalds 25441da177e4SLinus Torvalds #if DEBUG 25451da177e4SLinus Torvalds #define ST_DEB_FORWARD 0 25461da177e4SLinus Torvalds #define ST_DEB_BACKWARD 1 25471da177e4SLinus Torvalds static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd) 25481da177e4SLinus Torvalds { 25491da177e4SLinus Torvalds s32 sc; 25501da177e4SLinus Torvalds 25511da177e4SLinus Torvalds sc = cmd[2] & 0x80 ? 0xff000000 : 0; 25521da177e4SLinus Torvalds sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4]; 25531da177e4SLinus Torvalds if (direction) 25541da177e4SLinus Torvalds sc = -sc; 25551da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name, 25561da177e4SLinus Torvalds direction ? "backward" : "forward", sc, units); 25571da177e4SLinus Torvalds } 25581da177e4SLinus Torvalds #endif 25591da177e4SLinus Torvalds 25601da177e4SLinus Torvalds 25611da177e4SLinus Torvalds /* Internal ioctl function */ 25621da177e4SLinus Torvalds static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg) 25631da177e4SLinus Torvalds { 25641da177e4SLinus Torvalds int timeout; 25651da177e4SLinus Torvalds long ltmp; 25661da177e4SLinus Torvalds int ioctl_result; 25671da177e4SLinus Torvalds int chg_eof = 1; 25681da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 25698b05b773SMike Christie struct st_request *SRpnt; 25701da177e4SLinus Torvalds struct st_partstat *STps; 25711da177e4SLinus Torvalds int fileno, blkno, at_sm, undone; 25721da177e4SLinus Torvalds int datalen = 0, direction = DMA_NONE; 25731da177e4SLinus Torvalds char *name = tape_name(STp); 25741da177e4SLinus Torvalds 25751da177e4SLinus Torvalds WARN_ON(STp->buffer->do_dio != 0); 25761da177e4SLinus Torvalds if (STp->ready != ST_READY) { 25771da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 25781da177e4SLinus Torvalds return (-ENOMEDIUM); 25791da177e4SLinus Torvalds else 25801da177e4SLinus Torvalds return (-EIO); 25811da177e4SLinus Torvalds } 25821da177e4SLinus Torvalds timeout = STp->long_timeout; 25831da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 25841da177e4SLinus Torvalds fileno = STps->drv_file; 25851da177e4SLinus Torvalds blkno = STps->drv_block; 25861da177e4SLinus Torvalds at_sm = STps->at_sm; 25871da177e4SLinus Torvalds 25881da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 25891da177e4SLinus Torvalds switch (cmd_in) { 25901da177e4SLinus Torvalds case MTFSFM: 25911da177e4SLinus Torvalds chg_eof = 0; /* Changed from the FSF after this */ 25921da177e4SLinus Torvalds case MTFSF: 25931da177e4SLinus Torvalds cmd[0] = SPACE; 25941da177e4SLinus Torvalds cmd[1] = 0x01; /* Space FileMarks */ 25951da177e4SLinus Torvalds cmd[2] = (arg >> 16); 25961da177e4SLinus Torvalds cmd[3] = (arg >> 8); 25971da177e4SLinus Torvalds cmd[4] = arg; 25981da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);) 25991da177e4SLinus Torvalds if (fileno >= 0) 26001da177e4SLinus Torvalds fileno += arg; 26011da177e4SLinus Torvalds blkno = 0; 26021da177e4SLinus Torvalds at_sm &= (arg == 0); 26031da177e4SLinus Torvalds break; 26041da177e4SLinus Torvalds case MTBSFM: 26051da177e4SLinus Torvalds chg_eof = 0; /* Changed from the FSF after this */ 26061da177e4SLinus Torvalds case MTBSF: 26071da177e4SLinus Torvalds cmd[0] = SPACE; 26081da177e4SLinus Torvalds cmd[1] = 0x01; /* Space FileMarks */ 26091da177e4SLinus Torvalds ltmp = (-arg); 26101da177e4SLinus Torvalds cmd[2] = (ltmp >> 16); 26111da177e4SLinus Torvalds cmd[3] = (ltmp >> 8); 26121da177e4SLinus Torvalds cmd[4] = ltmp; 26131da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);) 26141da177e4SLinus Torvalds if (fileno >= 0) 26151da177e4SLinus Torvalds fileno -= arg; 26161da177e4SLinus Torvalds blkno = (-1); /* We can't know the block number */ 26171da177e4SLinus Torvalds at_sm &= (arg == 0); 26181da177e4SLinus Torvalds break; 26191da177e4SLinus Torvalds case MTFSR: 26201da177e4SLinus Torvalds cmd[0] = SPACE; 26211da177e4SLinus Torvalds cmd[1] = 0x00; /* Space Blocks */ 26221da177e4SLinus Torvalds cmd[2] = (arg >> 16); 26231da177e4SLinus Torvalds cmd[3] = (arg >> 8); 26241da177e4SLinus Torvalds cmd[4] = arg; 26251da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);) 26261da177e4SLinus Torvalds if (blkno >= 0) 26271da177e4SLinus Torvalds blkno += arg; 26281da177e4SLinus Torvalds at_sm &= (arg == 0); 26291da177e4SLinus Torvalds break; 26301da177e4SLinus Torvalds case MTBSR: 26311da177e4SLinus Torvalds cmd[0] = SPACE; 26321da177e4SLinus Torvalds cmd[1] = 0x00; /* Space Blocks */ 26331da177e4SLinus Torvalds ltmp = (-arg); 26341da177e4SLinus Torvalds cmd[2] = (ltmp >> 16); 26351da177e4SLinus Torvalds cmd[3] = (ltmp >> 8); 26361da177e4SLinus Torvalds cmd[4] = ltmp; 26371da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);) 26381da177e4SLinus Torvalds if (blkno >= 0) 26391da177e4SLinus Torvalds blkno -= arg; 26401da177e4SLinus Torvalds at_sm &= (arg == 0); 26411da177e4SLinus Torvalds break; 26421da177e4SLinus Torvalds case MTFSS: 26431da177e4SLinus Torvalds cmd[0] = SPACE; 26441da177e4SLinus Torvalds cmd[1] = 0x04; /* Space Setmarks */ 26451da177e4SLinus Torvalds cmd[2] = (arg >> 16); 26461da177e4SLinus Torvalds cmd[3] = (arg >> 8); 26471da177e4SLinus Torvalds cmd[4] = arg; 26481da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);) 26491da177e4SLinus Torvalds if (arg != 0) { 26501da177e4SLinus Torvalds blkno = fileno = (-1); 26511da177e4SLinus Torvalds at_sm = 1; 26521da177e4SLinus Torvalds } 26531da177e4SLinus Torvalds break; 26541da177e4SLinus Torvalds case MTBSS: 26551da177e4SLinus Torvalds cmd[0] = SPACE; 26561da177e4SLinus Torvalds cmd[1] = 0x04; /* Space Setmarks */ 26571da177e4SLinus Torvalds ltmp = (-arg); 26581da177e4SLinus Torvalds cmd[2] = (ltmp >> 16); 26591da177e4SLinus Torvalds cmd[3] = (ltmp >> 8); 26601da177e4SLinus Torvalds cmd[4] = ltmp; 26611da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);) 26621da177e4SLinus Torvalds if (arg != 0) { 26631da177e4SLinus Torvalds blkno = fileno = (-1); 26641da177e4SLinus Torvalds at_sm = 1; 26651da177e4SLinus Torvalds } 26661da177e4SLinus Torvalds break; 26671da177e4SLinus Torvalds case MTWEOF: 26681da177e4SLinus Torvalds case MTWSM: 26691da177e4SLinus Torvalds if (STp->write_prot) 26701da177e4SLinus Torvalds return (-EACCES); 26711da177e4SLinus Torvalds cmd[0] = WRITE_FILEMARKS; 26721da177e4SLinus Torvalds if (cmd_in == MTWSM) 26731da177e4SLinus Torvalds cmd[1] = 2; 26741da177e4SLinus Torvalds cmd[2] = (arg >> 16); 26751da177e4SLinus Torvalds cmd[3] = (arg >> 8); 26761da177e4SLinus Torvalds cmd[4] = arg; 2677a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 26781da177e4SLinus Torvalds DEBC( 26791da177e4SLinus Torvalds if (cmd_in == MTWEOF) 26801da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name, 26811da177e4SLinus Torvalds cmd[2] * 65536 + cmd[3] * 256 + cmd[4]); 26821da177e4SLinus Torvalds else 26831da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name, 26841da177e4SLinus Torvalds cmd[2] * 65536 + cmd[3] * 256 + cmd[4]); 26851da177e4SLinus Torvalds ) 26861da177e4SLinus Torvalds if (fileno >= 0) 26871da177e4SLinus Torvalds fileno += arg; 26881da177e4SLinus Torvalds blkno = 0; 26891da177e4SLinus Torvalds at_sm = (cmd_in == MTWSM); 26901da177e4SLinus Torvalds break; 26911da177e4SLinus Torvalds case MTREW: 26921da177e4SLinus Torvalds cmd[0] = REZERO_UNIT; 26931da177e4SLinus Torvalds if (STp->immediate) { 26941da177e4SLinus Torvalds cmd[1] = 1; /* Don't wait for completion */ 2695a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 26961da177e4SLinus Torvalds } 26971da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name)); 26981da177e4SLinus Torvalds fileno = blkno = at_sm = 0; 26991da177e4SLinus Torvalds break; 27001da177e4SLinus Torvalds case MTNOP: 27011da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name)); 27021da177e4SLinus Torvalds return 0; /* Should do something ? */ 27031da177e4SLinus Torvalds break; 27041da177e4SLinus Torvalds case MTRETEN: 27051da177e4SLinus Torvalds cmd[0] = START_STOP; 27061da177e4SLinus Torvalds if (STp->immediate) { 27071da177e4SLinus Torvalds cmd[1] = 1; /* Don't wait for completion */ 2708a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 27091da177e4SLinus Torvalds } 27101da177e4SLinus Torvalds cmd[4] = 3; 27111da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name)); 27121da177e4SLinus Torvalds fileno = blkno = at_sm = 0; 27131da177e4SLinus Torvalds break; 27141da177e4SLinus Torvalds case MTEOM: 27151da177e4SLinus Torvalds if (!STp->fast_mteom) { 27161da177e4SLinus Torvalds /* space to the end of tape */ 27171da177e4SLinus Torvalds ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff); 27181da177e4SLinus Torvalds fileno = STps->drv_file; 27191da177e4SLinus Torvalds if (STps->eof >= ST_EOD_1) 27201da177e4SLinus Torvalds return 0; 27211da177e4SLinus Torvalds /* The next lines would hide the number of spaced FileMarks 27221da177e4SLinus Torvalds That's why I inserted the previous lines. I had no luck 27231da177e4SLinus Torvalds with detecting EOM with FSF, so we go now to EOM. 27241da177e4SLinus Torvalds Joerg Weule */ 27251da177e4SLinus Torvalds } else 27261da177e4SLinus Torvalds fileno = (-1); 27271da177e4SLinus Torvalds cmd[0] = SPACE; 27281da177e4SLinus Torvalds cmd[1] = 3; 27291da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n", 27301da177e4SLinus Torvalds name)); 27311da177e4SLinus Torvalds blkno = -1; 27321da177e4SLinus Torvalds at_sm = 0; 27331da177e4SLinus Torvalds break; 27341da177e4SLinus Torvalds case MTERASE: 27351da177e4SLinus Torvalds if (STp->write_prot) 27361da177e4SLinus Torvalds return (-EACCES); 27371da177e4SLinus Torvalds cmd[0] = ERASE; 27381da177e4SLinus Torvalds cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */ 27391da177e4SLinus Torvalds if (STp->immediate) { 27401da177e4SLinus Torvalds cmd[1] |= 2; /* Don't wait for completion */ 2741a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 27421da177e4SLinus Torvalds } 27431da177e4SLinus Torvalds else 27441da177e4SLinus Torvalds timeout = STp->long_timeout * 8; 27451da177e4SLinus Torvalds 27461da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name)); 27471da177e4SLinus Torvalds fileno = blkno = at_sm = 0; 27481da177e4SLinus Torvalds break; 27491da177e4SLinus Torvalds case MTSETBLK: /* Set block length */ 27501da177e4SLinus Torvalds case MTSETDENSITY: /* Set tape density */ 27511da177e4SLinus Torvalds case MTSETDRVBUFFER: /* Set drive buffering */ 27521da177e4SLinus Torvalds case SET_DENS_AND_BLK: /* Set density and block size */ 27531da177e4SLinus Torvalds chg_eof = 0; 27541da177e4SLinus Torvalds if (STp->dirty || (STp->buffer)->buffer_bytes != 0) 27551da177e4SLinus Torvalds return (-EIO); /* Not allowed if data in buffer */ 27561da177e4SLinus Torvalds if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) && 27571da177e4SLinus Torvalds (arg & MT_ST_BLKSIZE_MASK) != 0 && 27581da177e4SLinus Torvalds STp->max_block > 0 && 27591da177e4SLinus Torvalds ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block || 27601da177e4SLinus Torvalds (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) { 27611da177e4SLinus Torvalds printk(KERN_WARNING "%s: Illegal block size.\n", name); 27621da177e4SLinus Torvalds return (-EINVAL); 27631da177e4SLinus Torvalds } 27641da177e4SLinus Torvalds cmd[0] = MODE_SELECT; 27651da177e4SLinus Torvalds if ((STp->use_pf & USE_PF)) 27661da177e4SLinus Torvalds cmd[1] = MODE_SELECT_PAGE_FORMAT; 27671da177e4SLinus Torvalds cmd[4] = datalen = 12; 27681da177e4SLinus Torvalds direction = DMA_TO_DEVICE; 27691da177e4SLinus Torvalds 27701da177e4SLinus Torvalds memset((STp->buffer)->b_data, 0, 12); 27711da177e4SLinus Torvalds if (cmd_in == MTSETDRVBUFFER) 27721da177e4SLinus Torvalds (STp->buffer)->b_data[2] = (arg & 7) << 4; 27731da177e4SLinus Torvalds else 27741da177e4SLinus Torvalds (STp->buffer)->b_data[2] = 27751da177e4SLinus Torvalds STp->drv_buffer << 4; 27761da177e4SLinus Torvalds (STp->buffer)->b_data[3] = 8; /* block descriptor length */ 27771da177e4SLinus Torvalds if (cmd_in == MTSETDENSITY) { 27781da177e4SLinus Torvalds (STp->buffer)->b_data[4] = arg; 27791da177e4SLinus Torvalds STp->density_changed = 1; /* At least we tried ;-) */ 27801da177e4SLinus Torvalds } else if (cmd_in == SET_DENS_AND_BLK) 27811da177e4SLinus Torvalds (STp->buffer)->b_data[4] = arg >> 24; 27821da177e4SLinus Torvalds else 27831da177e4SLinus Torvalds (STp->buffer)->b_data[4] = STp->density; 27841da177e4SLinus Torvalds if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) { 27851da177e4SLinus Torvalds ltmp = arg & MT_ST_BLKSIZE_MASK; 27861da177e4SLinus Torvalds if (cmd_in == MTSETBLK) 27871da177e4SLinus Torvalds STp->blksize_changed = 1; /* At least we tried ;-) */ 27881da177e4SLinus Torvalds } else 27891da177e4SLinus Torvalds ltmp = STp->block_size; 27901da177e4SLinus Torvalds (STp->buffer)->b_data[9] = (ltmp >> 16); 27911da177e4SLinus Torvalds (STp->buffer)->b_data[10] = (ltmp >> 8); 27921da177e4SLinus Torvalds (STp->buffer)->b_data[11] = ltmp; 2793a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 27941da177e4SLinus Torvalds DEBC( 27951da177e4SLinus Torvalds if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) 27961da177e4SLinus Torvalds printk(ST_DEB_MSG 27971da177e4SLinus Torvalds "%s: Setting block size to %d bytes.\n", name, 27981da177e4SLinus Torvalds (STp->buffer)->b_data[9] * 65536 + 27991da177e4SLinus Torvalds (STp->buffer)->b_data[10] * 256 + 28001da177e4SLinus Torvalds (STp->buffer)->b_data[11]); 28011da177e4SLinus Torvalds if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK) 28021da177e4SLinus Torvalds printk(ST_DEB_MSG 28031da177e4SLinus Torvalds "%s: Setting density code to %x.\n", name, 28041da177e4SLinus Torvalds (STp->buffer)->b_data[4]); 28051da177e4SLinus Torvalds if (cmd_in == MTSETDRVBUFFER) 28061da177e4SLinus Torvalds printk(ST_DEB_MSG 28071da177e4SLinus Torvalds "%s: Setting drive buffer code to %d.\n", name, 28081da177e4SLinus Torvalds ((STp->buffer)->b_data[2] >> 4) & 7); 28091da177e4SLinus Torvalds ) 28101da177e4SLinus Torvalds break; 28111da177e4SLinus Torvalds default: 28121da177e4SLinus Torvalds return (-ENOSYS); 28131da177e4SLinus Torvalds } 28141da177e4SLinus Torvalds 28151da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction, 28161da177e4SLinus Torvalds timeout, MAX_RETRIES, 1); 28171da177e4SLinus Torvalds if (!SRpnt) 28181da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 28191da177e4SLinus Torvalds 28201da177e4SLinus Torvalds ioctl_result = (STp->buffer)->syscall_result; 28211da177e4SLinus Torvalds 28221da177e4SLinus Torvalds if (!ioctl_result) { /* SCSI command successful */ 28238b05b773SMike Christie st_release_request(SRpnt); 28241da177e4SLinus Torvalds SRpnt = NULL; 28251da177e4SLinus Torvalds STps->drv_block = blkno; 28261da177e4SLinus Torvalds STps->drv_file = fileno; 28271da177e4SLinus Torvalds STps->at_sm = at_sm; 28281da177e4SLinus Torvalds 28291da177e4SLinus Torvalds if (cmd_in == MTBSFM) 28301da177e4SLinus Torvalds ioctl_result = st_int_ioctl(STp, MTFSF, 1); 28311da177e4SLinus Torvalds else if (cmd_in == MTFSFM) 28321da177e4SLinus Torvalds ioctl_result = st_int_ioctl(STp, MTBSF, 1); 28331da177e4SLinus Torvalds 28341da177e4SLinus Torvalds if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) { 28351da177e4SLinus Torvalds int old_block_size = STp->block_size; 28361da177e4SLinus Torvalds STp->block_size = arg & MT_ST_BLKSIZE_MASK; 28371da177e4SLinus Torvalds if (STp->block_size != 0) { 28381da177e4SLinus Torvalds if (old_block_size == 0) 28391da177e4SLinus Torvalds normalize_buffer(STp->buffer); 28401da177e4SLinus Torvalds (STp->buffer)->buffer_blocks = 28411da177e4SLinus Torvalds (STp->buffer)->buffer_size / STp->block_size; 28421da177e4SLinus Torvalds } 28431da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0; 28441da177e4SLinus Torvalds if (cmd_in == SET_DENS_AND_BLK) 28451da177e4SLinus Torvalds STp->density = arg >> MT_ST_DENSITY_SHIFT; 28461da177e4SLinus Torvalds } else if (cmd_in == MTSETDRVBUFFER) 28471da177e4SLinus Torvalds STp->drv_buffer = (arg & 7); 28481da177e4SLinus Torvalds else if (cmd_in == MTSETDENSITY) 28491da177e4SLinus Torvalds STp->density = arg; 28501da177e4SLinus Torvalds 28511da177e4SLinus Torvalds if (cmd_in == MTEOM) 28521da177e4SLinus Torvalds STps->eof = ST_EOD; 28531da177e4SLinus Torvalds else if (cmd_in == MTFSF) 28541da177e4SLinus Torvalds STps->eof = ST_FM; 28551da177e4SLinus Torvalds else if (chg_eof) 28561da177e4SLinus Torvalds STps->eof = ST_NOEOF; 28571da177e4SLinus Torvalds 28581da177e4SLinus Torvalds if (cmd_in == MTWEOF) 28591da177e4SLinus Torvalds STps->rw = ST_IDLE; 28601da177e4SLinus Torvalds } else { /* SCSI command was not completely successful. Don't return 28611da177e4SLinus Torvalds from this block without releasing the SCSI command block! */ 28621da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 28631da177e4SLinus Torvalds 28641da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_EOM) { 28651da177e4SLinus Torvalds if (cmd_in != MTBSF && cmd_in != MTBSFM && 28661da177e4SLinus Torvalds cmd_in != MTBSR && cmd_in != MTBSS) 28671da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 28681da177e4SLinus Torvalds STps->drv_block = 0; 28691da177e4SLinus Torvalds } 28701da177e4SLinus Torvalds 28711da177e4SLinus Torvalds if (cmdstatp->remainder_valid) 28721da177e4SLinus Torvalds undone = (int)cmdstatp->uremainder64; 28731da177e4SLinus Torvalds else 28741da177e4SLinus Torvalds undone = 0; 28751da177e4SLinus Torvalds 28761da177e4SLinus Torvalds if (cmd_in == MTWEOF && 28771da177e4SLinus Torvalds cmdstatp->have_sense && 287891614c05SKai Makisara (cmdstatp->flags & SENSE_EOM)) { 287991614c05SKai Makisara if (cmdstatp->sense_hdr.sense_key == NO_SENSE || 288091614c05SKai Makisara cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) { 288191614c05SKai Makisara ioctl_result = 0; /* EOF(s) written successfully at EOM */ 28821da177e4SLinus Torvalds STps->eof = ST_NOEOF; 288391614c05SKai Makisara } else { /* Writing EOF(s) failed */ 288491614c05SKai Makisara if (fileno >= 0) 288591614c05SKai Makisara fileno -= undone; 288691614c05SKai Makisara if (undone < arg) 288791614c05SKai Makisara STps->eof = ST_NOEOF; 288891614c05SKai Makisara } 288991614c05SKai Makisara STps->drv_file = fileno; 28901da177e4SLinus Torvalds } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) { 28911da177e4SLinus Torvalds if (fileno >= 0) 28921da177e4SLinus Torvalds STps->drv_file = fileno - undone; 28931da177e4SLinus Torvalds else 28941da177e4SLinus Torvalds STps->drv_file = fileno; 28951da177e4SLinus Torvalds STps->drv_block = -1; 28961da177e4SLinus Torvalds STps->eof = ST_NOEOF; 28971da177e4SLinus Torvalds } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) { 28981da177e4SLinus Torvalds if (arg > 0 && undone < 0) /* Some drives get this wrong */ 28991da177e4SLinus Torvalds undone = (-undone); 29001da177e4SLinus Torvalds if (STps->drv_file >= 0) 29011da177e4SLinus Torvalds STps->drv_file = fileno + undone; 29021da177e4SLinus Torvalds STps->drv_block = 0; 29031da177e4SLinus Torvalds STps->eof = ST_NOEOF; 29041da177e4SLinus Torvalds } else if (cmd_in == MTFSR) { 29051da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */ 29061da177e4SLinus Torvalds if (STps->drv_file >= 0) 29071da177e4SLinus Torvalds STps->drv_file++; 29081da177e4SLinus Torvalds STps->drv_block = 0; 29091da177e4SLinus Torvalds STps->eof = ST_FM; 29101da177e4SLinus Torvalds } else { 29111da177e4SLinus Torvalds if (blkno >= undone) 29121da177e4SLinus Torvalds STps->drv_block = blkno - undone; 29131da177e4SLinus Torvalds else 29141da177e4SLinus Torvalds STps->drv_block = (-1); 29151da177e4SLinus Torvalds STps->eof = ST_NOEOF; 29161da177e4SLinus Torvalds } 29171da177e4SLinus Torvalds } else if (cmd_in == MTBSR) { 29181da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */ 29191da177e4SLinus Torvalds STps->drv_file--; 29201da177e4SLinus Torvalds STps->drv_block = (-1); 29211da177e4SLinus Torvalds } else { 29221da177e4SLinus Torvalds if (arg > 0 && undone < 0) /* Some drives get this wrong */ 29231da177e4SLinus Torvalds undone = (-undone); 29241da177e4SLinus Torvalds if (STps->drv_block >= 0) 29251da177e4SLinus Torvalds STps->drv_block = blkno + undone; 29261da177e4SLinus Torvalds } 29271da177e4SLinus Torvalds STps->eof = ST_NOEOF; 29281da177e4SLinus Torvalds } else if (cmd_in == MTEOM) { 29291da177e4SLinus Torvalds STps->drv_file = (-1); 29301da177e4SLinus Torvalds STps->drv_block = (-1); 29311da177e4SLinus Torvalds STps->eof = ST_EOD; 29321da177e4SLinus Torvalds } else if (cmd_in == MTSETBLK || 29331da177e4SLinus Torvalds cmd_in == MTSETDENSITY || 29341da177e4SLinus Torvalds cmd_in == MTSETDRVBUFFER || 29351da177e4SLinus Torvalds cmd_in == SET_DENS_AND_BLK) { 29361da177e4SLinus Torvalds if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST && 29371da177e4SLinus Torvalds !(STp->use_pf & PF_TESTED)) { 29381da177e4SLinus Torvalds /* Try the other possible state of Page Format if not 29391da177e4SLinus Torvalds already tried */ 29401da177e4SLinus Torvalds STp->use_pf = !STp->use_pf | PF_TESTED; 29418b05b773SMike Christie st_release_request(SRpnt); 29421da177e4SLinus Torvalds SRpnt = NULL; 29431da177e4SLinus Torvalds return st_int_ioctl(STp, cmd_in, arg); 29441da177e4SLinus Torvalds } 29451da177e4SLinus Torvalds } else if (chg_eof) 29461da177e4SLinus Torvalds STps->eof = ST_NOEOF; 29471da177e4SLinus Torvalds 29481da177e4SLinus Torvalds if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK) 29491da177e4SLinus Torvalds STps->eof = ST_EOD; 29501da177e4SLinus Torvalds 29518b05b773SMike Christie st_release_request(SRpnt); 29521da177e4SLinus Torvalds SRpnt = NULL; 29531da177e4SLinus Torvalds } 29541da177e4SLinus Torvalds 29551da177e4SLinus Torvalds return ioctl_result; 29561da177e4SLinus Torvalds } 29571da177e4SLinus Torvalds 29581da177e4SLinus Torvalds 29591da177e4SLinus Torvalds /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc 29601da177e4SLinus Torvalds structure. */ 29611da177e4SLinus Torvalds 29621da177e4SLinus Torvalds static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition, 29631da177e4SLinus Torvalds int logical) 29641da177e4SLinus Torvalds { 29651da177e4SLinus Torvalds int result; 29661da177e4SLinus Torvalds unsigned char scmd[MAX_COMMAND_SIZE]; 29678b05b773SMike Christie struct st_request *SRpnt; 29681da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 29691da177e4SLinus Torvalds 29701da177e4SLinus Torvalds if (STp->ready != ST_READY) 29711da177e4SLinus Torvalds return (-EIO); 29721da177e4SLinus Torvalds 29731da177e4SLinus Torvalds memset(scmd, 0, MAX_COMMAND_SIZE); 29741da177e4SLinus Torvalds if ((STp->device)->scsi_level < SCSI_2) { 29751da177e4SLinus Torvalds scmd[0] = QFA_REQUEST_BLOCK; 29761da177e4SLinus Torvalds scmd[4] = 3; 29771da177e4SLinus Torvalds } else { 29781da177e4SLinus Torvalds scmd[0] = READ_POSITION; 29791da177e4SLinus Torvalds if (!logical && !STp->scsi2_logical) 29801da177e4SLinus Torvalds scmd[1] = 1; 29811da177e4SLinus Torvalds } 29821da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE, 2983a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 2984a02488edSJames Bottomley MAX_READY_RETRIES, 1); 29851da177e4SLinus Torvalds if (!SRpnt) 29861da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 29871da177e4SLinus Torvalds 29881da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0 || 29891da177e4SLinus Torvalds (STp->device->scsi_level >= SCSI_2 && 29901da177e4SLinus Torvalds ((STp->buffer)->b_data[0] & 4) != 0)) { 29911da177e4SLinus Torvalds *block = *partition = 0; 29921da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name)); 29931da177e4SLinus Torvalds result = (-EIO); 29941da177e4SLinus Torvalds } else { 29951da177e4SLinus Torvalds result = 0; 29961da177e4SLinus Torvalds if ((STp->device)->scsi_level < SCSI_2) { 29971da177e4SLinus Torvalds *block = ((STp->buffer)->b_data[0] << 16) 29981da177e4SLinus Torvalds + ((STp->buffer)->b_data[1] << 8) 29991da177e4SLinus Torvalds + (STp->buffer)->b_data[2]; 30001da177e4SLinus Torvalds *partition = 0; 30011da177e4SLinus Torvalds } else { 30021da177e4SLinus Torvalds *block = ((STp->buffer)->b_data[4] << 24) 30031da177e4SLinus Torvalds + ((STp->buffer)->b_data[5] << 16) 30041da177e4SLinus Torvalds + ((STp->buffer)->b_data[6] << 8) 30051da177e4SLinus Torvalds + (STp->buffer)->b_data[7]; 30061da177e4SLinus Torvalds *partition = (STp->buffer)->b_data[1]; 30071da177e4SLinus Torvalds if (((STp->buffer)->b_data[0] & 0x80) && 30081da177e4SLinus Torvalds (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */ 30091da177e4SLinus Torvalds STp->ps[0].drv_block = STp->ps[0].drv_file = 0; 30101da177e4SLinus Torvalds } 30111da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name, 30121da177e4SLinus Torvalds *block, *partition)); 30131da177e4SLinus Torvalds } 30148b05b773SMike Christie st_release_request(SRpnt); 30151da177e4SLinus Torvalds SRpnt = NULL; 30161da177e4SLinus Torvalds 30171da177e4SLinus Torvalds return result; 30181da177e4SLinus Torvalds } 30191da177e4SLinus Torvalds 30201da177e4SLinus Torvalds 30211da177e4SLinus Torvalds /* Set the tape block and partition. Negative partition means that only the 30221da177e4SLinus Torvalds block should be set in vendor specific way. */ 30231da177e4SLinus Torvalds static int set_location(struct scsi_tape *STp, unsigned int block, int partition, 30241da177e4SLinus Torvalds int logical) 30251da177e4SLinus Torvalds { 30261da177e4SLinus Torvalds struct st_partstat *STps; 30271da177e4SLinus Torvalds int result, p; 30281da177e4SLinus Torvalds unsigned int blk; 30291da177e4SLinus Torvalds int timeout; 30301da177e4SLinus Torvalds unsigned char scmd[MAX_COMMAND_SIZE]; 30318b05b773SMike Christie struct st_request *SRpnt; 30321da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 30331da177e4SLinus Torvalds 30341da177e4SLinus Torvalds if (STp->ready != ST_READY) 30351da177e4SLinus Torvalds return (-EIO); 30361da177e4SLinus Torvalds timeout = STp->long_timeout; 30371da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 30381da177e4SLinus Torvalds 30391da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n", 30401da177e4SLinus Torvalds name, block, partition)); 30411da177e4SLinus Torvalds DEB(if (partition < 0) 30421da177e4SLinus Torvalds return (-EIO); ) 30431da177e4SLinus Torvalds 30441da177e4SLinus Torvalds /* Update the location at the partition we are leaving */ 30451da177e4SLinus Torvalds if ((!STp->can_partitions && partition != 0) || 30461da177e4SLinus Torvalds partition >= ST_NBR_PARTITIONS) 30471da177e4SLinus Torvalds return (-EINVAL); 30481da177e4SLinus Torvalds if (partition != STp->partition) { 30491da177e4SLinus Torvalds if (get_location(STp, &blk, &p, 1)) 30501da177e4SLinus Torvalds STps->last_block_valid = 0; 30511da177e4SLinus Torvalds else { 30521da177e4SLinus Torvalds STps->last_block_valid = 1; 30531da177e4SLinus Torvalds STps->last_block_visited = blk; 30541da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 30551da177e4SLinus Torvalds "%s: Visited block %d for partition %d saved.\n", 30561da177e4SLinus Torvalds name, blk, STp->partition)); 30571da177e4SLinus Torvalds } 30581da177e4SLinus Torvalds } 30591da177e4SLinus Torvalds 30601da177e4SLinus Torvalds memset(scmd, 0, MAX_COMMAND_SIZE); 30611da177e4SLinus Torvalds if ((STp->device)->scsi_level < SCSI_2) { 30621da177e4SLinus Torvalds scmd[0] = QFA_SEEK_BLOCK; 30631da177e4SLinus Torvalds scmd[2] = (block >> 16); 30641da177e4SLinus Torvalds scmd[3] = (block >> 8); 30651da177e4SLinus Torvalds scmd[4] = block; 30661da177e4SLinus Torvalds scmd[5] = 0; 30671da177e4SLinus Torvalds } else { 30681da177e4SLinus Torvalds scmd[0] = SEEK_10; 30691da177e4SLinus Torvalds scmd[3] = (block >> 24); 30701da177e4SLinus Torvalds scmd[4] = (block >> 16); 30711da177e4SLinus Torvalds scmd[5] = (block >> 8); 30721da177e4SLinus Torvalds scmd[6] = block; 30731da177e4SLinus Torvalds if (!logical && !STp->scsi2_logical) 30741da177e4SLinus Torvalds scmd[1] = 4; 30751da177e4SLinus Torvalds if (STp->partition != partition) { 30761da177e4SLinus Torvalds scmd[1] |= 2; 30771da177e4SLinus Torvalds scmd[8] = partition; 30781da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 30791da177e4SLinus Torvalds "%s: Trying to change partition from %d to %d\n", 30801da177e4SLinus Torvalds name, STp->partition, partition)); 30811da177e4SLinus Torvalds } 30821da177e4SLinus Torvalds } 30831da177e4SLinus Torvalds if (STp->immediate) { 30841da177e4SLinus Torvalds scmd[1] |= 1; /* Don't wait for completion */ 3085a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 30861da177e4SLinus Torvalds } 30871da177e4SLinus Torvalds 30881da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE, 30891da177e4SLinus Torvalds timeout, MAX_READY_RETRIES, 1); 30901da177e4SLinus Torvalds if (!SRpnt) 30911da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 30921da177e4SLinus Torvalds 30931da177e4SLinus Torvalds STps->drv_block = STps->drv_file = (-1); 30941da177e4SLinus Torvalds STps->eof = ST_NOEOF; 30951da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0) { 30961da177e4SLinus Torvalds result = (-EIO); 30971da177e4SLinus Torvalds if (STp->can_partitions && 30981da177e4SLinus Torvalds (STp->device)->scsi_level >= SCSI_2 && 30991da177e4SLinus Torvalds (p = find_partition(STp)) >= 0) 31001da177e4SLinus Torvalds STp->partition = p; 31011da177e4SLinus Torvalds } else { 31021da177e4SLinus Torvalds if (STp->can_partitions) { 31031da177e4SLinus Torvalds STp->partition = partition; 31041da177e4SLinus Torvalds STps = &(STp->ps[partition]); 31051da177e4SLinus Torvalds if (!STps->last_block_valid || 31061da177e4SLinus Torvalds STps->last_block_visited != block) { 31071da177e4SLinus Torvalds STps->at_sm = 0; 31081da177e4SLinus Torvalds STps->rw = ST_IDLE; 31091da177e4SLinus Torvalds } 31101da177e4SLinus Torvalds } else 31111da177e4SLinus Torvalds STps->at_sm = 0; 31121da177e4SLinus Torvalds if (block == 0) 31131da177e4SLinus Torvalds STps->drv_block = STps->drv_file = 0; 31141da177e4SLinus Torvalds result = 0; 31151da177e4SLinus Torvalds } 31161da177e4SLinus Torvalds 31178b05b773SMike Christie st_release_request(SRpnt); 31181da177e4SLinus Torvalds SRpnt = NULL; 31191da177e4SLinus Torvalds 31201da177e4SLinus Torvalds return result; 31211da177e4SLinus Torvalds } 31221da177e4SLinus Torvalds 31231da177e4SLinus Torvalds 31241da177e4SLinus Torvalds /* Find the current partition number for the drive status. Called from open and 31251da177e4SLinus Torvalds returns either partition number of negative error code. */ 31261da177e4SLinus Torvalds static int find_partition(struct scsi_tape *STp) 31271da177e4SLinus Torvalds { 31281da177e4SLinus Torvalds int i, partition; 31291da177e4SLinus Torvalds unsigned int block; 31301da177e4SLinus Torvalds 31311da177e4SLinus Torvalds if ((i = get_location(STp, &block, &partition, 1)) < 0) 31321da177e4SLinus Torvalds return i; 31331da177e4SLinus Torvalds if (partition >= ST_NBR_PARTITIONS) 31341da177e4SLinus Torvalds return (-EIO); 31351da177e4SLinus Torvalds return partition; 31361da177e4SLinus Torvalds } 31371da177e4SLinus Torvalds 31381da177e4SLinus Torvalds 31391da177e4SLinus Torvalds /* Change the partition if necessary */ 31401da177e4SLinus Torvalds static int switch_partition(struct scsi_tape *STp) 31411da177e4SLinus Torvalds { 31421da177e4SLinus Torvalds struct st_partstat *STps; 31431da177e4SLinus Torvalds 31441da177e4SLinus Torvalds if (STp->partition == STp->new_partition) 31451da177e4SLinus Torvalds return 0; 31461da177e4SLinus Torvalds STps = &(STp->ps[STp->new_partition]); 31471da177e4SLinus Torvalds if (!STps->last_block_valid) 31481da177e4SLinus Torvalds STps->last_block_visited = 0; 31491da177e4SLinus Torvalds return set_location(STp, STps->last_block_visited, STp->new_partition, 1); 31501da177e4SLinus Torvalds } 31511da177e4SLinus Torvalds 31521da177e4SLinus Torvalds /* Functions for reading and writing the medium partition mode page. */ 31531da177e4SLinus Torvalds 31541da177e4SLinus Torvalds #define PART_PAGE 0x11 31551da177e4SLinus Torvalds #define PART_PAGE_FIXED_LENGTH 8 31561da177e4SLinus Torvalds 31571da177e4SLinus Torvalds #define PP_OFF_MAX_ADD_PARTS 2 31581da177e4SLinus Torvalds #define PP_OFF_NBR_ADD_PARTS 3 31591da177e4SLinus Torvalds #define PP_OFF_FLAGS 4 31601da177e4SLinus Torvalds #define PP_OFF_PART_UNITS 6 31611da177e4SLinus Torvalds #define PP_OFF_RESERVED 7 31621da177e4SLinus Torvalds 31631da177e4SLinus Torvalds #define PP_BIT_IDP 0x20 31641da177e4SLinus Torvalds #define PP_MSK_PSUM_MB 0x10 31651da177e4SLinus Torvalds 31661da177e4SLinus Torvalds /* Get the number of partitions on the tape. As a side effect reads the 31671da177e4SLinus Torvalds mode page into the tape buffer. */ 31681da177e4SLinus Torvalds static int nbr_partitions(struct scsi_tape *STp) 31691da177e4SLinus Torvalds { 31701da177e4SLinus Torvalds int result; 31711da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 31721da177e4SLinus Torvalds 31731da177e4SLinus Torvalds if (STp->ready != ST_READY) 31741da177e4SLinus Torvalds return (-EIO); 31751da177e4SLinus Torvalds 31761da177e4SLinus Torvalds result = read_mode_page(STp, PART_PAGE, 1); 31771da177e4SLinus Torvalds 31781da177e4SLinus Torvalds if (result) { 31791da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n", 31801da177e4SLinus Torvalds name)); 31811da177e4SLinus Torvalds result = (-EIO); 31821da177e4SLinus Torvalds } else { 31831da177e4SLinus Torvalds result = (STp->buffer)->b_data[MODE_HEADER_LENGTH + 31841da177e4SLinus Torvalds PP_OFF_NBR_ADD_PARTS] + 1; 31851da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result)); 31861da177e4SLinus Torvalds } 31871da177e4SLinus Torvalds 31881da177e4SLinus Torvalds return result; 31891da177e4SLinus Torvalds } 31901da177e4SLinus Torvalds 31911da177e4SLinus Torvalds 31921da177e4SLinus Torvalds /* Partition the tape into two partitions if size > 0 or one partition if 31931da177e4SLinus Torvalds size == 0. 31941da177e4SLinus Torvalds 31951da177e4SLinus Torvalds The block descriptors are read and written because Sony SDT-7000 does not 31961da177e4SLinus Torvalds work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>). 31971da177e4SLinus Torvalds 31981da177e4SLinus Torvalds My HP C1533A drive returns only one partition size field. This is used to 31991da177e4SLinus Torvalds set the size of partition 1. There is no size field for the default partition. 32001da177e4SLinus Torvalds Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is 32011da177e4SLinus Torvalds used to set the size of partition 1 (this is what the SCSI-3 standard specifies). 32021da177e4SLinus Torvalds The following algorithm is used to accommodate both drives: if the number of 32031da177e4SLinus Torvalds partition size fields is greater than the maximum number of additional partitions 32041da177e4SLinus Torvalds in the mode page, the second field is used. Otherwise the first field is used. 32051da177e4SLinus Torvalds 32061da177e4SLinus Torvalds For Seagate DDS drives the page length must be 8 when no partitions is defined 32071da177e4SLinus Torvalds and 10 when 1 partition is defined (information from Eric Lee Green). This is 32081da177e4SLinus Torvalds is acceptable also to some other old drives and enforced if the first partition 32091da177e4SLinus Torvalds size field is used for the first additional partition size. 32101da177e4SLinus Torvalds */ 32111da177e4SLinus Torvalds static int partition_tape(struct scsi_tape *STp, int size) 32121da177e4SLinus Torvalds { 32131da177e4SLinus Torvalds char *name = tape_name(STp); 32141da177e4SLinus Torvalds int result; 32151da177e4SLinus Torvalds int pgo, psd_cnt, psdo; 32161da177e4SLinus Torvalds unsigned char *bp; 32171da177e4SLinus Torvalds 32181da177e4SLinus Torvalds result = read_mode_page(STp, PART_PAGE, 0); 32191da177e4SLinus Torvalds if (result) { 32201da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name)); 32211da177e4SLinus Torvalds return result; 32221da177e4SLinus Torvalds } 32231da177e4SLinus Torvalds /* The mode page is in the buffer. Let's modify it and write it. */ 32241da177e4SLinus Torvalds bp = (STp->buffer)->b_data; 32251da177e4SLinus Torvalds pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH]; 32261da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n", 32271da177e4SLinus Torvalds name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2)); 32281da177e4SLinus Torvalds 32291da177e4SLinus Torvalds psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2; 32301da177e4SLinus Torvalds psdo = pgo + PART_PAGE_FIXED_LENGTH; 32311da177e4SLinus Torvalds if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) { 32321da177e4SLinus Torvalds bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */ 32331da177e4SLinus Torvalds psdo += 2; 32341da177e4SLinus Torvalds } 32351da177e4SLinus Torvalds memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2); 32361da177e4SLinus Torvalds 32371da177e4SLinus Torvalds DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name, 32381da177e4SLinus Torvalds psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS], 32391da177e4SLinus Torvalds bp[pgo + PP_OFF_NBR_ADD_PARTS])); 32401da177e4SLinus Torvalds 32411da177e4SLinus Torvalds if (size <= 0) { 32421da177e4SLinus Torvalds bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0; 32431da177e4SLinus Torvalds if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS]) 32441da177e4SLinus Torvalds bp[pgo + MP_OFF_PAGE_LENGTH] = 6; 32451da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n", 32461da177e4SLinus Torvalds name)); 32471da177e4SLinus Torvalds } else { 32481da177e4SLinus Torvalds bp[psdo] = (size >> 8) & 0xff; 32491da177e4SLinus Torvalds bp[psdo + 1] = size & 0xff; 32501da177e4SLinus Torvalds bp[pgo + 3] = 1; 32511da177e4SLinus Torvalds if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8) 32521da177e4SLinus Torvalds bp[pgo + MP_OFF_PAGE_LENGTH] = 8; 32531da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 32541da177e4SLinus Torvalds "%s: Formatting tape with two partitions (1 = %d MB).\n", 32551da177e4SLinus Torvalds name, size)); 32561da177e4SLinus Torvalds } 32571da177e4SLinus Torvalds bp[pgo + PP_OFF_PART_UNITS] = 0; 32581da177e4SLinus Torvalds bp[pgo + PP_OFF_RESERVED] = 0; 32591da177e4SLinus Torvalds bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB; 32601da177e4SLinus Torvalds 32611da177e4SLinus Torvalds result = write_mode_page(STp, PART_PAGE, 1); 32621da177e4SLinus Torvalds if (result) { 32631da177e4SLinus Torvalds printk(KERN_INFO "%s: Partitioning of tape failed.\n", name); 32641da177e4SLinus Torvalds result = (-EIO); 32651da177e4SLinus Torvalds } 32661da177e4SLinus Torvalds 32671da177e4SLinus Torvalds return result; 32681da177e4SLinus Torvalds } 32691da177e4SLinus Torvalds 32701da177e4SLinus Torvalds 32711da177e4SLinus Torvalds 32721da177e4SLinus Torvalds /* The ioctl command */ 3273fd66c1b4SKai Makisara static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) 32741da177e4SLinus Torvalds { 32751da177e4SLinus Torvalds int i, cmd_nr, cmd_type, bt; 32761da177e4SLinus Torvalds int retval = 0; 32771da177e4SLinus Torvalds unsigned int blk; 32781da177e4SLinus Torvalds struct scsi_tape *STp = file->private_data; 32791da177e4SLinus Torvalds struct st_modedef *STm; 32801da177e4SLinus Torvalds struct st_partstat *STps; 32811da177e4SLinus Torvalds char *name = tape_name(STp); 32821da177e4SLinus Torvalds void __user *p = (void __user *)arg; 32831da177e4SLinus Torvalds 328428f85009SMatthias Kaehlcke if (mutex_lock_interruptible(&STp->lock)) 32851da177e4SLinus Torvalds return -ERESTARTSYS; 32861da177e4SLinus Torvalds 32871da177e4SLinus Torvalds DEB( 32881da177e4SLinus Torvalds if (debugging && !STp->in_use) { 32891da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Incorrect device.\n", name); 32901da177e4SLinus Torvalds retval = (-EIO); 32911da177e4SLinus Torvalds goto out; 32921da177e4SLinus Torvalds } ) /* end DEB */ 32931da177e4SLinus Torvalds 32941da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 32951da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 32961da177e4SLinus Torvalds 32971da177e4SLinus Torvalds /* 32981da177e4SLinus Torvalds * If we are in the middle of error recovery, don't let anyone 32991da177e4SLinus Torvalds * else try and use this device. Also, if error recovery fails, it 33001da177e4SLinus Torvalds * may try and take the device offline, in which case all further 33011da177e4SLinus Torvalds * access to the device is prohibited. 33021da177e4SLinus Torvalds */ 330383ff6fe8SAl Viro retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p, 330483ff6fe8SAl Viro file->f_flags & O_NDELAY); 33051da177e4SLinus Torvalds if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV) 33061da177e4SLinus Torvalds goto out; 33071da177e4SLinus Torvalds retval = 0; 33081da177e4SLinus Torvalds 33091da177e4SLinus Torvalds cmd_type = _IOC_TYPE(cmd_in); 33101da177e4SLinus Torvalds cmd_nr = _IOC_NR(cmd_in); 33111da177e4SLinus Torvalds 33121da177e4SLinus Torvalds if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) { 33131da177e4SLinus Torvalds struct mtop mtc; 33141da177e4SLinus Torvalds 33151da177e4SLinus Torvalds if (_IOC_SIZE(cmd_in) != sizeof(mtc)) { 33161da177e4SLinus Torvalds retval = (-EINVAL); 33171da177e4SLinus Torvalds goto out; 33181da177e4SLinus Torvalds } 33191da177e4SLinus Torvalds 33201da177e4SLinus Torvalds i = copy_from_user(&mtc, p, sizeof(struct mtop)); 33211da177e4SLinus Torvalds if (i) { 33221da177e4SLinus Torvalds retval = (-EFAULT); 33231da177e4SLinus Torvalds goto out; 33241da177e4SLinus Torvalds } 33251da177e4SLinus Torvalds 33261da177e4SLinus Torvalds if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) { 33271da177e4SLinus Torvalds printk(KERN_WARNING 33281da177e4SLinus Torvalds "%s: MTSETDRVBUFFER only allowed for root.\n", name); 33291da177e4SLinus Torvalds retval = (-EPERM); 33301da177e4SLinus Torvalds goto out; 33311da177e4SLinus Torvalds } 33321da177e4SLinus Torvalds if (!STm->defined && 33331da177e4SLinus Torvalds (mtc.mt_op != MTSETDRVBUFFER && 33341da177e4SLinus Torvalds (mtc.mt_count & MT_ST_OPTIONS) == 0)) { 33351da177e4SLinus Torvalds retval = (-ENXIO); 33361da177e4SLinus Torvalds goto out; 33371da177e4SLinus Torvalds } 33381da177e4SLinus Torvalds 33391da177e4SLinus Torvalds if (!STp->pos_unknown) { 33401da177e4SLinus Torvalds 33411da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) { 33421da177e4SLinus Torvalds if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 33431da177e4SLinus Torvalds mtc.mt_op == MTEOM) { 33441da177e4SLinus Torvalds mtc.mt_count -= 1; 33451da177e4SLinus Torvalds if (STps->drv_file >= 0) 33461da177e4SLinus Torvalds STps->drv_file += 1; 33471da177e4SLinus Torvalds } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) { 33481da177e4SLinus Torvalds mtc.mt_count += 1; 33491da177e4SLinus Torvalds if (STps->drv_file >= 0) 33501da177e4SLinus Torvalds STps->drv_file += 1; 33511da177e4SLinus Torvalds } 33521da177e4SLinus Torvalds } 33531da177e4SLinus Torvalds 33541da177e4SLinus Torvalds if (mtc.mt_op == MTSEEK) { 33551da177e4SLinus Torvalds /* Old position must be restored if partition will be 33561da177e4SLinus Torvalds changed */ 33571da177e4SLinus Torvalds i = !STp->can_partitions || 33581da177e4SLinus Torvalds (STp->new_partition != STp->partition); 33591da177e4SLinus Torvalds } else { 33601da177e4SLinus Torvalds i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 33611da177e4SLinus Torvalds mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM || 33621da177e4SLinus Torvalds mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD || 33631da177e4SLinus Torvalds mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 33641da177e4SLinus Torvalds mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM || 33651da177e4SLinus Torvalds mtc.mt_op == MTCOMPRESSION; 33661da177e4SLinus Torvalds } 33671da177e4SLinus Torvalds i = flush_buffer(STp, i); 33681da177e4SLinus Torvalds if (i < 0) { 33691da177e4SLinus Torvalds retval = i; 33701da177e4SLinus Torvalds goto out; 33711da177e4SLinus Torvalds } 33721da177e4SLinus Torvalds if (STps->rw == ST_WRITING && 33731da177e4SLinus Torvalds (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 33741da177e4SLinus Torvalds mtc.mt_op == MTSEEK || 33751da177e4SLinus Torvalds mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) { 33761da177e4SLinus Torvalds i = st_int_ioctl(STp, MTWEOF, 1); 33771da177e4SLinus Torvalds if (i < 0) { 33781da177e4SLinus Torvalds retval = i; 33791da177e4SLinus Torvalds goto out; 33801da177e4SLinus Torvalds } 33811da177e4SLinus Torvalds if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) 33821da177e4SLinus Torvalds mtc.mt_count++; 33831da177e4SLinus Torvalds STps->rw = ST_IDLE; 33841da177e4SLinus Torvalds } 33851da177e4SLinus Torvalds 33861da177e4SLinus Torvalds } else { 33871da177e4SLinus Torvalds /* 33881da177e4SLinus Torvalds * If there was a bus reset, block further access 33891da177e4SLinus Torvalds * to this device. If the user wants to rewind the tape, 33901da177e4SLinus Torvalds * then reset the flag and allow access again. 33911da177e4SLinus Torvalds */ 33921da177e4SLinus Torvalds if (mtc.mt_op != MTREW && 33931da177e4SLinus Torvalds mtc.mt_op != MTOFFL && 33941da177e4SLinus Torvalds mtc.mt_op != MTRETEN && 33951da177e4SLinus Torvalds mtc.mt_op != MTERASE && 33961da177e4SLinus Torvalds mtc.mt_op != MTSEEK && 33971da177e4SLinus Torvalds mtc.mt_op != MTEOM) { 33981da177e4SLinus Torvalds retval = (-EIO); 33991da177e4SLinus Torvalds goto out; 34001da177e4SLinus Torvalds } 34011da177e4SLinus Torvalds reset_state(STp); 34021da177e4SLinus Torvalds /* remove this when the midlevel properly clears was_reset */ 34031da177e4SLinus Torvalds STp->device->was_reset = 0; 34041da177e4SLinus Torvalds } 34051da177e4SLinus Torvalds 34061da177e4SLinus Torvalds if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK && 34071da177e4SLinus Torvalds mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM && 34081da177e4SLinus Torvalds mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART) 34091da177e4SLinus Torvalds STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */ 34101da177e4SLinus Torvalds 34111da177e4SLinus Torvalds if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED) 34121da177e4SLinus Torvalds do_door_lock(STp, 0); /* Ignore result! */ 34131da177e4SLinus Torvalds 34141da177e4SLinus Torvalds if (mtc.mt_op == MTSETDRVBUFFER && 34151da177e4SLinus Torvalds (mtc.mt_count & MT_ST_OPTIONS) != 0) { 34161da177e4SLinus Torvalds retval = st_set_options(STp, mtc.mt_count); 34171da177e4SLinus Torvalds goto out; 34181da177e4SLinus Torvalds } 34191da177e4SLinus Torvalds 34201da177e4SLinus Torvalds if (mtc.mt_op == MTSETPART) { 34211da177e4SLinus Torvalds if (!STp->can_partitions || 34221da177e4SLinus Torvalds mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) { 34231da177e4SLinus Torvalds retval = (-EINVAL); 34241da177e4SLinus Torvalds goto out; 34251da177e4SLinus Torvalds } 34261da177e4SLinus Torvalds if (mtc.mt_count >= STp->nbr_partitions && 34271da177e4SLinus Torvalds (STp->nbr_partitions = nbr_partitions(STp)) < 0) { 34281da177e4SLinus Torvalds retval = (-EIO); 34291da177e4SLinus Torvalds goto out; 34301da177e4SLinus Torvalds } 34311da177e4SLinus Torvalds if (mtc.mt_count >= STp->nbr_partitions) { 34321da177e4SLinus Torvalds retval = (-EINVAL); 34331da177e4SLinus Torvalds goto out; 34341da177e4SLinus Torvalds } 34351da177e4SLinus Torvalds STp->new_partition = mtc.mt_count; 34361da177e4SLinus Torvalds retval = 0; 34371da177e4SLinus Torvalds goto out; 34381da177e4SLinus Torvalds } 34391da177e4SLinus Torvalds 34401da177e4SLinus Torvalds if (mtc.mt_op == MTMKPART) { 34411da177e4SLinus Torvalds if (!STp->can_partitions) { 34421da177e4SLinus Torvalds retval = (-EINVAL); 34431da177e4SLinus Torvalds goto out; 34441da177e4SLinus Torvalds } 34451da177e4SLinus Torvalds if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 || 34461da177e4SLinus Torvalds (i = partition_tape(STp, mtc.mt_count)) < 0) { 34471da177e4SLinus Torvalds retval = i; 34481da177e4SLinus Torvalds goto out; 34491da177e4SLinus Torvalds } 34501da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 34511da177e4SLinus Torvalds STp->ps[i].rw = ST_IDLE; 34521da177e4SLinus Torvalds STp->ps[i].at_sm = 0; 34531da177e4SLinus Torvalds STp->ps[i].last_block_valid = 0; 34541da177e4SLinus Torvalds } 34551da177e4SLinus Torvalds STp->partition = STp->new_partition = 0; 34561da177e4SLinus Torvalds STp->nbr_partitions = 1; /* Bad guess ?-) */ 34571da177e4SLinus Torvalds STps->drv_block = STps->drv_file = 0; 34581da177e4SLinus Torvalds retval = 0; 34591da177e4SLinus Torvalds goto out; 34601da177e4SLinus Torvalds } 34611da177e4SLinus Torvalds 34621da177e4SLinus Torvalds if (mtc.mt_op == MTSEEK) { 34631da177e4SLinus Torvalds i = set_location(STp, mtc.mt_count, STp->new_partition, 0); 34641da177e4SLinus Torvalds if (!STp->can_partitions) 34651da177e4SLinus Torvalds STp->ps[0].rw = ST_IDLE; 34661da177e4SLinus Torvalds retval = i; 34671da177e4SLinus Torvalds goto out; 34681da177e4SLinus Torvalds } 34691da177e4SLinus Torvalds 34701da177e4SLinus Torvalds if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) { 34711da177e4SLinus Torvalds retval = do_load_unload(STp, file, 0); 34721da177e4SLinus Torvalds goto out; 34731da177e4SLinus Torvalds } 34741da177e4SLinus Torvalds 34751da177e4SLinus Torvalds if (mtc.mt_op == MTLOAD) { 34761da177e4SLinus Torvalds retval = do_load_unload(STp, file, max(1, mtc.mt_count)); 34771da177e4SLinus Torvalds goto out; 34781da177e4SLinus Torvalds } 34791da177e4SLinus Torvalds 34801da177e4SLinus Torvalds if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) { 34811da177e4SLinus Torvalds retval = do_door_lock(STp, (mtc.mt_op == MTLOCK)); 34821da177e4SLinus Torvalds goto out; 34831da177e4SLinus Torvalds } 34841da177e4SLinus Torvalds 34851da177e4SLinus Torvalds if (STp->can_partitions && STp->ready == ST_READY && 34861da177e4SLinus Torvalds (i = switch_partition(STp)) < 0) { 34871da177e4SLinus Torvalds retval = i; 34881da177e4SLinus Torvalds goto out; 34891da177e4SLinus Torvalds } 34901da177e4SLinus Torvalds 34911da177e4SLinus Torvalds if (mtc.mt_op == MTCOMPRESSION) 34921da177e4SLinus Torvalds retval = st_compression(STp, (mtc.mt_count & 1)); 34931da177e4SLinus Torvalds else 34941da177e4SLinus Torvalds retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count); 34951da177e4SLinus Torvalds goto out; 34961da177e4SLinus Torvalds } 34971da177e4SLinus Torvalds if (!STm->defined) { 34981da177e4SLinus Torvalds retval = (-ENXIO); 34991da177e4SLinus Torvalds goto out; 35001da177e4SLinus Torvalds } 35011da177e4SLinus Torvalds 35021da177e4SLinus Torvalds if ((i = flush_buffer(STp, 0)) < 0) { 35031da177e4SLinus Torvalds retval = i; 35041da177e4SLinus Torvalds goto out; 35051da177e4SLinus Torvalds } 35061da177e4SLinus Torvalds if (STp->can_partitions && 35071da177e4SLinus Torvalds (i = switch_partition(STp)) < 0) { 35081da177e4SLinus Torvalds retval = i; 35091da177e4SLinus Torvalds goto out; 35101da177e4SLinus Torvalds } 35111da177e4SLinus Torvalds 35121da177e4SLinus Torvalds if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) { 35131da177e4SLinus Torvalds struct mtget mt_status; 35141da177e4SLinus Torvalds 35151da177e4SLinus Torvalds if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) { 35161da177e4SLinus Torvalds retval = (-EINVAL); 35171da177e4SLinus Torvalds goto out; 35181da177e4SLinus Torvalds } 35191da177e4SLinus Torvalds 35201da177e4SLinus Torvalds mt_status.mt_type = STp->tape_type; 35211da177e4SLinus Torvalds mt_status.mt_dsreg = 35221da177e4SLinus Torvalds ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) | 35231da177e4SLinus Torvalds ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK); 35241da177e4SLinus Torvalds mt_status.mt_blkno = STps->drv_block; 35251da177e4SLinus Torvalds mt_status.mt_fileno = STps->drv_file; 35261da177e4SLinus Torvalds if (STp->block_size != 0) { 35271da177e4SLinus Torvalds if (STps->rw == ST_WRITING) 35281da177e4SLinus Torvalds mt_status.mt_blkno += 35291da177e4SLinus Torvalds (STp->buffer)->buffer_bytes / STp->block_size; 35301da177e4SLinus Torvalds else if (STps->rw == ST_READING) 35311da177e4SLinus Torvalds mt_status.mt_blkno -= 35321da177e4SLinus Torvalds ((STp->buffer)->buffer_bytes + 35331da177e4SLinus Torvalds STp->block_size - 1) / STp->block_size; 35341da177e4SLinus Torvalds } 35351da177e4SLinus Torvalds 35361da177e4SLinus Torvalds mt_status.mt_gstat = 0; 35371da177e4SLinus Torvalds if (STp->drv_write_prot) 35381da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff); 35391da177e4SLinus Torvalds if (mt_status.mt_blkno == 0) { 35401da177e4SLinus Torvalds if (mt_status.mt_fileno == 0) 35411da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_BOT(0xffffffff); 35421da177e4SLinus Torvalds else 35431da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_EOF(0xffffffff); 35441da177e4SLinus Torvalds } 35451da177e4SLinus Torvalds mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT); 35461da177e4SLinus Torvalds mt_status.mt_resid = STp->partition; 35471da177e4SLinus Torvalds if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR) 35481da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_EOT(0xffffffff); 35491da177e4SLinus Torvalds else if (STps->eof >= ST_EOM_OK) 35501da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_EOD(0xffffffff); 35511da177e4SLinus Torvalds if (STp->density == 1) 35521da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_D_800(0xffffffff); 35531da177e4SLinus Torvalds else if (STp->density == 2) 35541da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_D_1600(0xffffffff); 35551da177e4SLinus Torvalds else if (STp->density == 3) 35561da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_D_6250(0xffffffff); 35571da177e4SLinus Torvalds if (STp->ready == ST_READY) 35581da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_ONLINE(0xffffffff); 35591da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 35601da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff); 35611da177e4SLinus Torvalds if (STps->at_sm) 35621da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_SM(0xffffffff); 35631da177e4SLinus Torvalds if (STm->do_async_writes || 35641da177e4SLinus Torvalds (STm->do_buffer_writes && STp->block_size != 0) || 35651da177e4SLinus Torvalds STp->drv_buffer != 0) 35661da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff); 35671da177e4SLinus Torvalds if (STp->cleaning_req) 35681da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_CLN(0xffffffff); 35691da177e4SLinus Torvalds 35701da177e4SLinus Torvalds i = copy_to_user(p, &mt_status, sizeof(struct mtget)); 35711da177e4SLinus Torvalds if (i) { 35721da177e4SLinus Torvalds retval = (-EFAULT); 35731da177e4SLinus Torvalds goto out; 35741da177e4SLinus Torvalds } 35751da177e4SLinus Torvalds 35761da177e4SLinus Torvalds STp->recover_reg = 0; /* Clear after read */ 35771da177e4SLinus Torvalds retval = 0; 35781da177e4SLinus Torvalds goto out; 35791da177e4SLinus Torvalds } /* End of MTIOCGET */ 35801da177e4SLinus Torvalds if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) { 35811da177e4SLinus Torvalds struct mtpos mt_pos; 35821da177e4SLinus Torvalds if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) { 35831da177e4SLinus Torvalds retval = (-EINVAL); 35841da177e4SLinus Torvalds goto out; 35851da177e4SLinus Torvalds } 35861da177e4SLinus Torvalds if ((i = get_location(STp, &blk, &bt, 0)) < 0) { 35871da177e4SLinus Torvalds retval = i; 35881da177e4SLinus Torvalds goto out; 35891da177e4SLinus Torvalds } 35901da177e4SLinus Torvalds mt_pos.mt_blkno = blk; 35911da177e4SLinus Torvalds i = copy_to_user(p, &mt_pos, sizeof(struct mtpos)); 35921da177e4SLinus Torvalds if (i) 35931da177e4SLinus Torvalds retval = (-EFAULT); 35941da177e4SLinus Torvalds goto out; 35951da177e4SLinus Torvalds } 359628f85009SMatthias Kaehlcke mutex_unlock(&STp->lock); 35971da177e4SLinus Torvalds switch (cmd_in) { 35981da177e4SLinus Torvalds case SCSI_IOCTL_GET_IDLUN: 35991da177e4SLinus Torvalds case SCSI_IOCTL_GET_BUS_NUMBER: 36001da177e4SLinus Torvalds break; 36011da177e4SLinus Torvalds default: 360216c4b3e2SKai Makisara if ((cmd_in == SG_IO || 360316c4b3e2SKai Makisara cmd_in == SCSI_IOCTL_SEND_COMMAND || 360416c4b3e2SKai Makisara cmd_in == CDROM_SEND_PACKET) && 360516c4b3e2SKai Makisara !capable(CAP_SYS_RAWIO)) 36061da177e4SLinus Torvalds i = -EPERM; 36071da177e4SLinus Torvalds else 360874f3c8afSAl Viro i = scsi_cmd_ioctl(STp->disk->queue, STp->disk, 360974f3c8afSAl Viro file->f_mode, cmd_in, p); 36101da177e4SLinus Torvalds if (i != -ENOTTY) 36111da177e4SLinus Torvalds return i; 36121da177e4SLinus Torvalds break; 36131da177e4SLinus Torvalds } 361416c4b3e2SKai Makisara retval = scsi_ioctl(STp->device, cmd_in, p); 361516c4b3e2SKai Makisara if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */ 361616c4b3e2SKai Makisara STp->rew_at_close = 0; 361716c4b3e2SKai Makisara STp->ready = ST_NO_TAPE; 361816c4b3e2SKai Makisara } 361916c4b3e2SKai Makisara return retval; 36201da177e4SLinus Torvalds 36211da177e4SLinus Torvalds out: 362228f85009SMatthias Kaehlcke mutex_unlock(&STp->lock); 36231da177e4SLinus Torvalds return retval; 36241da177e4SLinus Torvalds } 36251da177e4SLinus Torvalds 36261da177e4SLinus Torvalds #ifdef CONFIG_COMPAT 36271da177e4SLinus Torvalds static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 36281da177e4SLinus Torvalds { 36291da177e4SLinus Torvalds struct scsi_tape *STp = file->private_data; 36301da177e4SLinus Torvalds struct scsi_device *sdev = STp->device; 36311da177e4SLinus Torvalds int ret = -ENOIOCTLCMD; 36321da177e4SLinus Torvalds if (sdev->host->hostt->compat_ioctl) { 36331da177e4SLinus Torvalds 36341da177e4SLinus Torvalds ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg); 36351da177e4SLinus Torvalds 36361da177e4SLinus Torvalds } 36371da177e4SLinus Torvalds return ret; 36381da177e4SLinus Torvalds } 36391da177e4SLinus Torvalds #endif 36401da177e4SLinus Torvalds 36411da177e4SLinus Torvalds 36421da177e4SLinus Torvalds 36431da177e4SLinus Torvalds /* Try to allocate a new tape buffer. Calling function must not hold 36441da177e4SLinus Torvalds dev_arr_lock. */ 36451da177e4SLinus Torvalds static struct st_buffer * 36461da177e4SLinus Torvalds new_tape_buffer(int from_initialization, int need_dma, int max_sg) 36471da177e4SLinus Torvalds { 36488b05b773SMike Christie int i, got = 0; 3649c53033f6SAl Viro gfp_t priority; 36501da177e4SLinus Torvalds struct st_buffer *tb; 36511da177e4SLinus Torvalds 36521da177e4SLinus Torvalds if (from_initialization) 36531da177e4SLinus Torvalds priority = GFP_ATOMIC; 36541da177e4SLinus Torvalds else 36551da177e4SLinus Torvalds priority = GFP_KERNEL; 36561da177e4SLinus Torvalds 36571da177e4SLinus Torvalds i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) + 36581da177e4SLinus Torvalds max_sg * sizeof(struct st_buf_fragment); 365924669f75SJes Sorensen tb = kzalloc(i, priority); 36601da177e4SLinus Torvalds if (!tb) { 36611da177e4SLinus Torvalds printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n"); 36621da177e4SLinus Torvalds return NULL; 36631da177e4SLinus Torvalds } 36648b05b773SMike Christie tb->frp_segs = tb->orig_frp_segs = 0; 36651da177e4SLinus Torvalds tb->use_sg = max_sg; 36661da177e4SLinus Torvalds tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg); 36671da177e4SLinus Torvalds 36681da177e4SLinus Torvalds tb->dma = need_dma; 36691da177e4SLinus Torvalds tb->buffer_size = got; 3670cd81621cSFUJITA Tomonori sg_init_table(tb->sg, max_sg); 36711da177e4SLinus Torvalds 36721da177e4SLinus Torvalds return tb; 36731da177e4SLinus Torvalds } 36741da177e4SLinus Torvalds 36751da177e4SLinus Torvalds 36761da177e4SLinus Torvalds /* Try to allocate enough space in the tape buffer */ 36771da177e4SLinus Torvalds static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma) 36781da177e4SLinus Torvalds { 3679c53033f6SAl Viro int segs, nbr, max_segs, b_size, order, got; 3680c53033f6SAl Viro gfp_t priority; 36811da177e4SLinus Torvalds 36821da177e4SLinus Torvalds if (new_size <= STbuffer->buffer_size) 36831da177e4SLinus Torvalds return 1; 36841da177e4SLinus Torvalds 36851da177e4SLinus Torvalds if (STbuffer->buffer_size <= PAGE_SIZE) 36861da177e4SLinus Torvalds normalize_buffer(STbuffer); /* Avoid extra segment */ 36871da177e4SLinus Torvalds 36881da177e4SLinus Torvalds max_segs = STbuffer->use_sg; 36891da177e4SLinus Torvalds nbr = max_segs - STbuffer->frp_segs; 36901da177e4SLinus Torvalds if (nbr <= 0) 36911da177e4SLinus Torvalds return 0; 36921da177e4SLinus Torvalds 36931da177e4SLinus Torvalds priority = GFP_KERNEL | __GFP_NOWARN; 36941da177e4SLinus Torvalds if (need_dma) 36951da177e4SLinus Torvalds priority |= GFP_DMA; 36968b05b773SMike Christie for (b_size = PAGE_SIZE, order=0; order <= 6 && 36971da177e4SLinus Torvalds b_size < new_size - STbuffer->buffer_size; 36981da177e4SLinus Torvalds order++, b_size *= 2) 36991da177e4SLinus Torvalds ; /* empty */ 37001da177e4SLinus Torvalds 37011da177e4SLinus Torvalds for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size; 37021da177e4SLinus Torvalds segs < max_segs && got < new_size;) { 37031da177e4SLinus Torvalds STbuffer->frp[segs].page = alloc_pages(priority, order); 37041da177e4SLinus Torvalds if (STbuffer->frp[segs].page == NULL) { 37051da177e4SLinus Torvalds if (new_size - got <= (max_segs - segs) * b_size / 2) { 37061da177e4SLinus Torvalds b_size /= 2; /* Large enough for the rest of the buffers */ 37071da177e4SLinus Torvalds order--; 37081da177e4SLinus Torvalds continue; 37091da177e4SLinus Torvalds } 37101da177e4SLinus Torvalds DEB(STbuffer->buffer_size = got); 37111da177e4SLinus Torvalds normalize_buffer(STbuffer); 37121da177e4SLinus Torvalds return 0; 37131da177e4SLinus Torvalds } 37141da177e4SLinus Torvalds STbuffer->frp[segs].length = b_size; 37151da177e4SLinus Torvalds STbuffer->frp_segs += 1; 37161da177e4SLinus Torvalds got += b_size; 37171da177e4SLinus Torvalds STbuffer->buffer_size = got; 371840f6b36cSKai Makisara if (STbuffer->cleared) 371940f6b36cSKai Makisara memset(page_address(STbuffer->frp[segs].page), 0, b_size); 37201da177e4SLinus Torvalds segs++; 37211da177e4SLinus Torvalds } 37221da177e4SLinus Torvalds STbuffer->b_data = page_address(STbuffer->frp[0].page); 37231da177e4SLinus Torvalds 37241da177e4SLinus Torvalds return 1; 37251da177e4SLinus Torvalds } 37261da177e4SLinus Torvalds 37271da177e4SLinus Torvalds 372840f6b36cSKai Makisara /* Make sure that no data from previous user is in the internal buffer */ 372940f6b36cSKai Makisara static void clear_buffer(struct st_buffer * st_bp) 373040f6b36cSKai Makisara { 373140f6b36cSKai Makisara int i; 373240f6b36cSKai Makisara 373340f6b36cSKai Makisara for (i=0; i < st_bp->frp_segs; i++) 373440f6b36cSKai Makisara memset(page_address(st_bp->frp[i].page), 0, st_bp->frp[i].length); 373540f6b36cSKai Makisara st_bp->cleared = 1; 373640f6b36cSKai Makisara } 373740f6b36cSKai Makisara 373840f6b36cSKai Makisara 37391da177e4SLinus Torvalds /* Release the extra buffer */ 37401da177e4SLinus Torvalds static void normalize_buffer(struct st_buffer * STbuffer) 37411da177e4SLinus Torvalds { 37421da177e4SLinus Torvalds int i, order; 37431da177e4SLinus Torvalds 37441da177e4SLinus Torvalds for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) { 37451da177e4SLinus Torvalds order = get_order(STbuffer->frp[i].length); 37461da177e4SLinus Torvalds __free_pages(STbuffer->frp[i].page, order); 37471da177e4SLinus Torvalds STbuffer->buffer_size -= STbuffer->frp[i].length; 37481da177e4SLinus Torvalds } 37491da177e4SLinus Torvalds STbuffer->frp_segs = STbuffer->orig_frp_segs; 37501da177e4SLinus Torvalds STbuffer->frp_sg_current = 0; 37518b05b773SMike Christie STbuffer->sg_segs = 0; 37521da177e4SLinus Torvalds } 37531da177e4SLinus Torvalds 37541da177e4SLinus Torvalds 37551da177e4SLinus Torvalds /* Move data from the user buffer to the tape buffer. Returns zero (success) or 37561da177e4SLinus Torvalds negative error code. */ 37571da177e4SLinus Torvalds static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count) 37581da177e4SLinus Torvalds { 37591da177e4SLinus Torvalds int i, cnt, res, offset; 37601da177e4SLinus Torvalds 37611da177e4SLinus Torvalds for (i = 0, offset = st_bp->buffer_bytes; 37621da177e4SLinus Torvalds i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++) 37631da177e4SLinus Torvalds offset -= st_bp->frp[i].length; 37641da177e4SLinus Torvalds if (i == st_bp->frp_segs) { /* Should never happen */ 37651da177e4SLinus Torvalds printk(KERN_WARNING "st: append_to_buffer offset overflow.\n"); 37661da177e4SLinus Torvalds return (-EIO); 37671da177e4SLinus Torvalds } 37681da177e4SLinus Torvalds for (; i < st_bp->frp_segs && do_count > 0; i++) { 37691da177e4SLinus Torvalds cnt = st_bp->frp[i].length - offset < do_count ? 37701da177e4SLinus Torvalds st_bp->frp[i].length - offset : do_count; 37711da177e4SLinus Torvalds res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt); 37721da177e4SLinus Torvalds if (res) 37731da177e4SLinus Torvalds return (-EFAULT); 37741da177e4SLinus Torvalds do_count -= cnt; 37751da177e4SLinus Torvalds st_bp->buffer_bytes += cnt; 37761da177e4SLinus Torvalds ubp += cnt; 37771da177e4SLinus Torvalds offset = 0; 37781da177e4SLinus Torvalds } 37791da177e4SLinus Torvalds if (do_count) /* Should never happen */ 37801da177e4SLinus Torvalds return (-EIO); 37811da177e4SLinus Torvalds 37821da177e4SLinus Torvalds return 0; 37831da177e4SLinus Torvalds } 37841da177e4SLinus Torvalds 37851da177e4SLinus Torvalds 37861da177e4SLinus Torvalds /* Move data from the tape buffer to the user buffer. Returns zero (success) or 37871da177e4SLinus Torvalds negative error code. */ 37881da177e4SLinus Torvalds static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count) 37891da177e4SLinus Torvalds { 37901da177e4SLinus Torvalds int i, cnt, res, offset; 37911da177e4SLinus Torvalds 37921da177e4SLinus Torvalds for (i = 0, offset = st_bp->read_pointer; 37931da177e4SLinus Torvalds i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++) 37941da177e4SLinus Torvalds offset -= st_bp->frp[i].length; 37951da177e4SLinus Torvalds if (i == st_bp->frp_segs) { /* Should never happen */ 37961da177e4SLinus Torvalds printk(KERN_WARNING "st: from_buffer offset overflow.\n"); 37971da177e4SLinus Torvalds return (-EIO); 37981da177e4SLinus Torvalds } 37991da177e4SLinus Torvalds for (; i < st_bp->frp_segs && do_count > 0; i++) { 38001da177e4SLinus Torvalds cnt = st_bp->frp[i].length - offset < do_count ? 38011da177e4SLinus Torvalds st_bp->frp[i].length - offset : do_count; 38021da177e4SLinus Torvalds res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt); 38031da177e4SLinus Torvalds if (res) 38041da177e4SLinus Torvalds return (-EFAULT); 38051da177e4SLinus Torvalds do_count -= cnt; 38061da177e4SLinus Torvalds st_bp->buffer_bytes -= cnt; 38071da177e4SLinus Torvalds st_bp->read_pointer += cnt; 38081da177e4SLinus Torvalds ubp += cnt; 38091da177e4SLinus Torvalds offset = 0; 38101da177e4SLinus Torvalds } 38111da177e4SLinus Torvalds if (do_count) /* Should never happen */ 38121da177e4SLinus Torvalds return (-EIO); 38131da177e4SLinus Torvalds 38141da177e4SLinus Torvalds return 0; 38151da177e4SLinus Torvalds } 38161da177e4SLinus Torvalds 38171da177e4SLinus Torvalds 38181da177e4SLinus Torvalds /* Move data towards start of buffer */ 38191da177e4SLinus Torvalds static void move_buffer_data(struct st_buffer * st_bp, int offset) 38201da177e4SLinus Torvalds { 38211da177e4SLinus Torvalds int src_seg, dst_seg, src_offset = 0, dst_offset; 38221da177e4SLinus Torvalds int count, total; 38231da177e4SLinus Torvalds 38241da177e4SLinus Torvalds if (offset == 0) 38251da177e4SLinus Torvalds return; 38261da177e4SLinus Torvalds 38271da177e4SLinus Torvalds total=st_bp->buffer_bytes - offset; 38281da177e4SLinus Torvalds for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) { 38291da177e4SLinus Torvalds src_offset = offset; 38301da177e4SLinus Torvalds if (src_offset < st_bp->frp[src_seg].length) 38311da177e4SLinus Torvalds break; 38321da177e4SLinus Torvalds offset -= st_bp->frp[src_seg].length; 38331da177e4SLinus Torvalds } 38341da177e4SLinus Torvalds 38351da177e4SLinus Torvalds st_bp->buffer_bytes = st_bp->read_pointer = total; 38361da177e4SLinus Torvalds for (dst_seg=dst_offset=0; total > 0; ) { 38371da177e4SLinus Torvalds count = min(st_bp->frp[dst_seg].length - dst_offset, 38381da177e4SLinus Torvalds st_bp->frp[src_seg].length - src_offset); 38391da177e4SLinus Torvalds memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset, 38401da177e4SLinus Torvalds page_address(st_bp->frp[src_seg].page) + src_offset, count); 38411da177e4SLinus Torvalds src_offset += count; 38421da177e4SLinus Torvalds if (src_offset >= st_bp->frp[src_seg].length) { 38431da177e4SLinus Torvalds src_seg++; 38441da177e4SLinus Torvalds src_offset = 0; 38451da177e4SLinus Torvalds } 38461da177e4SLinus Torvalds dst_offset += count; 38471da177e4SLinus Torvalds if (dst_offset >= st_bp->frp[dst_seg].length) { 38481da177e4SLinus Torvalds dst_seg++; 38491da177e4SLinus Torvalds dst_offset = 0; 38501da177e4SLinus Torvalds } 38511da177e4SLinus Torvalds total -= count; 38521da177e4SLinus Torvalds } 38531da177e4SLinus Torvalds } 38541da177e4SLinus Torvalds 38551da177e4SLinus Torvalds 38561da177e4SLinus Torvalds /* Fill the s/g list up to the length required for this transfer */ 38571da177e4SLinus Torvalds static void buf_to_sg(struct st_buffer *STbp, unsigned int length) 38581da177e4SLinus Torvalds { 38591da177e4SLinus Torvalds int i; 38601da177e4SLinus Torvalds unsigned int count; 38611da177e4SLinus Torvalds struct scatterlist *sg; 38621da177e4SLinus Torvalds struct st_buf_fragment *frp; 38631da177e4SLinus Torvalds 38641da177e4SLinus Torvalds if (length == STbp->frp_sg_current) 38651da177e4SLinus Torvalds return; /* work already done */ 38661da177e4SLinus Torvalds 38671da177e4SLinus Torvalds sg = &(STbp->sg[0]); 38681da177e4SLinus Torvalds frp = STbp->frp; 38691da177e4SLinus Torvalds for (i=count=0; count < length; i++) { 38701da177e4SLinus Torvalds if (length - count > frp[i].length) 3871642f1490SJens Axboe sg_set_page(&sg[i], frp[i].page, frp[i].length, 0); 38721da177e4SLinus Torvalds else 3873642f1490SJens Axboe sg_set_page(&sg[i], frp[i].page, length - count, 0); 38741da177e4SLinus Torvalds count += sg[i].length; 38751da177e4SLinus Torvalds } 38761da177e4SLinus Torvalds STbp->sg_segs = i; 38771da177e4SLinus Torvalds STbp->frp_sg_current = length; 38781da177e4SLinus Torvalds } 38791da177e4SLinus Torvalds 38801da177e4SLinus Torvalds 38811da177e4SLinus Torvalds /* Validate the options from command line or module parameters */ 38821da177e4SLinus Torvalds static void validate_options(void) 38831da177e4SLinus Torvalds { 38841da177e4SLinus Torvalds if (buffer_kbs > 0) 38851da177e4SLinus Torvalds st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE; 38861da177e4SLinus Torvalds if (max_sg_segs >= ST_FIRST_SG) 38871da177e4SLinus Torvalds st_max_sg_segs = max_sg_segs; 38881da177e4SLinus Torvalds } 38891da177e4SLinus Torvalds 38901da177e4SLinus Torvalds #ifndef MODULE 38911da177e4SLinus Torvalds /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt. 38921da177e4SLinus Torvalds */ 38931da177e4SLinus Torvalds static int __init st_setup(char *str) 38941da177e4SLinus Torvalds { 38951da177e4SLinus Torvalds int i, len, ints[5]; 38961da177e4SLinus Torvalds char *stp; 38971da177e4SLinus Torvalds 38981da177e4SLinus Torvalds stp = get_options(str, ARRAY_SIZE(ints), ints); 38991da177e4SLinus Torvalds 39001da177e4SLinus Torvalds if (ints[0] > 0) { 39011da177e4SLinus Torvalds for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++) 39021da177e4SLinus Torvalds if (parms[i].val) 39031da177e4SLinus Torvalds *parms[i].val = ints[i + 1]; 39041da177e4SLinus Torvalds } else { 39051da177e4SLinus Torvalds while (stp != NULL) { 39061da177e4SLinus Torvalds for (i = 0; i < ARRAY_SIZE(parms); i++) { 39071da177e4SLinus Torvalds len = strlen(parms[i].name); 39081da177e4SLinus Torvalds if (!strncmp(stp, parms[i].name, len) && 39091da177e4SLinus Torvalds (*(stp + len) == ':' || *(stp + len) == '=')) { 39101da177e4SLinus Torvalds if (parms[i].val) 39111da177e4SLinus Torvalds *parms[i].val = 39121da177e4SLinus Torvalds simple_strtoul(stp + len + 1, NULL, 0); 39131da177e4SLinus Torvalds else 39141da177e4SLinus Torvalds printk(KERN_WARNING "st: Obsolete parameter %s\n", 39151da177e4SLinus Torvalds parms[i].name); 39161da177e4SLinus Torvalds break; 39171da177e4SLinus Torvalds } 39181da177e4SLinus Torvalds } 39196391a113STobias Klauser if (i >= ARRAY_SIZE(parms)) 39201da177e4SLinus Torvalds printk(KERN_WARNING "st: invalid parameter in '%s'\n", 39211da177e4SLinus Torvalds stp); 39221da177e4SLinus Torvalds stp = strchr(stp, ','); 39231da177e4SLinus Torvalds if (stp) 39241da177e4SLinus Torvalds stp++; 39251da177e4SLinus Torvalds } 39261da177e4SLinus Torvalds } 39271da177e4SLinus Torvalds 39281da177e4SLinus Torvalds validate_options(); 39291da177e4SLinus Torvalds 39301da177e4SLinus Torvalds return 1; 39311da177e4SLinus Torvalds } 39321da177e4SLinus Torvalds 39331da177e4SLinus Torvalds __setup("st=", st_setup); 39341da177e4SLinus Torvalds 39351da177e4SLinus Torvalds #endif 39361da177e4SLinus Torvalds 393700977a59SArjan van de Ven static const struct file_operations st_fops = 39381da177e4SLinus Torvalds { 39391da177e4SLinus Torvalds .owner = THIS_MODULE, 39401da177e4SLinus Torvalds .read = st_read, 39411da177e4SLinus Torvalds .write = st_write, 3942fd66c1b4SKai Makisara .unlocked_ioctl = st_ioctl, 39431da177e4SLinus Torvalds #ifdef CONFIG_COMPAT 39441da177e4SLinus Torvalds .compat_ioctl = st_compat_ioctl, 39451da177e4SLinus Torvalds #endif 39461da177e4SLinus Torvalds .open = st_open, 39471da177e4SLinus Torvalds .flush = st_flush, 39481da177e4SLinus Torvalds .release = st_release, 39491da177e4SLinus Torvalds }; 39501da177e4SLinus Torvalds 39511da177e4SLinus Torvalds static int st_probe(struct device *dev) 39521da177e4SLinus Torvalds { 39531da177e4SLinus Torvalds struct scsi_device *SDp = to_scsi_device(dev); 39541da177e4SLinus Torvalds struct gendisk *disk = NULL; 39551da177e4SLinus Torvalds struct cdev *cdev = NULL; 39561da177e4SLinus Torvalds struct scsi_tape *tpnt = NULL; 39571da177e4SLinus Torvalds struct st_modedef *STm; 39581da177e4SLinus Torvalds struct st_partstat *STps; 39591da177e4SLinus Torvalds struct st_buffer *buffer; 39601da177e4SLinus Torvalds int i, j, mode, dev_num, error; 39611da177e4SLinus Torvalds char *stp; 39621da177e4SLinus Torvalds 39631da177e4SLinus Torvalds if (SDp->type != TYPE_TAPE) 39641da177e4SLinus Torvalds return -ENODEV; 39651da177e4SLinus Torvalds if ((stp = st_incompatible(SDp))) { 39663bf743e7SJeff Garzik sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n"); 39671da177e4SLinus Torvalds printk(KERN_INFO "st: The suggested driver is %s.\n", stp); 39681da177e4SLinus Torvalds return -ENODEV; 39691da177e4SLinus Torvalds } 39701da177e4SLinus Torvalds 39718b05b773SMike Christie i = min(SDp->request_queue->max_hw_segments, 39728b05b773SMike Christie SDp->request_queue->max_phys_segments); 39731da177e4SLinus Torvalds if (st_max_sg_segs < i) 39741da177e4SLinus Torvalds i = st_max_sg_segs; 39751da177e4SLinus Torvalds buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i); 39761da177e4SLinus Torvalds if (buffer == NULL) { 39771da177e4SLinus Torvalds printk(KERN_ERR 39781da177e4SLinus Torvalds "st: Can't allocate new tape buffer. Device not attached.\n"); 39791da177e4SLinus Torvalds goto out; 39801da177e4SLinus Torvalds } 39811da177e4SLinus Torvalds 39821da177e4SLinus Torvalds disk = alloc_disk(1); 39831da177e4SLinus Torvalds if (!disk) { 39841da177e4SLinus Torvalds printk(KERN_ERR "st: out of memory. Device not attached.\n"); 39851da177e4SLinus Torvalds goto out_buffer_free; 39861da177e4SLinus Torvalds } 39871da177e4SLinus Torvalds 39881da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 39891da177e4SLinus Torvalds if (st_nr_dev >= st_dev_max) { 39901da177e4SLinus Torvalds struct scsi_tape **tmp_da; 39911da177e4SLinus Torvalds int tmp_dev_max; 39921da177e4SLinus Torvalds 39931da177e4SLinus Torvalds tmp_dev_max = max(st_nr_dev * 2, 8); 39941da177e4SLinus Torvalds if (tmp_dev_max > ST_MAX_TAPES) 39951da177e4SLinus Torvalds tmp_dev_max = ST_MAX_TAPES; 39961da177e4SLinus Torvalds if (tmp_dev_max <= st_nr_dev) { 39971da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 39981da177e4SLinus Torvalds printk(KERN_ERR "st: Too many tape devices (max. %d).\n", 39991da177e4SLinus Torvalds ST_MAX_TAPES); 40001da177e4SLinus Torvalds goto out_put_disk; 40011da177e4SLinus Torvalds } 40021da177e4SLinus Torvalds 400324669f75SJes Sorensen tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC); 40041da177e4SLinus Torvalds if (tmp_da == NULL) { 40051da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 40061da177e4SLinus Torvalds printk(KERN_ERR "st: Can't extend device array.\n"); 40071da177e4SLinus Torvalds goto out_put_disk; 40081da177e4SLinus Torvalds } 40091da177e4SLinus Torvalds 40101da177e4SLinus Torvalds if (scsi_tapes != NULL) { 40111da177e4SLinus Torvalds memcpy(tmp_da, scsi_tapes, 40121da177e4SLinus Torvalds st_dev_max * sizeof(struct scsi_tape *)); 40131da177e4SLinus Torvalds kfree(scsi_tapes); 40141da177e4SLinus Torvalds } 40151da177e4SLinus Torvalds scsi_tapes = tmp_da; 40161da177e4SLinus Torvalds 40171da177e4SLinus Torvalds st_dev_max = tmp_dev_max; 40181da177e4SLinus Torvalds } 40191da177e4SLinus Torvalds 40201da177e4SLinus Torvalds for (i = 0; i < st_dev_max; i++) 40211da177e4SLinus Torvalds if (scsi_tapes[i] == NULL) 40221da177e4SLinus Torvalds break; 40231da177e4SLinus Torvalds if (i >= st_dev_max) 40241da177e4SLinus Torvalds panic("scsi_devices corrupt (st)"); 40251da177e4SLinus Torvalds 402624669f75SJes Sorensen tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC); 40271da177e4SLinus Torvalds if (tpnt == NULL) { 40281da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 40291da177e4SLinus Torvalds printk(KERN_ERR "st: Can't allocate device descriptor.\n"); 40301da177e4SLinus Torvalds goto out_put_disk; 40311da177e4SLinus Torvalds } 4032f03a5670SKai Makisara kref_init(&tpnt->kref); 40331da177e4SLinus Torvalds tpnt->disk = disk; 40341da177e4SLinus Torvalds sprintf(disk->disk_name, "st%d", i); 40351da177e4SLinus Torvalds disk->private_data = &tpnt->driver; 40361da177e4SLinus Torvalds disk->queue = SDp->request_queue; 40371da177e4SLinus Torvalds tpnt->driver = &st_template; 40381da177e4SLinus Torvalds scsi_tapes[i] = tpnt; 40391da177e4SLinus Torvalds dev_num = i; 40401da177e4SLinus Torvalds 40411da177e4SLinus Torvalds tpnt->device = SDp; 40421da177e4SLinus Torvalds if (SDp->scsi_level <= 2) 40431da177e4SLinus Torvalds tpnt->tape_type = MT_ISSCSI1; 40441da177e4SLinus Torvalds else 40451da177e4SLinus Torvalds tpnt->tape_type = MT_ISSCSI2; 40461da177e4SLinus Torvalds 40471da177e4SLinus Torvalds tpnt->buffer = buffer; 4048f03a5670SKai Makisara tpnt->buffer->last_SRpnt = NULL; 40491da177e4SLinus Torvalds 40501da177e4SLinus Torvalds tpnt->inited = 0; 40511da177e4SLinus Torvalds tpnt->dirty = 0; 40521da177e4SLinus Torvalds tpnt->in_use = 0; 40531da177e4SLinus Torvalds tpnt->drv_buffer = 1; /* Try buffering if no mode sense */ 40541da177e4SLinus Torvalds tpnt->restr_dma = (SDp->host)->unchecked_isa_dma; 40551da177e4SLinus Torvalds tpnt->use_pf = (SDp->scsi_level >= SCSI_2); 40561da177e4SLinus Torvalds tpnt->density = 0; 40571da177e4SLinus Torvalds tpnt->do_auto_lock = ST_AUTO_LOCK; 40581da177e4SLinus Torvalds tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */ 40591da177e4SLinus Torvalds tpnt->can_partitions = 0; 40601da177e4SLinus Torvalds tpnt->two_fm = ST_TWO_FM; 40611da177e4SLinus Torvalds tpnt->fast_mteom = ST_FAST_MTEOM; 40621da177e4SLinus Torvalds tpnt->scsi2_logical = ST_SCSI2LOGICAL; 406340f6b36cSKai Makisara tpnt->sili = ST_SILI; 40641da177e4SLinus Torvalds tpnt->immediate = ST_NOWAIT; 40651da177e4SLinus Torvalds tpnt->default_drvbuffer = 0xff; /* No forced buffering */ 40661da177e4SLinus Torvalds tpnt->partition = 0; 40671da177e4SLinus Torvalds tpnt->new_partition = 0; 40681da177e4SLinus Torvalds tpnt->nbr_partitions = 0; 4069a02488edSJames Bottomley blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT); 40701da177e4SLinus Torvalds tpnt->long_timeout = ST_LONG_TIMEOUT; 40711da177e4SLinus Torvalds tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma; 40721da177e4SLinus Torvalds 40731da177e4SLinus Torvalds for (i = 0; i < ST_NBR_MODES; i++) { 40741da177e4SLinus Torvalds STm = &(tpnt->modes[i]); 40751da177e4SLinus Torvalds STm->defined = 0; 40761da177e4SLinus Torvalds STm->sysv = ST_SYSV; 40771da177e4SLinus Torvalds STm->defaults_for_writes = 0; 40781da177e4SLinus Torvalds STm->do_async_writes = ST_ASYNC_WRITES; 40791da177e4SLinus Torvalds STm->do_buffer_writes = ST_BUFFER_WRITES; 40801da177e4SLinus Torvalds STm->do_read_ahead = ST_READ_AHEAD; 40811da177e4SLinus Torvalds STm->default_compression = ST_DONT_TOUCH; 40821da177e4SLinus Torvalds STm->default_blksize = (-1); /* No forced size */ 40831da177e4SLinus Torvalds STm->default_density = (-1); /* No forced density */ 40841da177e4SLinus Torvalds } 40851da177e4SLinus Torvalds 40861da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 40871da177e4SLinus Torvalds STps = &(tpnt->ps[i]); 40881da177e4SLinus Torvalds STps->rw = ST_IDLE; 40891da177e4SLinus Torvalds STps->eof = ST_NOEOF; 40901da177e4SLinus Torvalds STps->at_sm = 0; 40911da177e4SLinus Torvalds STps->last_block_valid = 0; 40921da177e4SLinus Torvalds STps->drv_block = (-1); 40931da177e4SLinus Torvalds STps->drv_file = (-1); 40941da177e4SLinus Torvalds } 40951da177e4SLinus Torvalds 40961da177e4SLinus Torvalds tpnt->current_mode = 0; 40971da177e4SLinus Torvalds tpnt->modes[0].defined = 1; 40981da177e4SLinus Torvalds 40991da177e4SLinus Torvalds tpnt->density_changed = tpnt->compression_changed = 41001da177e4SLinus Torvalds tpnt->blksize_changed = 0; 410128f85009SMatthias Kaehlcke mutex_init(&tpnt->lock); 41021da177e4SLinus Torvalds 41031da177e4SLinus Torvalds st_nr_dev++; 41041da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 41051da177e4SLinus Torvalds 41061da177e4SLinus Torvalds for (mode = 0; mode < ST_NBR_MODES; ++mode) { 41071da177e4SLinus Torvalds STm = &(tpnt->modes[mode]); 41081da177e4SLinus Torvalds for (j=0; j < 2; j++) { 41091da177e4SLinus Torvalds cdev = cdev_alloc(); 41101da177e4SLinus Torvalds if (!cdev) { 41111da177e4SLinus Torvalds printk(KERN_ERR 41121da177e4SLinus Torvalds "st%d: out of memory. Device not attached.\n", 41131da177e4SLinus Torvalds dev_num); 41141da177e4SLinus Torvalds goto out_free_tape; 41151da177e4SLinus Torvalds } 41161da177e4SLinus Torvalds cdev->owner = THIS_MODULE; 41171da177e4SLinus Torvalds cdev->ops = &st_fops; 41181da177e4SLinus Torvalds 41191da177e4SLinus Torvalds error = cdev_add(cdev, 41201da177e4SLinus Torvalds MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)), 41211da177e4SLinus Torvalds 1); 41221da177e4SLinus Torvalds if (error) { 41231da177e4SLinus Torvalds printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n", 41241da177e4SLinus Torvalds dev_num, j ? "non" : "auto", mode); 41251da177e4SLinus Torvalds printk(KERN_ERR "st%d: Device not attached.\n", dev_num); 41261da177e4SLinus Torvalds goto out_free_tape; 41271da177e4SLinus Torvalds } 41281da177e4SLinus Torvalds STm->cdevs[j] = cdev; 41291da177e4SLinus Torvalds 41301da177e4SLinus Torvalds } 413113026a6bSJeff Garzik error = do_create_class_files(tpnt, dev_num, mode); 413213026a6bSJeff Garzik if (error) 413313026a6bSJeff Garzik goto out_free_tape; 41341da177e4SLinus Torvalds } 41351da177e4SLinus Torvalds 413642252854SKai Makisara sdev_printk(KERN_NOTICE, SDp, 41378b1ea24cSRene Herman "Attached scsi tape %s\n", tape_name(tpnt)); 413842252854SKai Makisara sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n", 41391da177e4SLinus Torvalds tape_name(tpnt), tpnt->try_dio ? "yes" : "no", 41408b05b773SMike Christie queue_dma_alignment(SDp->request_queue) + 1); 41411da177e4SLinus Torvalds 41421da177e4SLinus Torvalds return 0; 41431da177e4SLinus Torvalds 41441da177e4SLinus Torvalds out_free_tape: 41451da177e4SLinus Torvalds for (mode=0; mode < ST_NBR_MODES; mode++) { 41461da177e4SLinus Torvalds STm = &(tpnt->modes[mode]); 41471da177e4SLinus Torvalds sysfs_remove_link(&tpnt->device->sdev_gendev.kobj, 41481da177e4SLinus Torvalds "tape"); 41491da177e4SLinus Torvalds for (j=0; j < 2; j++) { 41501da177e4SLinus Torvalds if (STm->cdevs[j]) { 41511da177e4SLinus Torvalds if (cdev == STm->cdevs[j]) 41521da177e4SLinus Torvalds cdev = NULL; 4153ee959b00STony Jones device_destroy(st_sysfs_class, 4154d253878bSgregkh@suse.de MKDEV(SCSI_TAPE_MAJOR, 41551da177e4SLinus Torvalds TAPE_MINOR(i, mode, j))); 41561da177e4SLinus Torvalds cdev_del(STm->cdevs[j]); 41571da177e4SLinus Torvalds } 41581da177e4SLinus Torvalds } 41591da177e4SLinus Torvalds } 41601da177e4SLinus Torvalds if (cdev) 41611da177e4SLinus Torvalds cdev_del(cdev); 41621da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 41631da177e4SLinus Torvalds scsi_tapes[dev_num] = NULL; 41641da177e4SLinus Torvalds st_nr_dev--; 41651da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 41661da177e4SLinus Torvalds out_put_disk: 41671da177e4SLinus Torvalds put_disk(disk); 41681da177e4SLinus Torvalds kfree(tpnt); 41691da177e4SLinus Torvalds out_buffer_free: 41701da177e4SLinus Torvalds kfree(buffer); 41711da177e4SLinus Torvalds out: 41721da177e4SLinus Torvalds return -ENODEV; 41731da177e4SLinus Torvalds }; 41741da177e4SLinus Torvalds 41751da177e4SLinus Torvalds 41761da177e4SLinus Torvalds static int st_remove(struct device *dev) 41771da177e4SLinus Torvalds { 41781da177e4SLinus Torvalds struct scsi_device *SDp = to_scsi_device(dev); 41791da177e4SLinus Torvalds struct scsi_tape *tpnt; 41801da177e4SLinus Torvalds int i, j, mode; 41811da177e4SLinus Torvalds 41821da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 41831da177e4SLinus Torvalds for (i = 0; i < st_dev_max; i++) { 41841da177e4SLinus Torvalds tpnt = scsi_tapes[i]; 41851da177e4SLinus Torvalds if (tpnt != NULL && tpnt->device == SDp) { 41861da177e4SLinus Torvalds scsi_tapes[i] = NULL; 41871da177e4SLinus Torvalds st_nr_dev--; 41881da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 41891da177e4SLinus Torvalds sysfs_remove_link(&tpnt->device->sdev_gendev.kobj, 41901da177e4SLinus Torvalds "tape"); 41911da177e4SLinus Torvalds for (mode = 0; mode < ST_NBR_MODES; ++mode) { 41921da177e4SLinus Torvalds for (j=0; j < 2; j++) { 4193ee959b00STony Jones device_destroy(st_sysfs_class, 4194d253878bSgregkh@suse.de MKDEV(SCSI_TAPE_MAJOR, 41951da177e4SLinus Torvalds TAPE_MINOR(i, mode, j))); 41961da177e4SLinus Torvalds cdev_del(tpnt->modes[mode].cdevs[j]); 41971da177e4SLinus Torvalds tpnt->modes[mode].cdevs[j] = NULL; 41981da177e4SLinus Torvalds } 41991da177e4SLinus Torvalds } 4200f03a5670SKai Makisara 42010b950672SArjan van de Ven mutex_lock(&st_ref_mutex); 4202f03a5670SKai Makisara kref_put(&tpnt->kref, scsi_tape_release); 42030b950672SArjan van de Ven mutex_unlock(&st_ref_mutex); 4204f03a5670SKai Makisara return 0; 4205f03a5670SKai Makisara } 4206f03a5670SKai Makisara } 4207f03a5670SKai Makisara 4208f03a5670SKai Makisara write_unlock(&st_dev_arr_lock); 4209f03a5670SKai Makisara return 0; 4210f03a5670SKai Makisara } 4211f03a5670SKai Makisara 4212f03a5670SKai Makisara /** 4213f03a5670SKai Makisara * scsi_tape_release - Called to free the Scsi_Tape structure 4214f03a5670SKai Makisara * @kref: pointer to embedded kref 4215f03a5670SKai Makisara * 42160b950672SArjan van de Ven * st_ref_mutex must be held entering this routine. Because it is 4217f03a5670SKai Makisara * called on last put, you should always use the scsi_tape_get() 4218f03a5670SKai Makisara * scsi_tape_put() helpers which manipulate the semaphore directly 4219f03a5670SKai Makisara * and never do a direct kref_put(). 4220f03a5670SKai Makisara **/ 4221f03a5670SKai Makisara static void scsi_tape_release(struct kref *kref) 4222f03a5670SKai Makisara { 4223f03a5670SKai Makisara struct scsi_tape *tpnt = to_scsi_tape(kref); 4224f03a5670SKai Makisara struct gendisk *disk = tpnt->disk; 4225f03a5670SKai Makisara 42261da177e4SLinus Torvalds tpnt->device = NULL; 42271da177e4SLinus Torvalds 42281da177e4SLinus Torvalds if (tpnt->buffer) { 42291da177e4SLinus Torvalds tpnt->buffer->orig_frp_segs = 0; 42301da177e4SLinus Torvalds normalize_buffer(tpnt->buffer); 42311da177e4SLinus Torvalds kfree(tpnt->buffer); 42321da177e4SLinus Torvalds } 42331da177e4SLinus Torvalds 4234f03a5670SKai Makisara disk->private_data = NULL; 4235f03a5670SKai Makisara put_disk(disk); 4236f03a5670SKai Makisara kfree(tpnt); 4237f03a5670SKai Makisara return; 42381da177e4SLinus Torvalds } 42391da177e4SLinus Torvalds 42401da177e4SLinus Torvalds static int __init init_st(void) 42411da177e4SLinus Torvalds { 424213026a6bSJeff Garzik int err; 424313026a6bSJeff Garzik 42441da177e4SLinus Torvalds validate_options(); 42451da177e4SLinus Torvalds 424613026a6bSJeff Garzik printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n", 42471da177e4SLinus Torvalds verstr, st_fixed_buffer_size, st_max_sg_segs); 42481da177e4SLinus Torvalds 4249d253878bSgregkh@suse.de st_sysfs_class = class_create(THIS_MODULE, "scsi_tape"); 42501da177e4SLinus Torvalds if (IS_ERR(st_sysfs_class)) { 42511da177e4SLinus Torvalds printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n"); 425213026a6bSJeff Garzik return PTR_ERR(st_sysfs_class); 42531da177e4SLinus Torvalds } 42541da177e4SLinus Torvalds 425513026a6bSJeff Garzik err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 425613026a6bSJeff Garzik ST_MAX_TAPE_ENTRIES, "st"); 425713026a6bSJeff Garzik if (err) { 425813026a6bSJeff Garzik printk(KERN_ERR "Unable to get major %d for SCSI tapes\n", 425913026a6bSJeff Garzik SCSI_TAPE_MAJOR); 426013026a6bSJeff Garzik goto err_class; 42611da177e4SLinus Torvalds } 426213026a6bSJeff Garzik 426313026a6bSJeff Garzik err = scsi_register_driver(&st_template.gendrv); 426413026a6bSJeff Garzik if (err) 426513026a6bSJeff Garzik goto err_chrdev; 426613026a6bSJeff Garzik 4267405ae7d3SRobert P. J. Day err = do_create_sysfs_files(); 426813026a6bSJeff Garzik if (err) 426913026a6bSJeff Garzik goto err_scsidrv; 427013026a6bSJeff Garzik 427113026a6bSJeff Garzik return 0; 427213026a6bSJeff Garzik 427313026a6bSJeff Garzik err_scsidrv: 427413026a6bSJeff Garzik scsi_unregister_driver(&st_template.gendrv); 427513026a6bSJeff Garzik err_chrdev: 42761da177e4SLinus Torvalds unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 42771da177e4SLinus Torvalds ST_MAX_TAPE_ENTRIES); 427813026a6bSJeff Garzik err_class: 4279c2c96f46SKai Makisara class_destroy(st_sysfs_class); 428013026a6bSJeff Garzik return err; 42811da177e4SLinus Torvalds } 42821da177e4SLinus Torvalds 42831da177e4SLinus Torvalds static void __exit exit_st(void) 42841da177e4SLinus Torvalds { 4285405ae7d3SRobert P. J. Day do_remove_sysfs_files(); 42861da177e4SLinus Torvalds scsi_unregister_driver(&st_template.gendrv); 42871da177e4SLinus Torvalds unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 42881da177e4SLinus Torvalds ST_MAX_TAPE_ENTRIES); 4289c2c96f46SKai Makisara class_destroy(st_sysfs_class); 42901da177e4SLinus Torvalds kfree(scsi_tapes); 42911da177e4SLinus Torvalds printk(KERN_INFO "st: Unloaded.\n"); 42921da177e4SLinus Torvalds } 42931da177e4SLinus Torvalds 42941da177e4SLinus Torvalds module_init(init_st); 42951da177e4SLinus Torvalds module_exit(exit_st); 42961da177e4SLinus Torvalds 42971da177e4SLinus Torvalds 42981da177e4SLinus Torvalds /* The sysfs driver interface. Read-only at the moment */ 42991da177e4SLinus Torvalds static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf) 43001da177e4SLinus Torvalds { 43011da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io); 43021da177e4SLinus Torvalds } 43031da177e4SLinus Torvalds static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL); 43041da177e4SLinus Torvalds 43051da177e4SLinus Torvalds static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf) 43061da177e4SLinus Torvalds { 43071da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size); 43081da177e4SLinus Torvalds } 43091da177e4SLinus Torvalds static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL); 43101da177e4SLinus Torvalds 43111da177e4SLinus Torvalds static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf) 43121da177e4SLinus Torvalds { 43131da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs); 43141da177e4SLinus Torvalds } 43151da177e4SLinus Torvalds static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL); 43161da177e4SLinus Torvalds 43171da177e4SLinus Torvalds static ssize_t st_version_show(struct device_driver *ddd, char *buf) 43181da177e4SLinus Torvalds { 43191da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr); 43201da177e4SLinus Torvalds } 43211da177e4SLinus Torvalds static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL); 43221da177e4SLinus Torvalds 4323405ae7d3SRobert P. J. Day static int do_create_sysfs_files(void) 43241da177e4SLinus Torvalds { 4325405ae7d3SRobert P. J. Day struct device_driver *sysfs = &st_template.gendrv; 432613026a6bSJeff Garzik int err; 43271da177e4SLinus Torvalds 4328405ae7d3SRobert P. J. Day err = driver_create_file(sysfs, &driver_attr_try_direct_io); 432913026a6bSJeff Garzik if (err) 433013026a6bSJeff Garzik return err; 4331405ae7d3SRobert P. J. Day err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size); 433213026a6bSJeff Garzik if (err) 433313026a6bSJeff Garzik goto err_try_direct_io; 4334405ae7d3SRobert P. J. Day err = driver_create_file(sysfs, &driver_attr_max_sg_segs); 433513026a6bSJeff Garzik if (err) 433613026a6bSJeff Garzik goto err_attr_fixed_buf; 4337405ae7d3SRobert P. J. Day err = driver_create_file(sysfs, &driver_attr_version); 433813026a6bSJeff Garzik if (err) 433913026a6bSJeff Garzik goto err_attr_max_sg; 434013026a6bSJeff Garzik 434113026a6bSJeff Garzik return 0; 434213026a6bSJeff Garzik 434313026a6bSJeff Garzik err_attr_max_sg: 4344405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_max_sg_segs); 434513026a6bSJeff Garzik err_attr_fixed_buf: 4346405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_fixed_buffer_size); 434713026a6bSJeff Garzik err_try_direct_io: 4348405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_try_direct_io); 434913026a6bSJeff Garzik return err; 43501da177e4SLinus Torvalds } 43511da177e4SLinus Torvalds 4352405ae7d3SRobert P. J. Day static void do_remove_sysfs_files(void) 43531da177e4SLinus Torvalds { 4354405ae7d3SRobert P. J. Day struct device_driver *sysfs = &st_template.gendrv; 43551da177e4SLinus Torvalds 4356405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_version); 4357405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_max_sg_segs); 4358405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_fixed_buffer_size); 4359405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_try_direct_io); 43601da177e4SLinus Torvalds } 43611da177e4SLinus Torvalds 43621da177e4SLinus Torvalds 43631da177e4SLinus Torvalds /* The sysfs simple class interface */ 4364ee959b00STony Jones static ssize_t 4365ee959b00STony Jones st_defined_show(struct device *dev, struct device_attribute *attr, char *buf) 43661da177e4SLinus Torvalds { 43677d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 43681da177e4SLinus Torvalds ssize_t l = 0; 43691da177e4SLinus Torvalds 43701da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined); 43711da177e4SLinus Torvalds return l; 43721da177e4SLinus Torvalds } 43731da177e4SLinus Torvalds 4374ee959b00STony Jones DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL); 43751da177e4SLinus Torvalds 4376ee959b00STony Jones static ssize_t 4377ee959b00STony Jones st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf) 43781da177e4SLinus Torvalds { 43797d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 43801da177e4SLinus Torvalds ssize_t l = 0; 43811da177e4SLinus Torvalds 43821da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize); 43831da177e4SLinus Torvalds return l; 43841da177e4SLinus Torvalds } 43851da177e4SLinus Torvalds 4386ee959b00STony Jones DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL); 43871da177e4SLinus Torvalds 4388ee959b00STony Jones static ssize_t 4389ee959b00STony Jones st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf) 43901da177e4SLinus Torvalds { 43917d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 43921da177e4SLinus Torvalds ssize_t l = 0; 43931da177e4SLinus Torvalds char *fmt; 43941da177e4SLinus Torvalds 43951da177e4SLinus Torvalds fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n"; 43961da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density); 43971da177e4SLinus Torvalds return l; 43981da177e4SLinus Torvalds } 43991da177e4SLinus Torvalds 4400ee959b00STony Jones DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL); 44011da177e4SLinus Torvalds 4402ee959b00STony Jones static ssize_t 4403ee959b00STony Jones st_defcompression_show(struct device *dev, struct device_attribute *attr, 4404ee959b00STony Jones char *buf) 44051da177e4SLinus Torvalds { 44067d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 44071da177e4SLinus Torvalds ssize_t l = 0; 44081da177e4SLinus Torvalds 44091da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1); 44101da177e4SLinus Torvalds return l; 44111da177e4SLinus Torvalds } 44121da177e4SLinus Torvalds 4413ee959b00STony Jones DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL); 44141da177e4SLinus Torvalds 4415ee959b00STony Jones static ssize_t 4416ee959b00STony Jones st_options_show(struct device *dev, struct device_attribute *attr, char *buf) 4417b174be02SKai Makisara { 44187d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 4419b174be02SKai Makisara struct scsi_tape *STp; 4420b174be02SKai Makisara int i, j, options; 4421b174be02SKai Makisara ssize_t l = 0; 4422b174be02SKai Makisara 4423b174be02SKai Makisara for (i=0; i < st_dev_max; i++) { 4424b174be02SKai Makisara for (j=0; j < ST_NBR_MODES; j++) 4425b174be02SKai Makisara if (&scsi_tapes[i]->modes[j] == STm) 4426b174be02SKai Makisara break; 4427b174be02SKai Makisara if (j < ST_NBR_MODES) 4428b174be02SKai Makisara break; 4429b174be02SKai Makisara } 4430b174be02SKai Makisara if (i == st_dev_max) 4431b174be02SKai Makisara return 0; /* should never happen */ 4432b174be02SKai Makisara 4433b174be02SKai Makisara STp = scsi_tapes[i]; 4434b174be02SKai Makisara 4435b174be02SKai Makisara options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0; 4436b174be02SKai Makisara options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0; 4437b174be02SKai Makisara options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0; 4438b174be02SKai Makisara DEB( options |= debugging ? MT_ST_DEBUGGING : 0 ); 4439b174be02SKai Makisara options |= STp->two_fm ? MT_ST_TWO_FM : 0; 4440b174be02SKai Makisara options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0; 4441b174be02SKai Makisara options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0; 4442b174be02SKai Makisara options |= STp->can_bsr ? MT_ST_CAN_BSR : 0; 4443b174be02SKai Makisara options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0; 4444b174be02SKai Makisara options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0; 4445b174be02SKai Makisara options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0; 4446b174be02SKai Makisara options |= STm->sysv ? MT_ST_SYSV : 0; 4447b174be02SKai Makisara options |= STp->immediate ? MT_ST_NOWAIT : 0; 4448b174be02SKai Makisara options |= STp->sili ? MT_ST_SILI : 0; 4449b174be02SKai Makisara 4450b174be02SKai Makisara l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options); 4451b174be02SKai Makisara return l; 4452b174be02SKai Makisara } 4453b174be02SKai Makisara 4454ee959b00STony Jones DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL); 4455b174be02SKai Makisara 445613026a6bSJeff Garzik static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode) 44571da177e4SLinus Torvalds { 44581da177e4SLinus Torvalds int i, rew, error; 44591da177e4SLinus Torvalds char name[10]; 4460ee959b00STony Jones struct device *st_class_member; 44611da177e4SLinus Torvalds 44621da177e4SLinus Torvalds for (rew=0; rew < 2; rew++) { 44631da177e4SLinus Torvalds /* Make sure that the minor numbers corresponding to the four 44641da177e4SLinus Torvalds first modes always get the same names */ 44651da177e4SLinus Torvalds i = mode << (4 - ST_NBR_MODE_BITS); 44661da177e4SLinus Torvalds snprintf(name, 10, "%s%s%s", rew ? "n" : "", 44671da177e4SLinus Torvalds STp->disk->disk_name, st_formats[i]); 44681da177e4SLinus Torvalds st_class_member = 4469d73a1a67SGreg Kroah-Hartman device_create(st_sysfs_class, &STp->device->sdev_gendev, 44701da177e4SLinus Torvalds MKDEV(SCSI_TAPE_MAJOR, 4471d73a1a67SGreg Kroah-Hartman TAPE_MINOR(dev_num, mode, rew)), 4472d73a1a67SGreg Kroah-Hartman &STp->modes[mode], "%s", name); 44731da177e4SLinus Torvalds if (IS_ERR(st_class_member)) { 4474ee959b00STony Jones printk(KERN_WARNING "st%d: device_create failed\n", 44751da177e4SLinus Torvalds dev_num); 447613026a6bSJeff Garzik error = PTR_ERR(st_class_member); 44771da177e4SLinus Torvalds goto out; 44781da177e4SLinus Torvalds } 44791da177e4SLinus Torvalds 4480ee959b00STony Jones error = device_create_file(st_class_member, 4481ee959b00STony Jones &dev_attr_defined); 448213026a6bSJeff Garzik if (error) goto out; 4483ee959b00STony Jones error = device_create_file(st_class_member, 4484ee959b00STony Jones &dev_attr_default_blksize); 448513026a6bSJeff Garzik if (error) goto out; 4486ee959b00STony Jones error = device_create_file(st_class_member, 4487ee959b00STony Jones &dev_attr_default_density); 448813026a6bSJeff Garzik if (error) goto out; 4489ee959b00STony Jones error = device_create_file(st_class_member, 4490ee959b00STony Jones &dev_attr_default_compression); 449113026a6bSJeff Garzik if (error) goto out; 4492ee959b00STony Jones error = device_create_file(st_class_member, 4493ee959b00STony Jones &dev_attr_options); 4494b174be02SKai Makisara if (error) goto out; 449513026a6bSJeff Garzik 44961da177e4SLinus Torvalds if (mode == 0 && rew == 0) { 44971da177e4SLinus Torvalds error = sysfs_create_link(&STp->device->sdev_gendev.kobj, 44981da177e4SLinus Torvalds &st_class_member->kobj, 44991da177e4SLinus Torvalds "tape"); 45001da177e4SLinus Torvalds if (error) { 45011da177e4SLinus Torvalds printk(KERN_ERR 45021da177e4SLinus Torvalds "st%d: Can't create sysfs link from SCSI device.\n", 45031da177e4SLinus Torvalds dev_num); 450413026a6bSJeff Garzik goto out; 45051da177e4SLinus Torvalds } 45061da177e4SLinus Torvalds } 45071da177e4SLinus Torvalds } 450813026a6bSJeff Garzik 450913026a6bSJeff Garzik return 0; 451013026a6bSJeff Garzik 45111da177e4SLinus Torvalds out: 451213026a6bSJeff Garzik return error; 45131da177e4SLinus Torvalds } 45141da177e4SLinus Torvalds 45151da177e4SLinus Torvalds /* The following functions may be useful for a larger audience. */ 45161da177e4SLinus Torvalds static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages, 45171da177e4SLinus Torvalds unsigned long uaddr, size_t count, int rw) 45181da177e4SLinus Torvalds { 451907542b83SJames Bottomley unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT; 452007542b83SJames Bottomley unsigned long start = uaddr >> PAGE_SHIFT; 452107542b83SJames Bottomley const int nr_pages = end - start; 45221da177e4SLinus Torvalds int res, i, j; 45231da177e4SLinus Torvalds struct page **pages; 45241da177e4SLinus Torvalds 45251da177e4SLinus Torvalds /* User attempted Overflow! */ 45261da177e4SLinus Torvalds if ((uaddr + count) < uaddr) 45271da177e4SLinus Torvalds return -EINVAL; 45281da177e4SLinus Torvalds 45291da177e4SLinus Torvalds /* Too big */ 45301da177e4SLinus Torvalds if (nr_pages > max_pages) 45311da177e4SLinus Torvalds return -ENOMEM; 45321da177e4SLinus Torvalds 45331da177e4SLinus Torvalds /* Hmm? */ 45341da177e4SLinus Torvalds if (count == 0) 45351da177e4SLinus Torvalds return 0; 45361da177e4SLinus Torvalds 45371da177e4SLinus Torvalds if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL) 45381da177e4SLinus Torvalds return -ENOMEM; 45391da177e4SLinus Torvalds 45401da177e4SLinus Torvalds /* Try to fault in all of the necessary pages */ 45411da177e4SLinus Torvalds down_read(¤t->mm->mmap_sem); 45421da177e4SLinus Torvalds /* rw==READ means read from drive, write into memory area */ 45431da177e4SLinus Torvalds res = get_user_pages( 45441da177e4SLinus Torvalds current, 45451da177e4SLinus Torvalds current->mm, 45461da177e4SLinus Torvalds uaddr, 45471da177e4SLinus Torvalds nr_pages, 45481da177e4SLinus Torvalds rw == READ, 45491da177e4SLinus Torvalds 0, /* don't force */ 45501da177e4SLinus Torvalds pages, 45511da177e4SLinus Torvalds NULL); 45521da177e4SLinus Torvalds up_read(¤t->mm->mmap_sem); 45531da177e4SLinus Torvalds 45541da177e4SLinus Torvalds /* Errors and no page mapped should return here */ 45551da177e4SLinus Torvalds if (res < nr_pages) 45561da177e4SLinus Torvalds goto out_unmap; 45571da177e4SLinus Torvalds 45581da177e4SLinus Torvalds for (i=0; i < nr_pages; i++) { 45591da177e4SLinus Torvalds /* FIXME: flush superflous for rw==READ, 45601da177e4SLinus Torvalds * probably wrong function for rw==WRITE 45611da177e4SLinus Torvalds */ 45621da177e4SLinus Torvalds flush_dcache_page(pages[i]); 45631da177e4SLinus Torvalds } 45641da177e4SLinus Torvalds 45651da177e4SLinus Torvalds /* Populate the scatter/gather list */ 4566642f1490SJens Axboe sg_set_page(&sgl[0], pages[0], 0, uaddr & ~PAGE_MASK); 45671da177e4SLinus Torvalds if (nr_pages > 1) { 45681da177e4SLinus Torvalds sgl[0].length = PAGE_SIZE - sgl[0].offset; 45691da177e4SLinus Torvalds count -= sgl[0].length; 45701da177e4SLinus Torvalds for (i=1; i < nr_pages ; i++) { 4571642f1490SJens Axboe sg_set_page(&sgl[i], pages[i], 4572642f1490SJens Axboe count < PAGE_SIZE ? count : PAGE_SIZE, 0);; 45731da177e4SLinus Torvalds count -= PAGE_SIZE; 45741da177e4SLinus Torvalds } 45751da177e4SLinus Torvalds } 45761da177e4SLinus Torvalds else { 45771da177e4SLinus Torvalds sgl[0].length = count; 45781da177e4SLinus Torvalds } 45791da177e4SLinus Torvalds 45801da177e4SLinus Torvalds kfree(pages); 45811da177e4SLinus Torvalds return nr_pages; 45821da177e4SLinus Torvalds 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... */ 45951da177e4SLinus Torvalds static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages, 45961da177e4SLinus Torvalds int dirtied) 45971da177e4SLinus Torvalds { 45981da177e4SLinus Torvalds int i; 45991da177e4SLinus Torvalds 46001da177e4SLinus Torvalds for (i=0; i < nr_pages; i++) { 460145711f1aSJens Axboe struct page *page = sg_page(&sgl[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 } 46101da177e4SLinus Torvalds 46111da177e4SLinus Torvalds return 0; 46121da177e4SLinus Torvalds } 4613