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]; 63039ade4b1SFUJITA Tomonori int ret; 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds cmd[0] = SPACE; 6331da177e4SLinus Torvalds cmd[1] = 0x01; /* Space FileMarks */ 6341da177e4SLinus Torvalds if (forward) { 6351da177e4SLinus Torvalds cmd[2] = cmd[3] = 0; 6361da177e4SLinus Torvalds cmd[4] = 1; 6371da177e4SLinus Torvalds } else 6381da177e4SLinus Torvalds cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */ 6391da177e4SLinus Torvalds cmd[5] = 0; 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n", 6421da177e4SLinus Torvalds tape_name(STp), forward ? "forward" : "backward")); 6431da177e4SLinus Torvalds 64439ade4b1SFUJITA Tomonori SRpnt = st_allocate_request(STp); 6451da177e4SLinus Torvalds if (!SRpnt) 64639ade4b1SFUJITA Tomonori return STp->buffer->syscall_result; 6471da177e4SLinus Torvalds 64839ade4b1SFUJITA Tomonori ret = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0, 64939ade4b1SFUJITA Tomonori STp->device->request_queue->rq_timeout, 65039ade4b1SFUJITA Tomonori MAX_RETRIES); 65139ade4b1SFUJITA Tomonori if (ret) 65239ade4b1SFUJITA Tomonori goto out; 65339ade4b1SFUJITA Tomonori 65439ade4b1SFUJITA Tomonori ret = STp->buffer->syscall_result; 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds if ((STp->buffer)->cmdstat.midlevel_result != 0) 6571da177e4SLinus Torvalds printk(KERN_ERR "%s: Stepping over filemark %s failed.\n", 6581da177e4SLinus Torvalds tape_name(STp), forward ? "forward" : "backward"); 6591da177e4SLinus Torvalds 66039ade4b1SFUJITA Tomonori out: 66139ade4b1SFUJITA Tomonori st_release_request(SRpnt); 66239ade4b1SFUJITA Tomonori 66339ade4b1SFUJITA Tomonori return ret; 6641da177e4SLinus Torvalds } 6651da177e4SLinus Torvalds 6661da177e4SLinus Torvalds 6671da177e4SLinus Torvalds /* Flush the write buffer (never need to write if variable blocksize). */ 6688ef8d594SAdrian Bunk static int st_flush_write_buffer(struct scsi_tape * STp) 6691da177e4SLinus Torvalds { 670786231afSKai Makisara int transfer, blks; 6711da177e4SLinus Torvalds int result; 6721da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 6738b05b773SMike Christie struct st_request *SRpnt; 6741da177e4SLinus Torvalds struct st_partstat *STps; 6751da177e4SLinus Torvalds 6761da177e4SLinus Torvalds result = write_behind_check(STp); 6771da177e4SLinus Torvalds if (result) 6781da177e4SLinus Torvalds return result; 6791da177e4SLinus Torvalds 6801da177e4SLinus Torvalds result = 0; 6811da177e4SLinus Torvalds if (STp->dirty == 1) { 6821da177e4SLinus Torvalds 683786231afSKai Makisara transfer = STp->buffer->buffer_bytes; 6841da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n", 6851da177e4SLinus Torvalds tape_name(STp), transfer)); 6861da177e4SLinus Torvalds 6871da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 6881da177e4SLinus Torvalds cmd[0] = WRITE_6; 6891da177e4SLinus Torvalds cmd[1] = 1; 6901da177e4SLinus Torvalds blks = transfer / STp->block_size; 6911da177e4SLinus Torvalds cmd[2] = blks >> 16; 6921da177e4SLinus Torvalds cmd[3] = blks >> 8; 6931da177e4SLinus Torvalds cmd[4] = blks; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE, 696a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 697a02488edSJames Bottomley MAX_WRITE_RETRIES, 1); 6981da177e4SLinus Torvalds if (!SRpnt) 6991da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 7001da177e4SLinus Torvalds 7011da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 7021da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0) { 7031da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds if (cmdstatp->have_sense && !cmdstatp->deferred && 7061da177e4SLinus Torvalds (cmdstatp->flags & SENSE_EOM) && 7071da177e4SLinus Torvalds (cmdstatp->sense_hdr.sense_key == NO_SENSE || 7081da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) && 7091da177e4SLinus Torvalds (!cmdstatp->remainder_valid || 7101da177e4SLinus Torvalds cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */ 7111da177e4SLinus Torvalds STp->dirty = 0; 7121da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = 0; 7131da177e4SLinus Torvalds if (STps->drv_block >= 0) 7141da177e4SLinus Torvalds STps->drv_block += blks; 7151da177e4SLinus Torvalds result = (-ENOSPC); 7161da177e4SLinus Torvalds } else { 7171da177e4SLinus Torvalds printk(KERN_ERR "%s: Error on flush.\n", 7181da177e4SLinus Torvalds tape_name(STp)); 7191da177e4SLinus Torvalds STps->drv_block = (-1); 7201da177e4SLinus Torvalds result = (-EIO); 7211da177e4SLinus Torvalds } 7221da177e4SLinus Torvalds } else { 7231da177e4SLinus Torvalds if (STps->drv_block >= 0) 7241da177e4SLinus Torvalds STps->drv_block += blks; 7251da177e4SLinus Torvalds STp->dirty = 0; 7261da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = 0; 7271da177e4SLinus Torvalds } 7288b05b773SMike Christie st_release_request(SRpnt); 7291da177e4SLinus Torvalds SRpnt = NULL; 7301da177e4SLinus Torvalds } 7311da177e4SLinus Torvalds return result; 7321da177e4SLinus Torvalds } 7331da177e4SLinus Torvalds 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds /* Flush the tape buffer. The tape will be positioned correctly unless 7361da177e4SLinus Torvalds seek_next is true. */ 7371da177e4SLinus Torvalds static int flush_buffer(struct scsi_tape *STp, int seek_next) 7381da177e4SLinus Torvalds { 7391da177e4SLinus Torvalds int backspace, result; 7401da177e4SLinus Torvalds struct st_buffer *STbuffer; 7411da177e4SLinus Torvalds struct st_partstat *STps; 7421da177e4SLinus Torvalds 7431da177e4SLinus Torvalds STbuffer = STp->buffer; 7441da177e4SLinus Torvalds 7451da177e4SLinus Torvalds /* 7461da177e4SLinus Torvalds * If there was a bus reset, block further access 7471da177e4SLinus Torvalds * to this device. 7481da177e4SLinus Torvalds */ 7491da177e4SLinus Torvalds if (STp->pos_unknown) 7501da177e4SLinus Torvalds return (-EIO); 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds if (STp->ready != ST_READY) 7531da177e4SLinus Torvalds return 0; 7541da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 7551da177e4SLinus Torvalds if (STps->rw == ST_WRITING) /* Writing */ 7568ef8d594SAdrian Bunk return st_flush_write_buffer(STp); 7571da177e4SLinus Torvalds 7581da177e4SLinus Torvalds if (STp->block_size == 0) 7591da177e4SLinus Torvalds return 0; 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds backspace = ((STp->buffer)->buffer_bytes + 7621da177e4SLinus Torvalds (STp->buffer)->read_pointer) / STp->block_size - 7631da177e4SLinus Torvalds ((STp->buffer)->read_pointer + STp->block_size - 1) / 7641da177e4SLinus Torvalds STp->block_size; 7651da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = 0; 7661da177e4SLinus Torvalds (STp->buffer)->read_pointer = 0; 7671da177e4SLinus Torvalds result = 0; 7681da177e4SLinus Torvalds if (!seek_next) { 7691da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) { 7701da177e4SLinus Torvalds result = cross_eof(STp, 0); /* Back over the EOF hit */ 7711da177e4SLinus Torvalds if (!result) 7721da177e4SLinus Torvalds STps->eof = ST_NOEOF; 7731da177e4SLinus Torvalds else { 7741da177e4SLinus Torvalds if (STps->drv_file >= 0) 7751da177e4SLinus Torvalds STps->drv_file++; 7761da177e4SLinus Torvalds STps->drv_block = 0; 7771da177e4SLinus Torvalds } 7781da177e4SLinus Torvalds } 7791da177e4SLinus Torvalds if (!result && backspace > 0) 7801da177e4SLinus Torvalds result = st_int_ioctl(STp, MTBSR, backspace); 7811da177e4SLinus Torvalds } else if (STps->eof == ST_FM_HIT) { 7821da177e4SLinus Torvalds if (STps->drv_file >= 0) 7831da177e4SLinus Torvalds STps->drv_file++; 7841da177e4SLinus Torvalds STps->drv_block = 0; 7851da177e4SLinus Torvalds STps->eof = ST_NOEOF; 7861da177e4SLinus Torvalds } 7871da177e4SLinus Torvalds return result; 7881da177e4SLinus Torvalds 7891da177e4SLinus Torvalds } 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds /* Set the mode parameters */ 7921da177e4SLinus Torvalds static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm) 7931da177e4SLinus Torvalds { 7941da177e4SLinus Torvalds int set_it = 0; 7951da177e4SLinus Torvalds unsigned long arg; 7961da177e4SLinus Torvalds char *name = tape_name(STp); 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds if (!STp->density_changed && 7991da177e4SLinus Torvalds STm->default_density >= 0 && 8001da177e4SLinus Torvalds STm->default_density != STp->density) { 8011da177e4SLinus Torvalds arg = STm->default_density; 8021da177e4SLinus Torvalds set_it = 1; 8031da177e4SLinus Torvalds } else 8041da177e4SLinus Torvalds arg = STp->density; 8051da177e4SLinus Torvalds arg <<= MT_ST_DENSITY_SHIFT; 8061da177e4SLinus Torvalds if (!STp->blksize_changed && 8071da177e4SLinus Torvalds STm->default_blksize >= 0 && 8081da177e4SLinus Torvalds STm->default_blksize != STp->block_size) { 8091da177e4SLinus Torvalds arg |= STm->default_blksize; 8101da177e4SLinus Torvalds set_it = 1; 8111da177e4SLinus Torvalds } else 8121da177e4SLinus Torvalds arg |= STp->block_size; 8131da177e4SLinus Torvalds if (set_it && 8141da177e4SLinus Torvalds st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) { 8151da177e4SLinus Torvalds printk(KERN_WARNING 8161da177e4SLinus Torvalds "%s: Can't set default block size to %d bytes and density %x.\n", 8171da177e4SLinus Torvalds name, STm->default_blksize, STm->default_density); 8181da177e4SLinus Torvalds if (modes_defined) 8191da177e4SLinus Torvalds return (-EINVAL); 8201da177e4SLinus Torvalds } 8211da177e4SLinus Torvalds return 0; 8221da177e4SLinus Torvalds } 8231da177e4SLinus Torvalds 8241da177e4SLinus Torvalds 8258b05b773SMike Christie /* Lock or unlock the drive door. Don't use when st_request allocated. */ 8261da177e4SLinus Torvalds static int do_door_lock(struct scsi_tape * STp, int do_lock) 8271da177e4SLinus Torvalds { 8281da177e4SLinus Torvalds int retval, cmd; 8291da177e4SLinus Torvalds DEB(char *name = tape_name(STp);) 8301da177e4SLinus Torvalds 8311da177e4SLinus Torvalds 8321da177e4SLinus Torvalds cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK; 8331da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name, 8341da177e4SLinus Torvalds do_lock ? "L" : "Unl")); 8351da177e4SLinus Torvalds retval = scsi_ioctl(STp->device, cmd, NULL); 8361da177e4SLinus Torvalds if (!retval) { 8371da177e4SLinus Torvalds STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED; 8381da177e4SLinus Torvalds } 8391da177e4SLinus Torvalds else { 8401da177e4SLinus Torvalds STp->door_locked = ST_LOCK_FAILS; 8411da177e4SLinus Torvalds } 8421da177e4SLinus Torvalds return retval; 8431da177e4SLinus Torvalds } 8441da177e4SLinus Torvalds 8451da177e4SLinus Torvalds 8461da177e4SLinus Torvalds /* Set the internal state after reset */ 8471da177e4SLinus Torvalds static void reset_state(struct scsi_tape *STp) 8481da177e4SLinus Torvalds { 8491da177e4SLinus Torvalds int i; 8501da177e4SLinus Torvalds struct st_partstat *STps; 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds STp->pos_unknown = 0; 8531da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 8541da177e4SLinus Torvalds STps = &(STp->ps[i]); 8551da177e4SLinus Torvalds STps->rw = ST_IDLE; 8561da177e4SLinus Torvalds STps->eof = ST_NOEOF; 8571da177e4SLinus Torvalds STps->at_sm = 0; 8581da177e4SLinus Torvalds STps->last_block_valid = 0; 8591da177e4SLinus Torvalds STps->drv_block = -1; 8601da177e4SLinus Torvalds STps->drv_file = -1; 8611da177e4SLinus Torvalds } 8621da177e4SLinus Torvalds if (STp->can_partitions) { 8631da177e4SLinus Torvalds STp->partition = find_partition(STp); 8641da177e4SLinus Torvalds if (STp->partition < 0) 8651da177e4SLinus Torvalds STp->partition = 0; 8661da177e4SLinus Torvalds STp->new_partition = STp->partition; 8671da177e4SLinus Torvalds } 8681da177e4SLinus Torvalds } 8691da177e4SLinus Torvalds 8701da177e4SLinus Torvalds /* Test if the drive is ready. Returns either one of the codes below or a negative system 8711da177e4SLinus Torvalds error code. */ 8721da177e4SLinus Torvalds #define CHKRES_READY 0 8731da177e4SLinus Torvalds #define CHKRES_NEW_SESSION 1 8741da177e4SLinus Torvalds #define CHKRES_NOT_READY 2 8751da177e4SLinus Torvalds #define CHKRES_NO_TAPE 3 8761da177e4SLinus Torvalds 8771da177e4SLinus Torvalds #define MAX_ATTENTIONS 10 8781da177e4SLinus Torvalds 8791da177e4SLinus Torvalds static int test_ready(struct scsi_tape *STp, int do_wait) 8801da177e4SLinus Torvalds { 8811da177e4SLinus Torvalds int attentions, waits, max_wait, scode; 8821da177e4SLinus Torvalds int retval = CHKRES_READY, new_session = 0; 8831da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 8840944a721SFUJITA Tomonori struct st_request *SRpnt; 8851da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 8861da177e4SLinus Torvalds 8870944a721SFUJITA Tomonori SRpnt = st_allocate_request(STp); 8880944a721SFUJITA Tomonori if (!SRpnt) 8890944a721SFUJITA Tomonori return STp->buffer->syscall_result; 8900944a721SFUJITA Tomonori 8911da177e4SLinus Torvalds max_wait = do_wait ? ST_BLOCK_SECONDS : 0; 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds for (attentions=waits=0; ; ) { 8941da177e4SLinus Torvalds memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 8951da177e4SLinus Torvalds cmd[0] = TEST_UNIT_READY; 8961da177e4SLinus Torvalds 8970944a721SFUJITA Tomonori retval = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0, 8980944a721SFUJITA Tomonori STp->long_timeout, 8990944a721SFUJITA Tomonori MAX_READY_RETRIES); 9000944a721SFUJITA Tomonori if (retval) 9011da177e4SLinus Torvalds break; 9021da177e4SLinus Torvalds 9031da177e4SLinus Torvalds if (cmdstatp->have_sense) { 9041da177e4SLinus Torvalds 9051da177e4SLinus Torvalds scode = cmdstatp->sense_hdr.sense_key; 9061da177e4SLinus Torvalds 9071da177e4SLinus Torvalds if (scode == UNIT_ATTENTION) { /* New media? */ 9081da177e4SLinus Torvalds new_session = 1; 9091da177e4SLinus Torvalds if (attentions < MAX_ATTENTIONS) { 9101da177e4SLinus Torvalds attentions++; 9111da177e4SLinus Torvalds continue; 9121da177e4SLinus Torvalds } 9131da177e4SLinus Torvalds else { 9141da177e4SLinus Torvalds retval = (-EIO); 9151da177e4SLinus Torvalds break; 9161da177e4SLinus Torvalds } 9171da177e4SLinus Torvalds } 9181da177e4SLinus Torvalds 9191da177e4SLinus Torvalds if (scode == NOT_READY) { 9201da177e4SLinus Torvalds if (waits < max_wait) { 9211da177e4SLinus Torvalds if (msleep_interruptible(1000)) { 9221da177e4SLinus Torvalds retval = (-EINTR); 9231da177e4SLinus Torvalds break; 9241da177e4SLinus Torvalds } 9251da177e4SLinus Torvalds waits++; 9261da177e4SLinus Torvalds continue; 9271da177e4SLinus Torvalds } 9281da177e4SLinus Torvalds else { 9291da177e4SLinus Torvalds if ((STp->device)->scsi_level >= SCSI_2 && 9301da177e4SLinus Torvalds cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */ 9311da177e4SLinus Torvalds retval = CHKRES_NO_TAPE; 9321da177e4SLinus Torvalds else 9331da177e4SLinus Torvalds retval = CHKRES_NOT_READY; 9341da177e4SLinus Torvalds break; 9351da177e4SLinus Torvalds } 9361da177e4SLinus Torvalds } 9371da177e4SLinus Torvalds } 9381da177e4SLinus Torvalds 9391da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 9401da177e4SLinus Torvalds if (!retval) 9411da177e4SLinus Torvalds retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY; 9421da177e4SLinus Torvalds break; 9431da177e4SLinus Torvalds } 9441da177e4SLinus Torvalds 9458b05b773SMike Christie st_release_request(SRpnt); 9460944a721SFUJITA Tomonori 9471da177e4SLinus Torvalds return retval; 9481da177e4SLinus Torvalds } 9491da177e4SLinus Torvalds 9501da177e4SLinus Torvalds 9511da177e4SLinus Torvalds /* See if the drive is ready and gather information about the tape. Return values: 9521da177e4SLinus Torvalds < 0 negative error code from errno.h 9531da177e4SLinus Torvalds 0 drive ready 9541da177e4SLinus Torvalds 1 drive not ready (possibly no tape) 9551da177e4SLinus Torvalds */ 9561da177e4SLinus Torvalds static int check_tape(struct scsi_tape *STp, struct file *filp) 9571da177e4SLinus Torvalds { 9581da177e4SLinus Torvalds int i, retval, new_session = 0, do_wait; 9591da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning; 9601da177e4SLinus Torvalds unsigned short st_flags = filp->f_flags; 9618b05b773SMike Christie struct st_request *SRpnt = NULL; 9621da177e4SLinus Torvalds struct st_modedef *STm; 9631da177e4SLinus Torvalds struct st_partstat *STps; 9641da177e4SLinus Torvalds char *name = tape_name(STp); 9657ac6207bSJosef Sipek struct inode *inode = filp->f_path.dentry->d_inode; 9661da177e4SLinus Torvalds int mode = TAPE_MODE(inode); 9671da177e4SLinus Torvalds 9681da177e4SLinus Torvalds STp->ready = ST_READY; 9691da177e4SLinus Torvalds 9701da177e4SLinus Torvalds if (mode != STp->current_mode) { 9711da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n", 9721da177e4SLinus Torvalds name, STp->current_mode, mode)); 9731da177e4SLinus Torvalds new_session = 1; 9741da177e4SLinus Torvalds STp->current_mode = mode; 9751da177e4SLinus Torvalds } 9761da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 9771da177e4SLinus Torvalds 9781da177e4SLinus Torvalds saved_cleaning = STp->cleaning_req; 9791da177e4SLinus Torvalds STp->cleaning_req = 0; 9801da177e4SLinus Torvalds 9811da177e4SLinus Torvalds do_wait = ((filp->f_flags & O_NONBLOCK) == 0); 9821da177e4SLinus Torvalds retval = test_ready(STp, do_wait); 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds if (retval < 0) 9851da177e4SLinus Torvalds goto err_out; 9861da177e4SLinus Torvalds 9871da177e4SLinus Torvalds if (retval == CHKRES_NEW_SESSION) { 9881da177e4SLinus Torvalds STp->pos_unknown = 0; 9891da177e4SLinus Torvalds STp->partition = STp->new_partition = 0; 9901da177e4SLinus Torvalds if (STp->can_partitions) 9911da177e4SLinus Torvalds STp->nbr_partitions = 1; /* This guess will be updated later 9921da177e4SLinus Torvalds if necessary */ 9931da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 9941da177e4SLinus Torvalds STps = &(STp->ps[i]); 9951da177e4SLinus Torvalds STps->rw = ST_IDLE; 9961da177e4SLinus Torvalds STps->eof = ST_NOEOF; 9971da177e4SLinus Torvalds STps->at_sm = 0; 9981da177e4SLinus Torvalds STps->last_block_valid = 0; 9991da177e4SLinus Torvalds STps->drv_block = 0; 10001da177e4SLinus Torvalds STps->drv_file = 0; 10011da177e4SLinus Torvalds } 10021da177e4SLinus Torvalds new_session = 1; 10031da177e4SLinus Torvalds } 10041da177e4SLinus Torvalds else { 10051da177e4SLinus Torvalds STp->cleaning_req |= saved_cleaning; 10061da177e4SLinus Torvalds 10071da177e4SLinus Torvalds if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) { 10081da177e4SLinus Torvalds if (retval == CHKRES_NO_TAPE) 10091da177e4SLinus Torvalds STp->ready = ST_NO_TAPE; 10101da177e4SLinus Torvalds else 10111da177e4SLinus Torvalds STp->ready = ST_NOT_READY; 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds STp->density = 0; /* Clear the erroneous "residue" */ 10141da177e4SLinus Torvalds STp->write_prot = 0; 10151da177e4SLinus Torvalds STp->block_size = 0; 10161da177e4SLinus Torvalds STp->ps[0].drv_file = STp->ps[0].drv_block = (-1); 10171da177e4SLinus Torvalds STp->partition = STp->new_partition = 0; 10181da177e4SLinus Torvalds STp->door_locked = ST_UNLOCKED; 10191da177e4SLinus Torvalds return CHKRES_NOT_READY; 10201da177e4SLinus Torvalds } 10211da177e4SLinus Torvalds } 10221da177e4SLinus Torvalds 10231da177e4SLinus Torvalds if (STp->omit_blklims) 10241da177e4SLinus Torvalds STp->min_block = STp->max_block = (-1); 10251da177e4SLinus Torvalds else { 10261da177e4SLinus Torvalds memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 10271da177e4SLinus Torvalds cmd[0] = READ_BLOCK_LIMITS; 10281da177e4SLinus Torvalds 10291da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE, 1030a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 1031a02488edSJames Bottomley MAX_READY_RETRIES, 1); 10321da177e4SLinus Torvalds if (!SRpnt) { 10331da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 10341da177e4SLinus Torvalds goto err_out; 10351da177e4SLinus Torvalds } 10361da177e4SLinus Torvalds 10378b05b773SMike Christie if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) { 10381da177e4SLinus Torvalds STp->max_block = ((STp->buffer)->b_data[1] << 16) | 10391da177e4SLinus Torvalds ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3]; 10401da177e4SLinus Torvalds STp->min_block = ((STp->buffer)->b_data[4] << 8) | 10411da177e4SLinus Torvalds (STp->buffer)->b_data[5]; 10421da177e4SLinus Torvalds if ( DEB( debugging || ) !STp->inited) 104342252854SKai Makisara printk(KERN_INFO 10441da177e4SLinus Torvalds "%s: Block limits %d - %d bytes.\n", name, 10451da177e4SLinus Torvalds STp->min_block, STp->max_block); 10461da177e4SLinus Torvalds } else { 10471da177e4SLinus Torvalds STp->min_block = STp->max_block = (-1); 10481da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n", 10491da177e4SLinus Torvalds name)); 10501da177e4SLinus Torvalds } 10511da177e4SLinus Torvalds } 10521da177e4SLinus Torvalds 10531da177e4SLinus Torvalds memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 10541da177e4SLinus Torvalds cmd[0] = MODE_SENSE; 10551da177e4SLinus Torvalds cmd[4] = 12; 10561da177e4SLinus Torvalds 10571da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE, 1058a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 1059a02488edSJames Bottomley MAX_READY_RETRIES, 1); 10601da177e4SLinus Torvalds if (!SRpnt) { 10611da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 10621da177e4SLinus Torvalds goto err_out; 10631da177e4SLinus Torvalds } 10641da177e4SLinus Torvalds 10651da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0) { 10661da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name)); 10671da177e4SLinus Torvalds STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */ 10681da177e4SLinus Torvalds (STp->buffer)->syscall_result = 0; /* Prevent error propagation */ 10691da177e4SLinus Torvalds STp->drv_write_prot = 0; 10701da177e4SLinus Torvalds } else { 10711da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 10721da177e4SLinus Torvalds "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n", 10731da177e4SLinus Torvalds name, 10741da177e4SLinus Torvalds (STp->buffer)->b_data[0], (STp->buffer)->b_data[1], 10751da177e4SLinus Torvalds (STp->buffer)->b_data[2], (STp->buffer)->b_data[3])); 10761da177e4SLinus Torvalds 10771da177e4SLinus Torvalds if ((STp->buffer)->b_data[3] >= 8) { 10781da177e4SLinus Torvalds STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7; 10791da177e4SLinus Torvalds STp->density = (STp->buffer)->b_data[4]; 10801da177e4SLinus Torvalds STp->block_size = (STp->buffer)->b_data[9] * 65536 + 10811da177e4SLinus Torvalds (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11]; 10821da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 10831da177e4SLinus Torvalds "%s: Density %x, tape length: %x, drv buffer: %d\n", 10841da177e4SLinus Torvalds name, STp->density, (STp->buffer)->b_data[5] * 65536 + 10851da177e4SLinus Torvalds (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7], 10861da177e4SLinus Torvalds STp->drv_buffer)); 10871da177e4SLinus Torvalds } 10881da177e4SLinus Torvalds STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0; 10891da177e4SLinus Torvalds } 10908b05b773SMike Christie st_release_request(SRpnt); 10911da177e4SLinus Torvalds SRpnt = NULL; 10921da177e4SLinus Torvalds STp->inited = 1; 10931da177e4SLinus Torvalds 10941da177e4SLinus Torvalds if (STp->block_size > 0) 10951da177e4SLinus Torvalds (STp->buffer)->buffer_blocks = 10961da177e4SLinus Torvalds (STp->buffer)->buffer_size / STp->block_size; 10971da177e4SLinus Torvalds else 10981da177e4SLinus Torvalds (STp->buffer)->buffer_blocks = 1; 10991da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0; 11001da177e4SLinus Torvalds 11011da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 11021da177e4SLinus Torvalds "%s: Block size: %d, buffer size: %d (%d blocks).\n", name, 11031da177e4SLinus Torvalds STp->block_size, (STp->buffer)->buffer_size, 11041da177e4SLinus Torvalds (STp->buffer)->buffer_blocks)); 11051da177e4SLinus Torvalds 11061da177e4SLinus Torvalds if (STp->drv_write_prot) { 11071da177e4SLinus Torvalds STp->write_prot = 1; 11081da177e4SLinus Torvalds 11091da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name)); 11101da177e4SLinus Torvalds 11111da177e4SLinus Torvalds if (do_wait && 11121da177e4SLinus Torvalds ((st_flags & O_ACCMODE) == O_WRONLY || 11131da177e4SLinus Torvalds (st_flags & O_ACCMODE) == O_RDWR)) { 11141da177e4SLinus Torvalds retval = (-EROFS); 11151da177e4SLinus Torvalds goto err_out; 11161da177e4SLinus Torvalds } 11171da177e4SLinus Torvalds } 11181da177e4SLinus Torvalds 11191da177e4SLinus Torvalds if (STp->can_partitions && STp->nbr_partitions < 1) { 11201da177e4SLinus Torvalds /* This code is reached when the device is opened for the first time 11211da177e4SLinus Torvalds after the driver has been initialized with tape in the drive and the 11221da177e4SLinus Torvalds partition support has been enabled. */ 11231da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 11241da177e4SLinus Torvalds "%s: Updating partition number in status.\n", name)); 11251da177e4SLinus Torvalds if ((STp->partition = find_partition(STp)) < 0) { 11261da177e4SLinus Torvalds retval = STp->partition; 11271da177e4SLinus Torvalds goto err_out; 11281da177e4SLinus Torvalds } 11291da177e4SLinus Torvalds STp->new_partition = STp->partition; 11301da177e4SLinus Torvalds STp->nbr_partitions = 1; /* This guess will be updated when necessary */ 11311da177e4SLinus Torvalds } 11321da177e4SLinus Torvalds 11331da177e4SLinus Torvalds if (new_session) { /* Change the drive parameters for the new mode */ 11341da177e4SLinus Torvalds STp->density_changed = STp->blksize_changed = 0; 11351da177e4SLinus Torvalds STp->compression_changed = 0; 11361da177e4SLinus Torvalds if (!(STm->defaults_for_writes) && 11371da177e4SLinus Torvalds (retval = set_mode_densblk(STp, STm)) < 0) 11381da177e4SLinus Torvalds goto err_out; 11391da177e4SLinus Torvalds 11401da177e4SLinus Torvalds if (STp->default_drvbuffer != 0xff) { 11411da177e4SLinus Torvalds if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer)) 11421da177e4SLinus Torvalds printk(KERN_WARNING 11431da177e4SLinus Torvalds "%s: Can't set default drive buffering to %d.\n", 11441da177e4SLinus Torvalds name, STp->default_drvbuffer); 11451da177e4SLinus Torvalds } 11461da177e4SLinus Torvalds } 11471da177e4SLinus Torvalds 11481da177e4SLinus Torvalds return CHKRES_READY; 11491da177e4SLinus Torvalds 11501da177e4SLinus Torvalds err_out: 11511da177e4SLinus Torvalds return retval; 11521da177e4SLinus Torvalds } 11531da177e4SLinus Torvalds 11541da177e4SLinus Torvalds 1155b3369c68SJonathan Corbet /* Open the device. Needs to take the BKL only because of incrementing the SCSI host 11561da177e4SLinus Torvalds module count. */ 11571da177e4SLinus Torvalds static int st_open(struct inode *inode, struct file *filp) 11581da177e4SLinus Torvalds { 11591da177e4SLinus Torvalds int i, retval = (-EIO); 11601da177e4SLinus Torvalds struct scsi_tape *STp; 11611da177e4SLinus Torvalds struct st_partstat *STps; 11621da177e4SLinus Torvalds int dev = TAPE_NR(inode); 11631da177e4SLinus Torvalds char *name; 11641da177e4SLinus Torvalds 1165b3369c68SJonathan Corbet lock_kernel(); 11661da177e4SLinus Torvalds /* 11671da177e4SLinus Torvalds * We really want to do nonseekable_open(inode, filp); here, but some 11681da177e4SLinus Torvalds * versions of tar incorrectly call lseek on tapes and bail out if that 11691da177e4SLinus Torvalds * fails. So we disallow pread() and pwrite(), but permit lseeks. 11701da177e4SLinus Torvalds */ 11711da177e4SLinus Torvalds filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE); 11721da177e4SLinus Torvalds 1173b3369c68SJonathan Corbet if (!(STp = scsi_tape_get(dev))) { 1174b3369c68SJonathan Corbet unlock_kernel(); 1175f03a5670SKai Makisara return -ENXIO; 1176b3369c68SJonathan Corbet } 1177f03a5670SKai Makisara 11781da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 11791da177e4SLinus Torvalds filp->private_data = STp; 11801da177e4SLinus Torvalds name = tape_name(STp); 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds if (STp->in_use) { 11831da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 1184f03a5670SKai Makisara scsi_tape_put(STp); 1185b3369c68SJonathan Corbet unlock_kernel(); 11861da177e4SLinus Torvalds DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); ) 11871da177e4SLinus Torvalds return (-EBUSY); 11881da177e4SLinus Torvalds } 11891da177e4SLinus Torvalds 11901da177e4SLinus Torvalds STp->in_use = 1; 11911da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 11921da177e4SLinus Torvalds STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0; 11931da177e4SLinus Torvalds 11941da177e4SLinus Torvalds if (!scsi_block_when_processing_errors(STp->device)) { 11951da177e4SLinus Torvalds retval = (-ENXIO); 11961da177e4SLinus Torvalds goto err_out; 11971da177e4SLinus Torvalds } 11981da177e4SLinus Torvalds 11991da177e4SLinus Torvalds /* See that we have at least a one page buffer available */ 12001da177e4SLinus Torvalds if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) { 12011da177e4SLinus Torvalds printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n", 12021da177e4SLinus Torvalds name); 12031da177e4SLinus Torvalds retval = (-EOVERFLOW); 12041da177e4SLinus Torvalds goto err_out; 12051da177e4SLinus Torvalds } 12061da177e4SLinus Torvalds 120740f6b36cSKai Makisara (STp->buffer)->cleared = 0; 12081da177e4SLinus Torvalds (STp->buffer)->writing = 0; 12091da177e4SLinus Torvalds (STp->buffer)->syscall_result = 0; 12101da177e4SLinus Torvalds 12111da177e4SLinus Torvalds STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY); 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds STp->dirty = 0; 12141da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 12151da177e4SLinus Torvalds STps = &(STp->ps[i]); 12161da177e4SLinus Torvalds STps->rw = ST_IDLE; 12171da177e4SLinus Torvalds } 12189abe16c6SKai Makisara STp->try_dio_now = STp->try_dio; 12191da177e4SLinus Torvalds STp->recover_count = 0; 12201da177e4SLinus Torvalds DEB( STp->nbr_waits = STp->nbr_finished = 0; 1221deee13dfSKai Makisara STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; ) 12221da177e4SLinus Torvalds 12231da177e4SLinus Torvalds retval = check_tape(STp, filp); 12241da177e4SLinus Torvalds if (retval < 0) 12251da177e4SLinus Torvalds goto err_out; 12261da177e4SLinus Torvalds if ((filp->f_flags & O_NONBLOCK) == 0 && 12271da177e4SLinus Torvalds retval != CHKRES_READY) { 1228413f7327SKai Makisara if (STp->ready == NO_TAPE) 1229413f7327SKai Makisara retval = (-ENOMEDIUM); 1230413f7327SKai Makisara else 12311da177e4SLinus Torvalds retval = (-EIO); 12321da177e4SLinus Torvalds goto err_out; 12331da177e4SLinus Torvalds } 1234b3369c68SJonathan Corbet unlock_kernel(); 12351da177e4SLinus Torvalds return 0; 12361da177e4SLinus Torvalds 12371da177e4SLinus Torvalds err_out: 12381da177e4SLinus Torvalds normalize_buffer(STp->buffer); 12391da177e4SLinus Torvalds STp->in_use = 0; 1240f03a5670SKai Makisara scsi_tape_put(STp); 1241b3369c68SJonathan Corbet unlock_kernel(); 12421da177e4SLinus Torvalds return retval; 12431da177e4SLinus Torvalds 12441da177e4SLinus Torvalds } 12451da177e4SLinus Torvalds 12461da177e4SLinus Torvalds 12471da177e4SLinus Torvalds /* Flush the tape buffer before close */ 124875e1fcc0SMiklos Szeredi static int st_flush(struct file *filp, fl_owner_t id) 12491da177e4SLinus Torvalds { 12501da177e4SLinus Torvalds int result = 0, result2; 12511da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 12528b05b773SMike Christie struct st_request *SRpnt; 12531da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 12541da177e4SLinus Torvalds struct st_modedef *STm = &(STp->modes[STp->current_mode]); 12551da177e4SLinus Torvalds struct st_partstat *STps = &(STp->ps[STp->partition]); 12561da177e4SLinus Torvalds char *name = tape_name(STp); 12571da177e4SLinus Torvalds 12581da177e4SLinus Torvalds if (file_count(filp) > 1) 12591da177e4SLinus Torvalds return 0; 12601da177e4SLinus Torvalds 12611da177e4SLinus Torvalds if (STps->rw == ST_WRITING && !STp->pos_unknown) { 12628ef8d594SAdrian Bunk result = st_flush_write_buffer(STp); 12631da177e4SLinus Torvalds if (result != 0 && result != (-ENOSPC)) 12641da177e4SLinus Torvalds goto out; 12651da177e4SLinus Torvalds } 12661da177e4SLinus Torvalds 12671da177e4SLinus Torvalds if (STp->can_partitions && 12681da177e4SLinus Torvalds (result2 = switch_partition(STp)) < 0) { 12691da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 12701da177e4SLinus Torvalds "%s: switch_partition at close failed.\n", name)); 12711da177e4SLinus Torvalds if (result == 0) 12721da177e4SLinus Torvalds result = result2; 12731da177e4SLinus Torvalds goto out; 12741da177e4SLinus Torvalds } 12751da177e4SLinus Torvalds 12761da177e4SLinus Torvalds DEBC( if (STp->nbr_requests) 1277deee13dfSKai Makisara printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n", 1278deee13dfSKai Makisara name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages)); 12791da177e4SLinus Torvalds 12801da177e4SLinus Torvalds if (STps->rw == ST_WRITING && !STp->pos_unknown) { 12811da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 12821da177e4SLinus Torvalds 12831da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n", 12841da177e4SLinus Torvalds name, STp->nbr_waits, STp->nbr_finished); 12851da177e4SLinus Torvalds ) 12861da177e4SLinus Torvalds 12871da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 12881da177e4SLinus Torvalds cmd[0] = WRITE_FILEMARKS; 12891da177e4SLinus Torvalds cmd[4] = 1 + STp->two_fm; 12901da177e4SLinus Torvalds 1291212cd8bfSFUJITA Tomonori SRpnt = st_allocate_request(STp); 12921da177e4SLinus Torvalds if (!SRpnt) { 1293212cd8bfSFUJITA Tomonori result = STp->buffer->syscall_result; 1294212cd8bfSFUJITA Tomonori goto out; 1295212cd8bfSFUJITA Tomonori } 1296212cd8bfSFUJITA Tomonori 1297212cd8bfSFUJITA Tomonori result = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0, 1298212cd8bfSFUJITA Tomonori STp->device->request_queue->rq_timeout, 1299212cd8bfSFUJITA Tomonori MAX_WRITE_RETRIES); 1300212cd8bfSFUJITA Tomonori if (result) { 1301212cd8bfSFUJITA Tomonori st_release_request(SRpnt); 13021da177e4SLinus Torvalds goto out; 13031da177e4SLinus Torvalds } 13041da177e4SLinus Torvalds 13051da177e4SLinus Torvalds if (STp->buffer->syscall_result == 0 || 13061da177e4SLinus Torvalds (cmdstatp->have_sense && !cmdstatp->deferred && 13071da177e4SLinus Torvalds (cmdstatp->flags & SENSE_EOM) && 13081da177e4SLinus Torvalds (cmdstatp->sense_hdr.sense_key == NO_SENSE || 13091da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) && 13101da177e4SLinus Torvalds (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) { 13111da177e4SLinus Torvalds /* Write successful at EOM */ 13128b05b773SMike Christie st_release_request(SRpnt); 13131da177e4SLinus Torvalds SRpnt = NULL; 13141da177e4SLinus Torvalds if (STps->drv_file >= 0) 13151da177e4SLinus Torvalds STps->drv_file++; 13161da177e4SLinus Torvalds STps->drv_block = 0; 13171da177e4SLinus Torvalds if (STp->two_fm) 13181da177e4SLinus Torvalds cross_eof(STp, 0); 13191da177e4SLinus Torvalds STps->eof = ST_FM; 13201da177e4SLinus Torvalds } 13211da177e4SLinus Torvalds else { /* Write error */ 13228b05b773SMike Christie st_release_request(SRpnt); 13231da177e4SLinus Torvalds SRpnt = NULL; 13241da177e4SLinus Torvalds printk(KERN_ERR "%s: Error on write filemark.\n", name); 13251da177e4SLinus Torvalds if (result == 0) 13261da177e4SLinus Torvalds result = (-EIO); 13271da177e4SLinus Torvalds } 13281da177e4SLinus Torvalds 13291da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n", 13301da177e4SLinus Torvalds name, cmd[4])); 13311da177e4SLinus Torvalds } else if (!STp->rew_at_close) { 13321da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 13331da177e4SLinus Torvalds if (!STm->sysv || STps->rw != ST_READING) { 13341da177e4SLinus Torvalds if (STp->can_bsr) 13351da177e4SLinus Torvalds result = flush_buffer(STp, 0); 13361da177e4SLinus Torvalds else if (STps->eof == ST_FM_HIT) { 13371da177e4SLinus Torvalds result = cross_eof(STp, 0); 13381da177e4SLinus Torvalds if (result) { 13391da177e4SLinus Torvalds if (STps->drv_file >= 0) 13401da177e4SLinus Torvalds STps->drv_file++; 13411da177e4SLinus Torvalds STps->drv_block = 0; 13421da177e4SLinus Torvalds STps->eof = ST_FM; 13431da177e4SLinus Torvalds } else 13441da177e4SLinus Torvalds STps->eof = ST_NOEOF; 13451da177e4SLinus Torvalds } 13461da177e4SLinus Torvalds } else if ((STps->eof == ST_NOEOF && 13471da177e4SLinus Torvalds !(result = cross_eof(STp, 1))) || 13481da177e4SLinus Torvalds STps->eof == ST_FM_HIT) { 13491da177e4SLinus Torvalds if (STps->drv_file >= 0) 13501da177e4SLinus Torvalds STps->drv_file++; 13511da177e4SLinus Torvalds STps->drv_block = 0; 13521da177e4SLinus Torvalds STps->eof = ST_FM; 13531da177e4SLinus Torvalds } 13541da177e4SLinus Torvalds } 13551da177e4SLinus Torvalds 13561da177e4SLinus Torvalds out: 13571da177e4SLinus Torvalds if (STp->rew_at_close) { 13581da177e4SLinus Torvalds result2 = st_int_ioctl(STp, MTREW, 1); 13591da177e4SLinus Torvalds if (result == 0) 13601da177e4SLinus Torvalds result = result2; 13611da177e4SLinus Torvalds } 13621da177e4SLinus Torvalds return result; 13631da177e4SLinus Torvalds } 13641da177e4SLinus Torvalds 13651da177e4SLinus Torvalds 13661da177e4SLinus Torvalds /* Close the device and release it. BKL is not needed: this is the only thread 13671da177e4SLinus Torvalds accessing this tape. */ 13681da177e4SLinus Torvalds static int st_release(struct inode *inode, struct file *filp) 13691da177e4SLinus Torvalds { 13701da177e4SLinus Torvalds int result = 0; 13711da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 13721da177e4SLinus Torvalds 13731da177e4SLinus Torvalds if (STp->door_locked == ST_LOCKED_AUTO) 13741da177e4SLinus Torvalds do_door_lock(STp, 0); 13751da177e4SLinus Torvalds 13761da177e4SLinus Torvalds normalize_buffer(STp->buffer); 13771da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 13781da177e4SLinus Torvalds STp->in_use = 0; 13791da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 1380f03a5670SKai Makisara scsi_tape_put(STp); 13811da177e4SLinus Torvalds 13821da177e4SLinus Torvalds return result; 13831da177e4SLinus Torvalds } 13841da177e4SLinus Torvalds 13851da177e4SLinus Torvalds /* The checks common to both reading and writing */ 13861da177e4SLinus Torvalds static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count) 13871da177e4SLinus Torvalds { 13881da177e4SLinus Torvalds ssize_t retval = 0; 13891da177e4SLinus Torvalds 13901da177e4SLinus Torvalds /* 13911da177e4SLinus Torvalds * If we are in the middle of error recovery, don't let anyone 13921da177e4SLinus Torvalds * else try and use this device. Also, if error recovery fails, it 13931da177e4SLinus Torvalds * may try and take the device offline, in which case all further 13941da177e4SLinus Torvalds * access to the device is prohibited. 13951da177e4SLinus Torvalds */ 13961da177e4SLinus Torvalds if (!scsi_block_when_processing_errors(STp->device)) { 13971da177e4SLinus Torvalds retval = (-ENXIO); 13981da177e4SLinus Torvalds goto out; 13991da177e4SLinus Torvalds } 14001da177e4SLinus Torvalds 14011da177e4SLinus Torvalds if (STp->ready != ST_READY) { 14021da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 14031da177e4SLinus Torvalds retval = (-ENOMEDIUM); 14041da177e4SLinus Torvalds else 14051da177e4SLinus Torvalds retval = (-EIO); 14061da177e4SLinus Torvalds goto out; 14071da177e4SLinus Torvalds } 14081da177e4SLinus Torvalds 14091da177e4SLinus Torvalds if (! STp->modes[STp->current_mode].defined) { 14101da177e4SLinus Torvalds retval = (-ENXIO); 14111da177e4SLinus Torvalds goto out; 14121da177e4SLinus Torvalds } 14131da177e4SLinus Torvalds 14141da177e4SLinus Torvalds 14151da177e4SLinus Torvalds /* 14161da177e4SLinus Torvalds * If there was a bus reset, block further access 14171da177e4SLinus Torvalds * to this device. 14181da177e4SLinus Torvalds */ 14191da177e4SLinus Torvalds if (STp->pos_unknown) { 14201da177e4SLinus Torvalds retval = (-EIO); 14211da177e4SLinus Torvalds goto out; 14221da177e4SLinus Torvalds } 14231da177e4SLinus Torvalds 14241da177e4SLinus Torvalds if (count == 0) 14251da177e4SLinus Torvalds goto out; 14261da177e4SLinus Torvalds 14271da177e4SLinus Torvalds DEB( 14281da177e4SLinus Torvalds if (!STp->in_use) { 14291da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp)); 14301da177e4SLinus Torvalds retval = (-EIO); 14311da177e4SLinus Torvalds goto out; 14321da177e4SLinus Torvalds } ) /* end DEB */ 14331da177e4SLinus Torvalds 14341da177e4SLinus Torvalds if (STp->can_partitions && 14351da177e4SLinus Torvalds (retval = switch_partition(STp)) < 0) 14361da177e4SLinus Torvalds goto out; 14371da177e4SLinus Torvalds 14381da177e4SLinus Torvalds if (STp->block_size == 0 && STp->max_block > 0 && 14391da177e4SLinus Torvalds (count < STp->min_block || count > STp->max_block)) { 14401da177e4SLinus Torvalds retval = (-EINVAL); 14411da177e4SLinus Torvalds goto out; 14421da177e4SLinus Torvalds } 14431da177e4SLinus Torvalds 14441da177e4SLinus Torvalds if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && 14451da177e4SLinus Torvalds !do_door_lock(STp, 1)) 14461da177e4SLinus Torvalds STp->door_locked = ST_LOCKED_AUTO; 14471da177e4SLinus Torvalds 14481da177e4SLinus Torvalds out: 14491da177e4SLinus Torvalds return retval; 14501da177e4SLinus Torvalds } 14511da177e4SLinus Torvalds 14521da177e4SLinus Torvalds 14531da177e4SLinus Torvalds static int setup_buffering(struct scsi_tape *STp, const char __user *buf, 14541da177e4SLinus Torvalds size_t count, int is_read) 14551da177e4SLinus Torvalds { 14561da177e4SLinus Torvalds int i, bufsize, retval = 0; 14571da177e4SLinus Torvalds struct st_buffer *STbp = STp->buffer; 14581da177e4SLinus Torvalds 14591da177e4SLinus Torvalds if (is_read) 14609abe16c6SKai Makisara i = STp->try_dio_now && try_rdio; 14611da177e4SLinus Torvalds else 14629abe16c6SKai Makisara i = STp->try_dio_now && try_wdio; 14638b05b773SMike Christie 14641da177e4SLinus Torvalds if (i && ((unsigned long)buf & queue_dma_alignment( 14651da177e4SLinus Torvalds STp->device->request_queue)) == 0) { 14668b05b773SMike Christie i = sgl_map_user_pages(&(STbp->sg[0]), STbp->use_sg, 14678b05b773SMike Christie (unsigned long)buf, count, (is_read ? READ : WRITE)); 14681da177e4SLinus Torvalds if (i > 0) { 14691da177e4SLinus Torvalds STbp->do_dio = i; 14701da177e4SLinus Torvalds STbp->buffer_bytes = 0; /* can be used as transfer counter */ 14711da177e4SLinus Torvalds } 14721da177e4SLinus Torvalds else 14731da177e4SLinus Torvalds STbp->do_dio = 0; /* fall back to buffering with any error */ 14741da177e4SLinus Torvalds STbp->sg_segs = STbp->do_dio; 14751da177e4SLinus Torvalds STbp->frp_sg_current = 0; 14761da177e4SLinus Torvalds DEB( 14771da177e4SLinus Torvalds if (STbp->do_dio) { 14781da177e4SLinus Torvalds STp->nbr_dio++; 14791da177e4SLinus Torvalds STp->nbr_pages += STbp->do_dio; 14801da177e4SLinus Torvalds } 14811da177e4SLinus Torvalds ) 14821da177e4SLinus Torvalds } else 14831da177e4SLinus Torvalds STbp->do_dio = 0; 14841da177e4SLinus Torvalds DEB( STp->nbr_requests++; ) 14851da177e4SLinus Torvalds 14861da177e4SLinus Torvalds if (!STbp->do_dio) { 14871da177e4SLinus Torvalds if (STp->block_size) 14881da177e4SLinus Torvalds bufsize = STp->block_size > st_fixed_buffer_size ? 14891da177e4SLinus Torvalds STp->block_size : st_fixed_buffer_size; 149040f6b36cSKai Makisara else { 14911da177e4SLinus Torvalds bufsize = count; 149240f6b36cSKai Makisara /* Make sure that data from previous user is not leaked even if 149340f6b36cSKai Makisara HBA does not return correct residual */ 149440f6b36cSKai Makisara if (is_read && STp->sili && !STbp->cleared) 149540f6b36cSKai Makisara clear_buffer(STbp); 149640f6b36cSKai Makisara } 149740f6b36cSKai Makisara 14981da177e4SLinus Torvalds if (bufsize > STbp->buffer_size && 14991da177e4SLinus Torvalds !enlarge_buffer(STbp, bufsize, STp->restr_dma)) { 15001da177e4SLinus Torvalds printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n", 15011da177e4SLinus Torvalds tape_name(STp), bufsize); 15021da177e4SLinus Torvalds retval = (-EOVERFLOW); 15031da177e4SLinus Torvalds goto out; 15041da177e4SLinus Torvalds } 15051da177e4SLinus Torvalds if (STp->block_size) 15061da177e4SLinus Torvalds STbp->buffer_blocks = bufsize / STp->block_size; 15071da177e4SLinus Torvalds } 15081da177e4SLinus Torvalds 15091da177e4SLinus Torvalds out: 15101da177e4SLinus Torvalds return retval; 15111da177e4SLinus Torvalds } 15121da177e4SLinus Torvalds 15131da177e4SLinus Torvalds 15141da177e4SLinus Torvalds /* Can be called more than once after each setup_buffer() */ 1515787926b1SKai Makisara static void release_buffering(struct scsi_tape *STp, int is_read) 15161da177e4SLinus Torvalds { 15171da177e4SLinus Torvalds struct st_buffer *STbp; 15181da177e4SLinus Torvalds 15191da177e4SLinus Torvalds STbp = STp->buffer; 15201da177e4SLinus Torvalds if (STbp->do_dio) { 1521787926b1SKai Makisara sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, is_read); 15221da177e4SLinus Torvalds STbp->do_dio = 0; 1523787926b1SKai Makisara STbp->sg_segs = 0; 15241da177e4SLinus Torvalds } 15251da177e4SLinus Torvalds } 15261da177e4SLinus Torvalds 15271da177e4SLinus Torvalds 15281da177e4SLinus Torvalds /* Write command */ 15291da177e4SLinus Torvalds static ssize_t 15301da177e4SLinus Torvalds st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) 15311da177e4SLinus Torvalds { 15321da177e4SLinus Torvalds ssize_t total; 15331da177e4SLinus Torvalds ssize_t i, do_count, blks, transfer; 15341da177e4SLinus Torvalds ssize_t retval; 15351da177e4SLinus Torvalds int undone, retry_eot = 0, scode; 15361da177e4SLinus Torvalds int async_write; 15371da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 15381da177e4SLinus Torvalds const char __user *b_point; 15398b05b773SMike Christie struct st_request *SRpnt = NULL; 15401da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 15411da177e4SLinus Torvalds struct st_modedef *STm; 15421da177e4SLinus Torvalds struct st_partstat *STps; 15431da177e4SLinus Torvalds struct st_buffer *STbp; 15441da177e4SLinus Torvalds char *name = tape_name(STp); 15451da177e4SLinus Torvalds 154628f85009SMatthias Kaehlcke if (mutex_lock_interruptible(&STp->lock)) 15471da177e4SLinus Torvalds return -ERESTARTSYS; 15481da177e4SLinus Torvalds 15491da177e4SLinus Torvalds retval = rw_checks(STp, filp, count); 15501da177e4SLinus Torvalds if (retval || count == 0) 15511da177e4SLinus Torvalds goto out; 15521da177e4SLinus Torvalds 15531da177e4SLinus Torvalds /* Write must be integral number of blocks */ 15541da177e4SLinus Torvalds if (STp->block_size != 0 && (count % STp->block_size) != 0) { 15551da177e4SLinus Torvalds printk(KERN_WARNING "%s: Write not multiple of tape block size.\n", 15561da177e4SLinus Torvalds name); 15571da177e4SLinus Torvalds retval = (-EINVAL); 15581da177e4SLinus Torvalds goto out; 15591da177e4SLinus Torvalds } 15601da177e4SLinus Torvalds 15611da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 15621da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 15631da177e4SLinus Torvalds 15641da177e4SLinus Torvalds if (STp->write_prot) { 15651da177e4SLinus Torvalds retval = (-EACCES); 15661da177e4SLinus Torvalds goto out; 15671da177e4SLinus Torvalds } 15681da177e4SLinus Torvalds 15691da177e4SLinus Torvalds 15701da177e4SLinus Torvalds if (STps->rw == ST_READING) { 15711da177e4SLinus Torvalds retval = flush_buffer(STp, 0); 15721da177e4SLinus Torvalds if (retval) 15731da177e4SLinus Torvalds goto out; 15741da177e4SLinus Torvalds STps->rw = ST_WRITING; 15751da177e4SLinus Torvalds } else if (STps->rw != ST_WRITING && 15761da177e4SLinus Torvalds STps->drv_file == 0 && STps->drv_block == 0) { 15771da177e4SLinus Torvalds if ((retval = set_mode_densblk(STp, STm)) < 0) 15781da177e4SLinus Torvalds goto out; 15791da177e4SLinus Torvalds if (STm->default_compression != ST_DONT_TOUCH && 15801da177e4SLinus Torvalds !(STp->compression_changed)) { 15811da177e4SLinus Torvalds if (st_compression(STp, (STm->default_compression == ST_YES))) { 15821da177e4SLinus Torvalds printk(KERN_WARNING "%s: Can't set default compression.\n", 15831da177e4SLinus Torvalds name); 15841da177e4SLinus Torvalds if (modes_defined) { 15851da177e4SLinus Torvalds retval = (-EINVAL); 15861da177e4SLinus Torvalds goto out; 15871da177e4SLinus Torvalds } 15881da177e4SLinus Torvalds } 15891da177e4SLinus Torvalds } 15901da177e4SLinus Torvalds } 15911da177e4SLinus Torvalds 15921da177e4SLinus Torvalds STbp = STp->buffer; 15931da177e4SLinus Torvalds i = write_behind_check(STp); 15941da177e4SLinus Torvalds if (i) { 15951da177e4SLinus Torvalds if (i == -ENOSPC) 15961da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 15971da177e4SLinus Torvalds else 15981da177e4SLinus Torvalds STps->eof = ST_EOM_ERROR; 15991da177e4SLinus Torvalds } 16001da177e4SLinus Torvalds 16011da177e4SLinus Torvalds if (STps->eof == ST_EOM_OK) { 16021da177e4SLinus Torvalds STps->eof = ST_EOD_1; /* allow next write */ 16031da177e4SLinus Torvalds retval = (-ENOSPC); 16041da177e4SLinus Torvalds goto out; 16051da177e4SLinus Torvalds } 16061da177e4SLinus Torvalds else if (STps->eof == ST_EOM_ERROR) { 16071da177e4SLinus Torvalds retval = (-EIO); 16081da177e4SLinus Torvalds goto out; 16091da177e4SLinus Torvalds } 16101da177e4SLinus Torvalds 16111da177e4SLinus Torvalds /* Check the buffer readability in cases where copy_user might catch 16121da177e4SLinus Torvalds the problems after some tape movement. */ 16131da177e4SLinus Torvalds if (STp->block_size != 0 && 16141da177e4SLinus Torvalds !STbp->do_dio && 16151da177e4SLinus Torvalds (copy_from_user(&i, buf, 1) != 0 || 16161da177e4SLinus Torvalds copy_from_user(&i, buf + count - 1, 1) != 0)) { 16171da177e4SLinus Torvalds retval = (-EFAULT); 16181da177e4SLinus Torvalds goto out; 16191da177e4SLinus Torvalds } 16201da177e4SLinus Torvalds 16211da177e4SLinus Torvalds retval = setup_buffering(STp, buf, count, 0); 16221da177e4SLinus Torvalds if (retval) 16231da177e4SLinus Torvalds goto out; 16241da177e4SLinus Torvalds 16251da177e4SLinus Torvalds total = count; 16261da177e4SLinus Torvalds 16271da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 16281da177e4SLinus Torvalds cmd[0] = WRITE_6; 16291da177e4SLinus Torvalds cmd[1] = (STp->block_size != 0); 16301da177e4SLinus Torvalds 16311da177e4SLinus Torvalds STps->rw = ST_WRITING; 16321da177e4SLinus Torvalds 16331da177e4SLinus Torvalds b_point = buf; 16341da177e4SLinus Torvalds while (count > 0 && !retry_eot) { 16351da177e4SLinus Torvalds 16361da177e4SLinus Torvalds if (STbp->do_dio) { 16371da177e4SLinus Torvalds do_count = count; 16381da177e4SLinus Torvalds } 16391da177e4SLinus Torvalds else { 16401da177e4SLinus Torvalds if (STp->block_size == 0) 16411da177e4SLinus Torvalds do_count = count; 16421da177e4SLinus Torvalds else { 16431da177e4SLinus Torvalds do_count = STbp->buffer_blocks * STp->block_size - 16441da177e4SLinus Torvalds STbp->buffer_bytes; 16451da177e4SLinus Torvalds if (do_count > count) 16461da177e4SLinus Torvalds do_count = count; 16471da177e4SLinus Torvalds } 16481da177e4SLinus Torvalds 16491da177e4SLinus Torvalds i = append_to_buffer(b_point, STbp, do_count); 16501da177e4SLinus Torvalds if (i) { 16511da177e4SLinus Torvalds retval = i; 16521da177e4SLinus Torvalds goto out; 16531da177e4SLinus Torvalds } 16541da177e4SLinus Torvalds } 16551da177e4SLinus Torvalds count -= do_count; 16561da177e4SLinus Torvalds b_point += do_count; 16571da177e4SLinus Torvalds 16581da177e4SLinus Torvalds async_write = STp->block_size == 0 && !STbp->do_dio && 16591da177e4SLinus Torvalds STm->do_async_writes && STps->eof < ST_EOM_OK; 16601da177e4SLinus Torvalds 16611da177e4SLinus Torvalds if (STp->block_size != 0 && STm->do_buffer_writes && 16629abe16c6SKai Makisara !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK && 16631da177e4SLinus Torvalds STbp->buffer_bytes < STbp->buffer_size) { 16641da177e4SLinus Torvalds STp->dirty = 1; 16651da177e4SLinus Torvalds /* Don't write a buffer that is not full enough. */ 16661da177e4SLinus Torvalds if (!async_write && count == 0) 16671da177e4SLinus Torvalds break; 16681da177e4SLinus Torvalds } 16691da177e4SLinus Torvalds 16701da177e4SLinus Torvalds retry_write: 16711da177e4SLinus Torvalds if (STp->block_size == 0) 16721da177e4SLinus Torvalds blks = transfer = do_count; 16731da177e4SLinus Torvalds else { 16741da177e4SLinus Torvalds if (!STbp->do_dio) 16751da177e4SLinus Torvalds blks = STbp->buffer_bytes; 16761da177e4SLinus Torvalds else 16771da177e4SLinus Torvalds blks = do_count; 16781da177e4SLinus Torvalds blks /= STp->block_size; 16791da177e4SLinus Torvalds transfer = blks * STp->block_size; 16801da177e4SLinus Torvalds } 16811da177e4SLinus Torvalds cmd[2] = blks >> 16; 16821da177e4SLinus Torvalds cmd[3] = blks >> 8; 16831da177e4SLinus Torvalds cmd[4] = blks; 16841da177e4SLinus Torvalds 16851da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE, 1686a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 1687a02488edSJames Bottomley MAX_WRITE_RETRIES, !async_write); 16881da177e4SLinus Torvalds if (!SRpnt) { 16891da177e4SLinus Torvalds retval = STbp->syscall_result; 16901da177e4SLinus Torvalds goto out; 16911da177e4SLinus Torvalds } 16928b05b773SMike Christie if (async_write && !STbp->syscall_result) { 16931da177e4SLinus Torvalds STbp->writing = transfer; 16941da177e4SLinus Torvalds STp->dirty = !(STbp->writing == 16951da177e4SLinus Torvalds STbp->buffer_bytes); 16961da177e4SLinus Torvalds SRpnt = NULL; /* Prevent releasing this request! */ 16971da177e4SLinus Torvalds DEB( STp->write_pending = 1; ) 16981da177e4SLinus Torvalds break; 16991da177e4SLinus Torvalds } 17001da177e4SLinus Torvalds 17011da177e4SLinus Torvalds if (STbp->syscall_result != 0) { 17021da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 17031da177e4SLinus Torvalds 17041da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name)); 17051da177e4SLinus Torvalds if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) { 17061da177e4SLinus Torvalds scode = cmdstatp->sense_hdr.sense_key; 17071da177e4SLinus Torvalds if (cmdstatp->remainder_valid) 17081da177e4SLinus Torvalds undone = (int)cmdstatp->uremainder64; 17091da177e4SLinus Torvalds else if (STp->block_size == 0 && 17101da177e4SLinus Torvalds scode == VOLUME_OVERFLOW) 17111da177e4SLinus Torvalds undone = transfer; 17121da177e4SLinus Torvalds else 17131da177e4SLinus Torvalds undone = 0; 17141da177e4SLinus Torvalds if (STp->block_size != 0) 17151da177e4SLinus Torvalds undone *= STp->block_size; 17161da177e4SLinus Torvalds if (undone <= do_count) { 17171da177e4SLinus Torvalds /* Only data from this write is not written */ 17181da177e4SLinus Torvalds count += undone; 1719626dcb1eSKai Makisara b_point -= undone; 17201da177e4SLinus Torvalds do_count -= undone; 17211da177e4SLinus Torvalds if (STp->block_size) 17221da177e4SLinus Torvalds blks = (transfer - undone) / STp->block_size; 17231da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 17241da177e4SLinus Torvalds /* Continue in fixed block mode if all written 17251da177e4SLinus Torvalds in this request but still something left to write 17261da177e4SLinus Torvalds (retval left to zero) 17271da177e4SLinus Torvalds */ 17281da177e4SLinus Torvalds if (STp->block_size == 0 || 17291da177e4SLinus Torvalds undone > 0 || count == 0) 17301da177e4SLinus Torvalds retval = (-ENOSPC); /* EOM within current request */ 17311da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 17321da177e4SLinus Torvalds "%s: EOM with %d bytes unwritten.\n", 17331da177e4SLinus Torvalds name, (int)count)); 17341da177e4SLinus Torvalds } else { 17351da177e4SLinus Torvalds /* EOT within data buffered earlier (possible only 17361da177e4SLinus Torvalds in fixed block mode without direct i/o) */ 17371da177e4SLinus Torvalds if (!retry_eot && !cmdstatp->deferred && 17381da177e4SLinus Torvalds (scode == NO_SENSE || scode == RECOVERED_ERROR)) { 17391da177e4SLinus Torvalds move_buffer_data(STp->buffer, transfer - undone); 17401da177e4SLinus Torvalds retry_eot = 1; 17411da177e4SLinus Torvalds if (STps->drv_block >= 0) { 17421da177e4SLinus Torvalds STps->drv_block += (transfer - undone) / 17431da177e4SLinus Torvalds STp->block_size; 17441da177e4SLinus Torvalds } 17451da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 17461da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 17471da177e4SLinus Torvalds "%s: Retry write of %d bytes at EOM.\n", 17481da177e4SLinus Torvalds name, STp->buffer->buffer_bytes)); 17491da177e4SLinus Torvalds goto retry_write; 17501da177e4SLinus Torvalds } 17511da177e4SLinus Torvalds else { 17521da177e4SLinus Torvalds /* Either error within data buffered by driver or 17531da177e4SLinus Torvalds failed retry */ 17541da177e4SLinus Torvalds count -= do_count; 17551da177e4SLinus Torvalds blks = do_count = 0; 17561da177e4SLinus Torvalds STps->eof = ST_EOM_ERROR; 17571da177e4SLinus Torvalds STps->drv_block = (-1); /* Too cautious? */ 17581da177e4SLinus Torvalds retval = (-EIO); /* EOM for old data */ 17591da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 17601da177e4SLinus Torvalds "%s: EOM with lost data.\n", 17611da177e4SLinus Torvalds name)); 17621da177e4SLinus Torvalds } 17631da177e4SLinus Torvalds } 17641da177e4SLinus Torvalds } else { 17651da177e4SLinus Torvalds count += do_count; 17661da177e4SLinus Torvalds STps->drv_block = (-1); /* Too cautious? */ 17678b05b773SMike Christie retval = STbp->syscall_result; 17681da177e4SLinus Torvalds } 17691da177e4SLinus Torvalds 17701da177e4SLinus Torvalds } 17711da177e4SLinus Torvalds 17721da177e4SLinus Torvalds if (STps->drv_block >= 0) { 17731da177e4SLinus Torvalds if (STp->block_size == 0) 17741da177e4SLinus Torvalds STps->drv_block += (do_count > 0); 17751da177e4SLinus Torvalds else 17761da177e4SLinus Torvalds STps->drv_block += blks; 17771da177e4SLinus Torvalds } 17781da177e4SLinus Torvalds 17791da177e4SLinus Torvalds STbp->buffer_bytes = 0; 17801da177e4SLinus Torvalds STp->dirty = 0; 17811da177e4SLinus Torvalds 17821da177e4SLinus Torvalds if (retval || retry_eot) { 17831da177e4SLinus Torvalds if (count < total) 17841da177e4SLinus Torvalds retval = total - count; 17851da177e4SLinus Torvalds goto out; 17861da177e4SLinus Torvalds } 17871da177e4SLinus Torvalds } 17881da177e4SLinus Torvalds 17891da177e4SLinus Torvalds if (STps->eof == ST_EOD_1) 17901da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 17911da177e4SLinus Torvalds else if (STps->eof != ST_EOM_OK) 17921da177e4SLinus Torvalds STps->eof = ST_NOEOF; 17931da177e4SLinus Torvalds retval = total - count; 17941da177e4SLinus Torvalds 17951da177e4SLinus Torvalds out: 17961da177e4SLinus Torvalds if (SRpnt != NULL) 17978b05b773SMike Christie st_release_request(SRpnt); 1798787926b1SKai Makisara release_buffering(STp, 0); 179928f85009SMatthias Kaehlcke mutex_unlock(&STp->lock); 18001da177e4SLinus Torvalds 18011da177e4SLinus Torvalds return retval; 18021da177e4SLinus Torvalds } 18031da177e4SLinus Torvalds 18041da177e4SLinus Torvalds /* Read data from the tape. Returns zero in the normal case, one if the 18051da177e4SLinus Torvalds eof status has changed, and the negative error code in case of a 18061da177e4SLinus Torvalds fatal error. Otherwise updates the buffer and the eof state. 18071da177e4SLinus Torvalds 18081da177e4SLinus Torvalds Does release user buffer mapping if it is set. 18091da177e4SLinus Torvalds */ 18101da177e4SLinus Torvalds static long read_tape(struct scsi_tape *STp, long count, 18118b05b773SMike Christie struct st_request ** aSRpnt) 18121da177e4SLinus Torvalds { 18131da177e4SLinus Torvalds int transfer, blks, bytes; 18141da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 18158b05b773SMike Christie struct st_request *SRpnt; 18161da177e4SLinus Torvalds struct st_modedef *STm; 18171da177e4SLinus Torvalds struct st_partstat *STps; 18181da177e4SLinus Torvalds struct st_buffer *STbp; 18191da177e4SLinus Torvalds int retval = 0; 18201da177e4SLinus Torvalds char *name = tape_name(STp); 18211da177e4SLinus Torvalds 18221da177e4SLinus Torvalds if (count == 0) 18231da177e4SLinus Torvalds return 0; 18241da177e4SLinus Torvalds 18251da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 18261da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 18271da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) 18281da177e4SLinus Torvalds return 1; 18291da177e4SLinus Torvalds STbp = STp->buffer; 18301da177e4SLinus Torvalds 18311da177e4SLinus Torvalds if (STp->block_size == 0) 18321da177e4SLinus Torvalds blks = bytes = count; 18331da177e4SLinus Torvalds else { 18349abe16c6SKai Makisara if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) { 18351da177e4SLinus Torvalds blks = (STp->buffer)->buffer_blocks; 18361da177e4SLinus Torvalds bytes = blks * STp->block_size; 18371da177e4SLinus Torvalds } else { 18381da177e4SLinus Torvalds bytes = count; 18391da177e4SLinus Torvalds if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size) 18401da177e4SLinus Torvalds bytes = (STp->buffer)->buffer_size; 18411da177e4SLinus Torvalds blks = bytes / STp->block_size; 18421da177e4SLinus Torvalds bytes = blks * STp->block_size; 18431da177e4SLinus Torvalds } 18441da177e4SLinus Torvalds } 18451da177e4SLinus Torvalds 18461da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 18471da177e4SLinus Torvalds cmd[0] = READ_6; 18481da177e4SLinus Torvalds cmd[1] = (STp->block_size != 0); 184940f6b36cSKai Makisara if (!cmd[1] && STp->sili) 185040f6b36cSKai Makisara cmd[1] |= 2; 18511da177e4SLinus Torvalds cmd[2] = blks >> 16; 18521da177e4SLinus Torvalds cmd[3] = blks >> 8; 18531da177e4SLinus Torvalds cmd[4] = blks; 18541da177e4SLinus Torvalds 18551da177e4SLinus Torvalds SRpnt = *aSRpnt; 18561da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE, 1857a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 1858a02488edSJames Bottomley MAX_RETRIES, 1); 1859787926b1SKai Makisara release_buffering(STp, 1); 18601da177e4SLinus Torvalds *aSRpnt = SRpnt; 18611da177e4SLinus Torvalds if (!SRpnt) 18621da177e4SLinus Torvalds return STbp->syscall_result; 18631da177e4SLinus Torvalds 18641da177e4SLinus Torvalds STbp->read_pointer = 0; 18651da177e4SLinus Torvalds STps->at_sm = 0; 18661da177e4SLinus Torvalds 18671da177e4SLinus Torvalds /* Something to check */ 18681da177e4SLinus Torvalds if (STbp->syscall_result) { 18691da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 18701da177e4SLinus Torvalds 18711da177e4SLinus Torvalds retval = 1; 18721da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n", 18731da177e4SLinus Torvalds name, 18748b05b773SMike Christie SRpnt->sense[0], SRpnt->sense[1], 18758b05b773SMike Christie SRpnt->sense[2], SRpnt->sense[3], 18768b05b773SMike Christie SRpnt->sense[4], SRpnt->sense[5], 18778b05b773SMike Christie SRpnt->sense[6], SRpnt->sense[7])); 18781da177e4SLinus Torvalds if (cmdstatp->have_sense) { 18791da177e4SLinus Torvalds 18801da177e4SLinus Torvalds if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK) 18811da177e4SLinus Torvalds cmdstatp->flags &= 0xcf; /* No need for EOM in this case */ 18821da177e4SLinus Torvalds 18831da177e4SLinus Torvalds if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */ 18841da177e4SLinus Torvalds /* Compute the residual count */ 18851da177e4SLinus Torvalds if (cmdstatp->remainder_valid) 18861da177e4SLinus Torvalds transfer = (int)cmdstatp->uremainder64; 18871da177e4SLinus Torvalds else 18881da177e4SLinus Torvalds transfer = 0; 18891da177e4SLinus Torvalds if (STp->block_size == 0 && 18901da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR) 18911da177e4SLinus Torvalds transfer = bytes; 18921da177e4SLinus Torvalds 18931da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_ILI) { /* ILI */ 18941da177e4SLinus Torvalds if (STp->block_size == 0) { 18951da177e4SLinus Torvalds if (transfer <= 0) { 18961da177e4SLinus Torvalds if (transfer < 0) 18971da177e4SLinus Torvalds printk(KERN_NOTICE 18981da177e4SLinus Torvalds "%s: Failed to read %d byte block with %d byte transfer.\n", 18991da177e4SLinus Torvalds name, bytes - transfer, bytes); 19001da177e4SLinus Torvalds if (STps->drv_block >= 0) 19011da177e4SLinus Torvalds STps->drv_block += 1; 19021da177e4SLinus Torvalds STbp->buffer_bytes = 0; 19031da177e4SLinus Torvalds return (-ENOMEM); 19041da177e4SLinus Torvalds } 19051da177e4SLinus Torvalds STbp->buffer_bytes = bytes - transfer; 19061da177e4SLinus Torvalds } else { 19078b05b773SMike Christie st_release_request(SRpnt); 19081da177e4SLinus Torvalds SRpnt = *aSRpnt = NULL; 19091da177e4SLinus Torvalds if (transfer == blks) { /* We did not get anything, error */ 19101da177e4SLinus Torvalds printk(KERN_NOTICE "%s: Incorrect block size.\n", name); 19111da177e4SLinus Torvalds if (STps->drv_block >= 0) 19121da177e4SLinus Torvalds STps->drv_block += blks - transfer + 1; 19131da177e4SLinus Torvalds st_int_ioctl(STp, MTBSR, 1); 19141da177e4SLinus Torvalds return (-EIO); 19151da177e4SLinus Torvalds } 19161da177e4SLinus Torvalds /* We have some data, deliver it */ 19171da177e4SLinus Torvalds STbp->buffer_bytes = (blks - transfer) * 19181da177e4SLinus Torvalds STp->block_size; 19191da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 19201da177e4SLinus Torvalds "%s: ILI but enough data received %ld %d.\n", 19211da177e4SLinus Torvalds name, count, STbp->buffer_bytes)); 19221da177e4SLinus Torvalds if (STps->drv_block >= 0) 19231da177e4SLinus Torvalds STps->drv_block += 1; 19241da177e4SLinus Torvalds if (st_int_ioctl(STp, MTBSR, 1)) 19251da177e4SLinus Torvalds return (-EIO); 19261da177e4SLinus Torvalds } 19271da177e4SLinus Torvalds } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */ 19281da177e4SLinus Torvalds if (STps->eof != ST_FM_HIT) 19291da177e4SLinus Torvalds STps->eof = ST_FM_HIT; 19301da177e4SLinus Torvalds else 19311da177e4SLinus Torvalds STps->eof = ST_EOD_2; 19321da177e4SLinus Torvalds if (STp->block_size == 0) 19331da177e4SLinus Torvalds STbp->buffer_bytes = 0; 19341da177e4SLinus Torvalds else 19351da177e4SLinus Torvalds STbp->buffer_bytes = 19361da177e4SLinus Torvalds bytes - transfer * STp->block_size; 19371da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 19381da177e4SLinus Torvalds "%s: EOF detected (%d bytes read).\n", 19391da177e4SLinus Torvalds name, STbp->buffer_bytes)); 19401da177e4SLinus Torvalds } else if (cmdstatp->flags & SENSE_EOM) { 19411da177e4SLinus Torvalds if (STps->eof == ST_FM) 19421da177e4SLinus Torvalds STps->eof = ST_EOD_1; 19431da177e4SLinus Torvalds else 19441da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 19451da177e4SLinus Torvalds if (STp->block_size == 0) 19461da177e4SLinus Torvalds STbp->buffer_bytes = bytes - transfer; 19471da177e4SLinus Torvalds else 19481da177e4SLinus Torvalds STbp->buffer_bytes = 19491da177e4SLinus Torvalds bytes - transfer * STp->block_size; 19501da177e4SLinus Torvalds 19511da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n", 19521da177e4SLinus Torvalds name, STbp->buffer_bytes)); 19531da177e4SLinus Torvalds } 19541da177e4SLinus Torvalds } 19551da177e4SLinus Torvalds /* end of EOF, EOM, ILI test */ 19561da177e4SLinus Torvalds else { /* nonzero sense key */ 19571da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 19581da177e4SLinus Torvalds "%s: Tape error while reading.\n", name)); 19591da177e4SLinus Torvalds STps->drv_block = (-1); 19601da177e4SLinus Torvalds if (STps->eof == ST_FM && 19611da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == BLANK_CHECK) { 19621da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 19631da177e4SLinus Torvalds "%s: Zero returned for first BLANK CHECK after EOF.\n", 19641da177e4SLinus Torvalds name)); 19651da177e4SLinus Torvalds STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */ 19661da177e4SLinus Torvalds } else /* Some other extended sense code */ 19671da177e4SLinus Torvalds retval = (-EIO); 19681da177e4SLinus Torvalds } 19691da177e4SLinus Torvalds 19701da177e4SLinus Torvalds if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */ 19711da177e4SLinus Torvalds STbp->buffer_bytes = 0; 19721da177e4SLinus Torvalds } 19731da177e4SLinus Torvalds /* End of extended sense test */ 19741da177e4SLinus Torvalds else { /* Non-extended sense */ 19751da177e4SLinus Torvalds retval = STbp->syscall_result; 19761da177e4SLinus Torvalds } 19771da177e4SLinus Torvalds 19781da177e4SLinus Torvalds } 19791da177e4SLinus Torvalds /* End of error handling */ 198040f6b36cSKai Makisara else { /* Read successful */ 19811da177e4SLinus Torvalds STbp->buffer_bytes = bytes; 198240f6b36cSKai Makisara if (STp->sili) /* In fixed block mode residual is always zero here */ 198340f6b36cSKai Makisara STbp->buffer_bytes -= STp->buffer->cmdstat.residual; 198440f6b36cSKai Makisara } 19851da177e4SLinus Torvalds 19861da177e4SLinus Torvalds if (STps->drv_block >= 0) { 19871da177e4SLinus Torvalds if (STp->block_size == 0) 19881da177e4SLinus Torvalds STps->drv_block++; 19891da177e4SLinus Torvalds else 19901da177e4SLinus Torvalds STps->drv_block += STbp->buffer_bytes / STp->block_size; 19911da177e4SLinus Torvalds } 19921da177e4SLinus Torvalds return retval; 19931da177e4SLinus Torvalds } 19941da177e4SLinus Torvalds 19951da177e4SLinus Torvalds 19961da177e4SLinus Torvalds /* Read command */ 19971da177e4SLinus Torvalds static ssize_t 19981da177e4SLinus Torvalds st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos) 19991da177e4SLinus Torvalds { 20001da177e4SLinus Torvalds ssize_t total; 20011da177e4SLinus Torvalds ssize_t retval = 0; 20021da177e4SLinus Torvalds ssize_t i, transfer; 20031da177e4SLinus Torvalds int special, do_dio = 0; 20048b05b773SMike Christie struct st_request *SRpnt = NULL; 20051da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 20061da177e4SLinus Torvalds struct st_modedef *STm; 20071da177e4SLinus Torvalds struct st_partstat *STps; 20081da177e4SLinus Torvalds struct st_buffer *STbp = STp->buffer; 20091da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 20101da177e4SLinus Torvalds 201128f85009SMatthias Kaehlcke if (mutex_lock_interruptible(&STp->lock)) 20121da177e4SLinus Torvalds return -ERESTARTSYS; 20131da177e4SLinus Torvalds 20141da177e4SLinus Torvalds retval = rw_checks(STp, filp, count); 20151da177e4SLinus Torvalds if (retval || count == 0) 20161da177e4SLinus Torvalds goto out; 20171da177e4SLinus Torvalds 20181da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 20199abe16c6SKai Makisara if (STp->block_size != 0 && (count % STp->block_size) != 0) { 20209abe16c6SKai Makisara if (!STm->do_read_ahead) { 20211da177e4SLinus Torvalds retval = (-EINVAL); /* Read must be integral number of blocks */ 20221da177e4SLinus Torvalds goto out; 20231da177e4SLinus Torvalds } 20249abe16c6SKai Makisara STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */ 20259abe16c6SKai Makisara } 20261da177e4SLinus Torvalds 20271da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 20281da177e4SLinus Torvalds if (STps->rw == ST_WRITING) { 20291da177e4SLinus Torvalds retval = flush_buffer(STp, 0); 20301da177e4SLinus Torvalds if (retval) 20311da177e4SLinus Torvalds goto out; 20321da177e4SLinus Torvalds STps->rw = ST_READING; 20331da177e4SLinus Torvalds } 20341da177e4SLinus Torvalds DEB( 20351da177e4SLinus Torvalds if (debugging && STps->eof != ST_NOEOF) 20361da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name, 20371da177e4SLinus Torvalds STps->eof, STbp->buffer_bytes); 20381da177e4SLinus Torvalds ) /* end DEB */ 20391da177e4SLinus Torvalds 20401da177e4SLinus Torvalds retval = setup_buffering(STp, buf, count, 1); 20411da177e4SLinus Torvalds if (retval) 20421da177e4SLinus Torvalds goto out; 20431da177e4SLinus Torvalds do_dio = STbp->do_dio; 20441da177e4SLinus Torvalds 20451da177e4SLinus Torvalds if (STbp->buffer_bytes == 0 && 20461da177e4SLinus Torvalds STps->eof >= ST_EOD_1) { 20471da177e4SLinus Torvalds if (STps->eof < ST_EOD) { 20481da177e4SLinus Torvalds STps->eof += 1; 20491da177e4SLinus Torvalds retval = 0; 20501da177e4SLinus Torvalds goto out; 20511da177e4SLinus Torvalds } 20521da177e4SLinus Torvalds retval = (-EIO); /* EOM or Blank Check */ 20531da177e4SLinus Torvalds goto out; 20541da177e4SLinus Torvalds } 20551da177e4SLinus Torvalds 20561da177e4SLinus Torvalds if (do_dio) { 20571da177e4SLinus Torvalds /* Check the buffer writability before any tape movement. Don't alter 20581da177e4SLinus Torvalds buffer data. */ 20591da177e4SLinus Torvalds if (copy_from_user(&i, buf, 1) != 0 || 20601da177e4SLinus Torvalds copy_to_user(buf, &i, 1) != 0 || 20611da177e4SLinus Torvalds copy_from_user(&i, buf + count - 1, 1) != 0 || 20621da177e4SLinus Torvalds copy_to_user(buf + count - 1, &i, 1) != 0) { 20631da177e4SLinus Torvalds retval = (-EFAULT); 20641da177e4SLinus Torvalds goto out; 20651da177e4SLinus Torvalds } 20661da177e4SLinus Torvalds } 20671da177e4SLinus Torvalds 20681da177e4SLinus Torvalds STps->rw = ST_READING; 20691da177e4SLinus Torvalds 20701da177e4SLinus Torvalds 20711da177e4SLinus Torvalds /* Loop until enough data in buffer or a special condition found */ 20721da177e4SLinus Torvalds for (total = 0, special = 0; total < count && !special;) { 20731da177e4SLinus Torvalds 20741da177e4SLinus Torvalds /* Get new data if the buffer is empty */ 20751da177e4SLinus Torvalds if (STbp->buffer_bytes == 0) { 20761da177e4SLinus Torvalds special = read_tape(STp, count - total, &SRpnt); 20771da177e4SLinus Torvalds if (special < 0) { /* No need to continue read */ 20781da177e4SLinus Torvalds retval = special; 20791da177e4SLinus Torvalds goto out; 20801da177e4SLinus Torvalds } 20811da177e4SLinus Torvalds } 20821da177e4SLinus Torvalds 20831da177e4SLinus Torvalds /* Move the data from driver buffer to user buffer */ 20841da177e4SLinus Torvalds if (STbp->buffer_bytes > 0) { 20851da177e4SLinus Torvalds DEB( 20861da177e4SLinus Torvalds if (debugging && STps->eof != ST_NOEOF) 20871da177e4SLinus Torvalds printk(ST_DEB_MSG 20881da177e4SLinus Torvalds "%s: EOF up (%d). Left %d, needed %d.\n", name, 20891da177e4SLinus Torvalds STps->eof, STbp->buffer_bytes, 20901da177e4SLinus Torvalds (int)(count - total)); 20911da177e4SLinus Torvalds ) /* end DEB */ 20921da177e4SLinus Torvalds transfer = STbp->buffer_bytes < count - total ? 20931da177e4SLinus Torvalds STbp->buffer_bytes : count - total; 20941da177e4SLinus Torvalds if (!do_dio) { 20951da177e4SLinus Torvalds i = from_buffer(STbp, buf, transfer); 20961da177e4SLinus Torvalds if (i) { 20971da177e4SLinus Torvalds retval = i; 20981da177e4SLinus Torvalds goto out; 20991da177e4SLinus Torvalds } 21001da177e4SLinus Torvalds } 21011da177e4SLinus Torvalds buf += transfer; 21021da177e4SLinus Torvalds total += transfer; 21031da177e4SLinus Torvalds } 21041da177e4SLinus Torvalds 21051da177e4SLinus Torvalds if (STp->block_size == 0) 21061da177e4SLinus Torvalds break; /* Read only one variable length block */ 21071da177e4SLinus Torvalds 21081da177e4SLinus Torvalds } /* for (total = 0, special = 0; 21091da177e4SLinus Torvalds total < count && !special; ) */ 21101da177e4SLinus Torvalds 21111da177e4SLinus Torvalds /* Change the eof state if no data from tape or buffer */ 21121da177e4SLinus Torvalds if (total == 0) { 21131da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) { 21141da177e4SLinus Torvalds STps->eof = ST_FM; 21151da177e4SLinus Torvalds STps->drv_block = 0; 21161da177e4SLinus Torvalds if (STps->drv_file >= 0) 21171da177e4SLinus Torvalds STps->drv_file++; 21181da177e4SLinus Torvalds } else if (STps->eof == ST_EOD_1) { 21191da177e4SLinus Torvalds STps->eof = ST_EOD_2; 21201da177e4SLinus Torvalds STps->drv_block = 0; 21211da177e4SLinus Torvalds if (STps->drv_file >= 0) 21221da177e4SLinus Torvalds STps->drv_file++; 21231da177e4SLinus Torvalds } else if (STps->eof == ST_EOD_2) 21241da177e4SLinus Torvalds STps->eof = ST_EOD; 21251da177e4SLinus Torvalds } else if (STps->eof == ST_FM) 21261da177e4SLinus Torvalds STps->eof = ST_NOEOF; 21271da177e4SLinus Torvalds retval = total; 21281da177e4SLinus Torvalds 21291da177e4SLinus Torvalds out: 21301da177e4SLinus Torvalds if (SRpnt != NULL) { 21318b05b773SMike Christie st_release_request(SRpnt); 21321da177e4SLinus Torvalds SRpnt = NULL; 21331da177e4SLinus Torvalds } 21341da177e4SLinus Torvalds if (do_dio) { 2135787926b1SKai Makisara release_buffering(STp, 1); 21361da177e4SLinus Torvalds STbp->buffer_bytes = 0; 21371da177e4SLinus Torvalds } 213828f85009SMatthias Kaehlcke mutex_unlock(&STp->lock); 21391da177e4SLinus Torvalds 21401da177e4SLinus Torvalds return retval; 21411da177e4SLinus Torvalds } 21421da177e4SLinus Torvalds 21431da177e4SLinus Torvalds 21441da177e4SLinus Torvalds 21451da177e4SLinus Torvalds DEB( 21461da177e4SLinus Torvalds /* Set the driver options */ 21471da177e4SLinus Torvalds static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name) 21481da177e4SLinus Torvalds { 21491da177e4SLinus Torvalds if (debugging) { 21501da177e4SLinus Torvalds printk(KERN_INFO 21511da177e4SLinus Torvalds "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n", 21521da177e4SLinus Torvalds name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes, 21531da177e4SLinus Torvalds STm->do_read_ahead); 21541da177e4SLinus Torvalds printk(KERN_INFO 21551da177e4SLinus Torvalds "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n", 21561da177e4SLinus Torvalds name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock); 21571da177e4SLinus Torvalds printk(KERN_INFO 21581da177e4SLinus Torvalds "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n", 21591da177e4SLinus Torvalds name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions, 21601da177e4SLinus Torvalds STp->scsi2_logical); 21611da177e4SLinus Torvalds printk(KERN_INFO 216240f6b36cSKai Makisara "%s: sysv: %d nowait: %d sili: %d\n", name, STm->sysv, STp->immediate, 216340f6b36cSKai Makisara STp->sili); 21641da177e4SLinus Torvalds printk(KERN_INFO "%s: debugging: %d\n", 21651da177e4SLinus Torvalds name, debugging); 21661da177e4SLinus Torvalds } 21671da177e4SLinus Torvalds } 21681da177e4SLinus Torvalds ) 21691da177e4SLinus Torvalds 21701da177e4SLinus Torvalds 21711da177e4SLinus Torvalds static int st_set_options(struct scsi_tape *STp, long options) 21721da177e4SLinus Torvalds { 21731da177e4SLinus Torvalds int value; 21741da177e4SLinus Torvalds long code; 21751da177e4SLinus Torvalds struct st_modedef *STm; 21761da177e4SLinus Torvalds char *name = tape_name(STp); 21771da177e4SLinus Torvalds struct cdev *cd0, *cd1; 21781da177e4SLinus Torvalds 21791da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 21801da177e4SLinus Torvalds if (!STm->defined) { 21811da177e4SLinus Torvalds cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1]; 21821da177e4SLinus Torvalds memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef)); 21831da177e4SLinus Torvalds STm->cdevs[0] = cd0; STm->cdevs[1] = cd1; 21841da177e4SLinus Torvalds modes_defined = 1; 21851da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 21861da177e4SLinus Torvalds "%s: Initialized mode %d definition from mode 0\n", 21871da177e4SLinus Torvalds name, STp->current_mode)); 21881da177e4SLinus Torvalds } 21891da177e4SLinus Torvalds 21901da177e4SLinus Torvalds code = options & MT_ST_OPTIONS; 21911da177e4SLinus Torvalds if (code == MT_ST_BOOLEANS) { 21921da177e4SLinus Torvalds STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0; 21931da177e4SLinus Torvalds STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0; 21941da177e4SLinus Torvalds STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0; 21951da177e4SLinus Torvalds STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0; 21961da177e4SLinus Torvalds STp->two_fm = (options & MT_ST_TWO_FM) != 0; 21971da177e4SLinus Torvalds STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0; 21981da177e4SLinus Torvalds STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0; 21991da177e4SLinus Torvalds STp->can_bsr = (options & MT_ST_CAN_BSR) != 0; 22001da177e4SLinus Torvalds STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0; 22011da177e4SLinus Torvalds if ((STp->device)->scsi_level >= SCSI_2) 22021da177e4SLinus Torvalds STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0; 22031da177e4SLinus Torvalds STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0; 22041da177e4SLinus Torvalds STp->immediate = (options & MT_ST_NOWAIT) != 0; 22051da177e4SLinus Torvalds STm->sysv = (options & MT_ST_SYSV) != 0; 220640f6b36cSKai Makisara STp->sili = (options & MT_ST_SILI) != 0; 22071da177e4SLinus Torvalds DEB( debugging = (options & MT_ST_DEBUGGING) != 0; 22081da177e4SLinus Torvalds st_log_options(STp, STm, name); ) 22091da177e4SLinus Torvalds } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) { 22101da177e4SLinus Torvalds value = (code == MT_ST_SETBOOLEANS); 22111da177e4SLinus Torvalds if ((options & MT_ST_BUFFER_WRITES) != 0) 22121da177e4SLinus Torvalds STm->do_buffer_writes = value; 22131da177e4SLinus Torvalds if ((options & MT_ST_ASYNC_WRITES) != 0) 22141da177e4SLinus Torvalds STm->do_async_writes = value; 22151da177e4SLinus Torvalds if ((options & MT_ST_DEF_WRITES) != 0) 22161da177e4SLinus Torvalds STm->defaults_for_writes = value; 22171da177e4SLinus Torvalds if ((options & MT_ST_READ_AHEAD) != 0) 22181da177e4SLinus Torvalds STm->do_read_ahead = value; 22191da177e4SLinus Torvalds if ((options & MT_ST_TWO_FM) != 0) 22201da177e4SLinus Torvalds STp->two_fm = value; 22211da177e4SLinus Torvalds if ((options & MT_ST_FAST_MTEOM) != 0) 22221da177e4SLinus Torvalds STp->fast_mteom = value; 22231da177e4SLinus Torvalds if ((options & MT_ST_AUTO_LOCK) != 0) 22241da177e4SLinus Torvalds STp->do_auto_lock = value; 22251da177e4SLinus Torvalds if ((options & MT_ST_CAN_BSR) != 0) 22261da177e4SLinus Torvalds STp->can_bsr = value; 22271da177e4SLinus Torvalds if ((options & MT_ST_NO_BLKLIMS) != 0) 22281da177e4SLinus Torvalds STp->omit_blklims = value; 22291da177e4SLinus Torvalds if ((STp->device)->scsi_level >= SCSI_2 && 22301da177e4SLinus Torvalds (options & MT_ST_CAN_PARTITIONS) != 0) 22311da177e4SLinus Torvalds STp->can_partitions = value; 22321da177e4SLinus Torvalds if ((options & MT_ST_SCSI2LOGICAL) != 0) 22331da177e4SLinus Torvalds STp->scsi2_logical = value; 22341da177e4SLinus Torvalds if ((options & MT_ST_NOWAIT) != 0) 22351da177e4SLinus Torvalds STp->immediate = value; 22361da177e4SLinus Torvalds if ((options & MT_ST_SYSV) != 0) 22371da177e4SLinus Torvalds STm->sysv = value; 223840f6b36cSKai Makisara if ((options & MT_ST_SILI) != 0) 223940f6b36cSKai Makisara STp->sili = value; 22401da177e4SLinus Torvalds DEB( 22411da177e4SLinus Torvalds if ((options & MT_ST_DEBUGGING) != 0) 22421da177e4SLinus Torvalds debugging = value; 22431da177e4SLinus Torvalds st_log_options(STp, STm, name); ) 22441da177e4SLinus Torvalds } else if (code == MT_ST_WRITE_THRESHOLD) { 22451da177e4SLinus Torvalds /* Retained for compatibility */ 22461da177e4SLinus Torvalds } else if (code == MT_ST_DEF_BLKSIZE) { 22471da177e4SLinus Torvalds value = (options & ~MT_ST_OPTIONS); 22481da177e4SLinus Torvalds if (value == ~MT_ST_OPTIONS) { 22491da177e4SLinus Torvalds STm->default_blksize = (-1); 22501da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name)); 22511da177e4SLinus Torvalds } else { 22521da177e4SLinus Torvalds STm->default_blksize = value; 22531da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n", 22541da177e4SLinus Torvalds name, STm->default_blksize)); 22551da177e4SLinus Torvalds if (STp->ready == ST_READY) { 22561da177e4SLinus Torvalds STp->blksize_changed = 0; 22571da177e4SLinus Torvalds set_mode_densblk(STp, STm); 22581da177e4SLinus Torvalds } 22591da177e4SLinus Torvalds } 22601da177e4SLinus Torvalds } else if (code == MT_ST_TIMEOUTS) { 22611da177e4SLinus Torvalds value = (options & ~MT_ST_OPTIONS); 22621da177e4SLinus Torvalds if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) { 22631da177e4SLinus Torvalds STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ; 22641da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name, 22651da177e4SLinus Torvalds (value & ~MT_ST_SET_LONG_TIMEOUT))); 22661da177e4SLinus Torvalds } else { 2267a02488edSJames Bottomley blk_queue_rq_timeout(STp->device->request_queue, 2268a02488edSJames Bottomley value * HZ); 22691da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n", 22701da177e4SLinus Torvalds name, value) ); 22711da177e4SLinus Torvalds } 22721da177e4SLinus Torvalds } else if (code == MT_ST_SET_CLN) { 22731da177e4SLinus Torvalds value = (options & ~MT_ST_OPTIONS) & 0xff; 22741da177e4SLinus Torvalds if (value != 0 && 22751da177e4SLinus Torvalds value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE) 22761da177e4SLinus Torvalds return (-EINVAL); 22771da177e4SLinus Torvalds STp->cln_mode = value; 22781da177e4SLinus Torvalds STp->cln_sense_mask = (options >> 8) & 0xff; 22791da177e4SLinus Torvalds STp->cln_sense_value = (options >> 16) & 0xff; 22801da177e4SLinus Torvalds printk(KERN_INFO 22811da177e4SLinus Torvalds "%s: Cleaning request mode %d, mask %02x, value %02x\n", 22821da177e4SLinus Torvalds name, value, STp->cln_sense_mask, STp->cln_sense_value); 22831da177e4SLinus Torvalds } else if (code == MT_ST_DEF_OPTIONS) { 22841da177e4SLinus Torvalds code = (options & ~MT_ST_CLEAR_DEFAULT); 22851da177e4SLinus Torvalds value = (options & MT_ST_CLEAR_DEFAULT); 22861da177e4SLinus Torvalds if (code == MT_ST_DEF_DENSITY) { 22871da177e4SLinus Torvalds if (value == MT_ST_CLEAR_DEFAULT) { 22881da177e4SLinus Torvalds STm->default_density = (-1); 22891da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Density default disabled.\n", 22901da177e4SLinus Torvalds name)); 22911da177e4SLinus Torvalds } else { 22921da177e4SLinus Torvalds STm->default_density = value & 0xff; 22931da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Density default set to %x\n", 22941da177e4SLinus Torvalds name, STm->default_density)); 22951da177e4SLinus Torvalds if (STp->ready == ST_READY) { 22961da177e4SLinus Torvalds STp->density_changed = 0; 22971da177e4SLinus Torvalds set_mode_densblk(STp, STm); 22981da177e4SLinus Torvalds } 22991da177e4SLinus Torvalds } 23001da177e4SLinus Torvalds } else if (code == MT_ST_DEF_DRVBUFFER) { 23011da177e4SLinus Torvalds if (value == MT_ST_CLEAR_DEFAULT) { 23021da177e4SLinus Torvalds STp->default_drvbuffer = 0xff; 23031da177e4SLinus Torvalds DEBC( printk(KERN_INFO 23041da177e4SLinus Torvalds "%s: Drive buffer default disabled.\n", name)); 23051da177e4SLinus Torvalds } else { 23061da177e4SLinus Torvalds STp->default_drvbuffer = value & 7; 23071da177e4SLinus Torvalds DEBC( printk(KERN_INFO 23081da177e4SLinus Torvalds "%s: Drive buffer default set to %x\n", 23091da177e4SLinus Torvalds name, STp->default_drvbuffer)); 23101da177e4SLinus Torvalds if (STp->ready == ST_READY) 23111da177e4SLinus Torvalds st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer); 23121da177e4SLinus Torvalds } 23131da177e4SLinus Torvalds } else if (code == MT_ST_DEF_COMPRESSION) { 23141da177e4SLinus Torvalds if (value == MT_ST_CLEAR_DEFAULT) { 23151da177e4SLinus Torvalds STm->default_compression = ST_DONT_TOUCH; 23161da177e4SLinus Torvalds DEBC( printk(KERN_INFO 23171da177e4SLinus Torvalds "%s: Compression default disabled.\n", name)); 23181da177e4SLinus Torvalds } else { 23191da177e4SLinus Torvalds if ((value & 0xff00) != 0) { 23201da177e4SLinus Torvalds STp->c_algo = (value & 0xff00) >> 8; 23211da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n", 23221da177e4SLinus Torvalds name, STp->c_algo)); 23231da177e4SLinus Torvalds } 23241da177e4SLinus Torvalds if ((value & 0xff) != 0xff) { 23251da177e4SLinus Torvalds STm->default_compression = (value & 1 ? ST_YES : ST_NO); 23261da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Compression default set to %x\n", 23271da177e4SLinus Torvalds name, (value & 1))); 23281da177e4SLinus Torvalds if (STp->ready == ST_READY) { 23291da177e4SLinus Torvalds STp->compression_changed = 0; 23301da177e4SLinus Torvalds st_compression(STp, (STm->default_compression == ST_YES)); 23311da177e4SLinus Torvalds } 23321da177e4SLinus Torvalds } 23331da177e4SLinus Torvalds } 23341da177e4SLinus Torvalds } 23351da177e4SLinus Torvalds } else 23361da177e4SLinus Torvalds return (-EIO); 23371da177e4SLinus Torvalds 23381da177e4SLinus Torvalds return 0; 23391da177e4SLinus Torvalds } 23401da177e4SLinus Torvalds 23411da177e4SLinus Torvalds #define MODE_HEADER_LENGTH 4 23421da177e4SLinus Torvalds 23431da177e4SLinus Torvalds /* Mode header and page byte offsets */ 23441da177e4SLinus Torvalds #define MH_OFF_DATA_LENGTH 0 23451da177e4SLinus Torvalds #define MH_OFF_MEDIUM_TYPE 1 23461da177e4SLinus Torvalds #define MH_OFF_DEV_SPECIFIC 2 23471da177e4SLinus Torvalds #define MH_OFF_BDESCS_LENGTH 3 23481da177e4SLinus Torvalds #define MP_OFF_PAGE_NBR 0 23491da177e4SLinus Torvalds #define MP_OFF_PAGE_LENGTH 1 23501da177e4SLinus Torvalds 23511da177e4SLinus Torvalds /* Mode header and page bit masks */ 23521da177e4SLinus Torvalds #define MH_BIT_WP 0x80 23531da177e4SLinus Torvalds #define MP_MSK_PAGE_NBR 0x3f 23541da177e4SLinus Torvalds 23551da177e4SLinus Torvalds /* Don't return block descriptors */ 23561da177e4SLinus Torvalds #define MODE_SENSE_OMIT_BDESCS 0x08 23571da177e4SLinus Torvalds 23581da177e4SLinus Torvalds #define MODE_SELECT_PAGE_FORMAT 0x10 23591da177e4SLinus Torvalds 23601da177e4SLinus Torvalds /* Read a mode page into the tape buffer. The block descriptors are included 23611da177e4SLinus Torvalds if incl_block_descs is true. The page control is ored to the page number 23621da177e4SLinus Torvalds parameter, if necessary. */ 23631da177e4SLinus Torvalds static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs) 23641da177e4SLinus Torvalds { 23651da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 23668b05b773SMike Christie struct st_request *SRpnt = NULL; 23671da177e4SLinus Torvalds 23681da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 23691da177e4SLinus Torvalds cmd[0] = MODE_SENSE; 23701da177e4SLinus Torvalds if (omit_block_descs) 23711da177e4SLinus Torvalds cmd[1] = MODE_SENSE_OMIT_BDESCS; 23721da177e4SLinus Torvalds cmd[2] = page; 23731da177e4SLinus Torvalds cmd[4] = 255; 23741da177e4SLinus Torvalds 23751da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, 2376a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 0, 1); 23771da177e4SLinus Torvalds if (SRpnt == NULL) 23781da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 23791da177e4SLinus Torvalds 23808b05b773SMike Christie st_release_request(SRpnt); 23811da177e4SLinus Torvalds 23821da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 23831da177e4SLinus Torvalds } 23841da177e4SLinus Torvalds 23851da177e4SLinus Torvalds 23861da177e4SLinus Torvalds /* Send the mode page in the tape buffer to the drive. Assumes that the mode data 23871da177e4SLinus Torvalds in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */ 23881da177e4SLinus Torvalds static int write_mode_page(struct scsi_tape *STp, int page, int slow) 23891da177e4SLinus Torvalds { 23901da177e4SLinus Torvalds int pgo; 23911da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 23928b05b773SMike Christie struct st_request *SRpnt = NULL; 23931da177e4SLinus Torvalds 23941da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 23951da177e4SLinus Torvalds cmd[0] = MODE_SELECT; 23961da177e4SLinus Torvalds cmd[1] = MODE_SELECT_PAGE_FORMAT; 23971da177e4SLinus Torvalds pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH]; 23981da177e4SLinus Torvalds cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2; 23991da177e4SLinus Torvalds 24001da177e4SLinus Torvalds /* Clear reserved fields */ 24011da177e4SLinus Torvalds (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0; 24021da177e4SLinus Torvalds (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0; 24031da177e4SLinus Torvalds (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP; 24041da177e4SLinus Torvalds (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR; 24051da177e4SLinus Torvalds 24061da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, 2407a02488edSJames Bottomley (slow ? STp->long_timeout : STp->device->request_queue->rq_timeout), 0, 1); 24081da177e4SLinus Torvalds if (SRpnt == NULL) 24091da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 24101da177e4SLinus Torvalds 24118b05b773SMike Christie st_release_request(SRpnt); 24121da177e4SLinus Torvalds 24131da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 24141da177e4SLinus Torvalds } 24151da177e4SLinus Torvalds 24161da177e4SLinus Torvalds 24171da177e4SLinus Torvalds #define COMPRESSION_PAGE 0x0f 24181da177e4SLinus Torvalds #define COMPRESSION_PAGE_LENGTH 16 24191da177e4SLinus Torvalds 24201da177e4SLinus Torvalds #define CP_OFF_DCE_DCC 2 24211da177e4SLinus Torvalds #define CP_OFF_C_ALGO 7 24221da177e4SLinus Torvalds 24231da177e4SLinus Torvalds #define DCE_MASK 0x80 24241da177e4SLinus Torvalds #define DCC_MASK 0x40 24251da177e4SLinus Torvalds #define RED_MASK 0x60 24261da177e4SLinus Torvalds 24271da177e4SLinus Torvalds 24281da177e4SLinus Torvalds /* Control the compression with mode page 15. Algorithm not changed if zero. 24291da177e4SLinus Torvalds 24301da177e4SLinus Torvalds The block descriptors are read and written because Sony SDT-7000 does not 24311da177e4SLinus Torvalds work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>). 24321da177e4SLinus Torvalds Including block descriptors should not cause any harm to other drives. */ 24331da177e4SLinus Torvalds 24341da177e4SLinus Torvalds static int st_compression(struct scsi_tape * STp, int state) 24351da177e4SLinus Torvalds { 24361da177e4SLinus Torvalds int retval; 24371da177e4SLinus Torvalds int mpoffs; /* Offset to mode page start */ 24381da177e4SLinus Torvalds unsigned char *b_data = (STp->buffer)->b_data; 24391da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 24401da177e4SLinus Torvalds 24411da177e4SLinus Torvalds if (STp->ready != ST_READY) 24421da177e4SLinus Torvalds return (-EIO); 24431da177e4SLinus Torvalds 24441da177e4SLinus Torvalds /* Read the current page contents */ 24451da177e4SLinus Torvalds retval = read_mode_page(STp, COMPRESSION_PAGE, 0); 24461da177e4SLinus Torvalds if (retval) { 24471da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n", 24481da177e4SLinus Torvalds name)); 24491da177e4SLinus Torvalds return (-EIO); 24501da177e4SLinus Torvalds } 24511da177e4SLinus Torvalds 24521da177e4SLinus Torvalds mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH]; 24531da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name, 24541da177e4SLinus Torvalds (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0))); 24551da177e4SLinus Torvalds 24561da177e4SLinus Torvalds /* Check if compression can be changed */ 24571da177e4SLinus Torvalds if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) { 24581da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name)); 24591da177e4SLinus Torvalds return (-EIO); 24601da177e4SLinus Torvalds } 24611da177e4SLinus Torvalds 24621da177e4SLinus Torvalds /* Do the change */ 24631da177e4SLinus Torvalds if (state) { 24641da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK; 24651da177e4SLinus Torvalds if (STp->c_algo != 0) 24661da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo; 24671da177e4SLinus Torvalds } 24681da177e4SLinus Torvalds else { 24691da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK; 24701da177e4SLinus Torvalds if (STp->c_algo != 0) 24711da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */ 24721da177e4SLinus Torvalds } 24731da177e4SLinus Torvalds 24741da177e4SLinus Torvalds retval = write_mode_page(STp, COMPRESSION_PAGE, 0); 24751da177e4SLinus Torvalds if (retval) { 24761da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name)); 24771da177e4SLinus Torvalds return (-EIO); 24781da177e4SLinus Torvalds } 24791da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n", 24801da177e4SLinus Torvalds name, state)); 24811da177e4SLinus Torvalds 24821da177e4SLinus Torvalds STp->compression_changed = 1; 24831da177e4SLinus Torvalds return 0; 24841da177e4SLinus Torvalds } 24851da177e4SLinus Torvalds 24861da177e4SLinus Torvalds 24871da177e4SLinus Torvalds /* Process the load and unload commands (does unload if the load code is zero) */ 24881da177e4SLinus Torvalds static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code) 24891da177e4SLinus Torvalds { 24901da177e4SLinus Torvalds int retval = (-EIO), timeout; 24911da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 24921da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 24931da177e4SLinus Torvalds struct st_partstat *STps; 24948b05b773SMike Christie struct st_request *SRpnt; 24951da177e4SLinus Torvalds 24961da177e4SLinus Torvalds if (STp->ready != ST_READY && !load_code) { 24971da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 24981da177e4SLinus Torvalds return (-ENOMEDIUM); 24991da177e4SLinus Torvalds else 25001da177e4SLinus Torvalds return (-EIO); 25011da177e4SLinus Torvalds } 25021da177e4SLinus Torvalds 25031da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 25041da177e4SLinus Torvalds cmd[0] = START_STOP; 25051da177e4SLinus Torvalds if (load_code) 25061da177e4SLinus Torvalds cmd[4] |= 1; 25071da177e4SLinus Torvalds /* 25081da177e4SLinus Torvalds * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A 25091da177e4SLinus Torvalds */ 25101da177e4SLinus Torvalds if (load_code >= 1 + MT_ST_HPLOADER_OFFSET 25111da177e4SLinus Torvalds && load_code <= 6 + MT_ST_HPLOADER_OFFSET) { 25121da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n", 25131da177e4SLinus Torvalds name, (cmd[4]) ? "" : "un", 25141da177e4SLinus Torvalds load_code - MT_ST_HPLOADER_OFFSET)); 25151da177e4SLinus Torvalds cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */ 25161da177e4SLinus Torvalds } 25171da177e4SLinus Torvalds if (STp->immediate) { 25181da177e4SLinus Torvalds cmd[1] = 1; /* Don't wait for completion */ 2519a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 25201da177e4SLinus Torvalds } 25211da177e4SLinus Torvalds else 25221da177e4SLinus Torvalds timeout = STp->long_timeout; 25231da177e4SLinus Torvalds 25241da177e4SLinus Torvalds DEBC( 25251da177e4SLinus Torvalds if (!load_code) 25261da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Unloading tape.\n", name); 25271da177e4SLinus Torvalds else 25281da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Loading tape.\n", name); 25291da177e4SLinus Torvalds ); 25301da177e4SLinus Torvalds 253115c920a6SFUJITA Tomonori SRpnt = st_allocate_request(STp); 25321da177e4SLinus Torvalds if (!SRpnt) 253315c920a6SFUJITA Tomonori return STp->buffer->syscall_result; 253415c920a6SFUJITA Tomonori 253515c920a6SFUJITA Tomonori retval = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0, timeout, 253615c920a6SFUJITA Tomonori MAX_RETRIES); 253715c920a6SFUJITA Tomonori if (retval) 253815c920a6SFUJITA Tomonori goto out; 25391da177e4SLinus Torvalds 25401da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 25411da177e4SLinus Torvalds 25421da177e4SLinus Torvalds if (!retval) { /* SCSI command successful */ 25431da177e4SLinus Torvalds 25441da177e4SLinus Torvalds if (!load_code) { 25451da177e4SLinus Torvalds STp->rew_at_close = 0; 25461da177e4SLinus Torvalds STp->ready = ST_NO_TAPE; 25471da177e4SLinus Torvalds } 25481da177e4SLinus Torvalds else { 25491da177e4SLinus Torvalds STp->rew_at_close = STp->autorew_dev; 25501da177e4SLinus Torvalds retval = check_tape(STp, filp); 25511da177e4SLinus Torvalds if (retval > 0) 25521da177e4SLinus Torvalds retval = 0; 25531da177e4SLinus Torvalds } 25541da177e4SLinus Torvalds } 25551da177e4SLinus Torvalds else { 25561da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 25571da177e4SLinus Torvalds STps->drv_file = STps->drv_block = (-1); 25581da177e4SLinus Torvalds } 255915c920a6SFUJITA Tomonori out: 256015c920a6SFUJITA Tomonori st_release_request(SRpnt); 25611da177e4SLinus Torvalds 25621da177e4SLinus Torvalds return retval; 25631da177e4SLinus Torvalds } 25641da177e4SLinus Torvalds 25651da177e4SLinus Torvalds #if DEBUG 25661da177e4SLinus Torvalds #define ST_DEB_FORWARD 0 25671da177e4SLinus Torvalds #define ST_DEB_BACKWARD 1 25681da177e4SLinus Torvalds static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd) 25691da177e4SLinus Torvalds { 25701da177e4SLinus Torvalds s32 sc; 25711da177e4SLinus Torvalds 25721da177e4SLinus Torvalds sc = cmd[2] & 0x80 ? 0xff000000 : 0; 25731da177e4SLinus Torvalds sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4]; 25741da177e4SLinus Torvalds if (direction) 25751da177e4SLinus Torvalds sc = -sc; 25761da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name, 25771da177e4SLinus Torvalds direction ? "backward" : "forward", sc, units); 25781da177e4SLinus Torvalds } 25791da177e4SLinus Torvalds #endif 25801da177e4SLinus Torvalds 25811da177e4SLinus Torvalds 25821da177e4SLinus Torvalds /* Internal ioctl function */ 25831da177e4SLinus Torvalds static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg) 25841da177e4SLinus Torvalds { 25851da177e4SLinus Torvalds int timeout; 25861da177e4SLinus Torvalds long ltmp; 25871da177e4SLinus Torvalds int ioctl_result; 25881da177e4SLinus Torvalds int chg_eof = 1; 25891da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 25908b05b773SMike Christie struct st_request *SRpnt; 25911da177e4SLinus Torvalds struct st_partstat *STps; 25921da177e4SLinus Torvalds int fileno, blkno, at_sm, undone; 25931da177e4SLinus Torvalds int datalen = 0, direction = DMA_NONE; 25941da177e4SLinus Torvalds char *name = tape_name(STp); 25951da177e4SLinus Torvalds 25961da177e4SLinus Torvalds WARN_ON(STp->buffer->do_dio != 0); 25971da177e4SLinus Torvalds if (STp->ready != ST_READY) { 25981da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 25991da177e4SLinus Torvalds return (-ENOMEDIUM); 26001da177e4SLinus Torvalds else 26011da177e4SLinus Torvalds return (-EIO); 26021da177e4SLinus Torvalds } 26031da177e4SLinus Torvalds timeout = STp->long_timeout; 26041da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 26051da177e4SLinus Torvalds fileno = STps->drv_file; 26061da177e4SLinus Torvalds blkno = STps->drv_block; 26071da177e4SLinus Torvalds at_sm = STps->at_sm; 26081da177e4SLinus Torvalds 26091da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 26101da177e4SLinus Torvalds switch (cmd_in) { 26111da177e4SLinus Torvalds case MTFSFM: 26121da177e4SLinus Torvalds chg_eof = 0; /* Changed from the FSF after this */ 26131da177e4SLinus Torvalds case MTFSF: 26141da177e4SLinus Torvalds cmd[0] = SPACE; 26151da177e4SLinus Torvalds cmd[1] = 0x01; /* Space FileMarks */ 26161da177e4SLinus Torvalds cmd[2] = (arg >> 16); 26171da177e4SLinus Torvalds cmd[3] = (arg >> 8); 26181da177e4SLinus Torvalds cmd[4] = arg; 26191da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);) 26201da177e4SLinus Torvalds if (fileno >= 0) 26211da177e4SLinus Torvalds fileno += arg; 26221da177e4SLinus Torvalds blkno = 0; 26231da177e4SLinus Torvalds at_sm &= (arg == 0); 26241da177e4SLinus Torvalds break; 26251da177e4SLinus Torvalds case MTBSFM: 26261da177e4SLinus Torvalds chg_eof = 0; /* Changed from the FSF after this */ 26271da177e4SLinus Torvalds case MTBSF: 26281da177e4SLinus Torvalds cmd[0] = SPACE; 26291da177e4SLinus Torvalds cmd[1] = 0x01; /* Space FileMarks */ 26301da177e4SLinus Torvalds ltmp = (-arg); 26311da177e4SLinus Torvalds cmd[2] = (ltmp >> 16); 26321da177e4SLinus Torvalds cmd[3] = (ltmp >> 8); 26331da177e4SLinus Torvalds cmd[4] = ltmp; 26341da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);) 26351da177e4SLinus Torvalds if (fileno >= 0) 26361da177e4SLinus Torvalds fileno -= arg; 26371da177e4SLinus Torvalds blkno = (-1); /* We can't know the block number */ 26381da177e4SLinus Torvalds at_sm &= (arg == 0); 26391da177e4SLinus Torvalds break; 26401da177e4SLinus Torvalds case MTFSR: 26411da177e4SLinus Torvalds cmd[0] = SPACE; 26421da177e4SLinus Torvalds cmd[1] = 0x00; /* Space Blocks */ 26431da177e4SLinus Torvalds cmd[2] = (arg >> 16); 26441da177e4SLinus Torvalds cmd[3] = (arg >> 8); 26451da177e4SLinus Torvalds cmd[4] = arg; 26461da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);) 26471da177e4SLinus Torvalds if (blkno >= 0) 26481da177e4SLinus Torvalds blkno += arg; 26491da177e4SLinus Torvalds at_sm &= (arg == 0); 26501da177e4SLinus Torvalds break; 26511da177e4SLinus Torvalds case MTBSR: 26521da177e4SLinus Torvalds cmd[0] = SPACE; 26531da177e4SLinus Torvalds cmd[1] = 0x00; /* Space Blocks */ 26541da177e4SLinus Torvalds ltmp = (-arg); 26551da177e4SLinus Torvalds cmd[2] = (ltmp >> 16); 26561da177e4SLinus Torvalds cmd[3] = (ltmp >> 8); 26571da177e4SLinus Torvalds cmd[4] = ltmp; 26581da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);) 26591da177e4SLinus Torvalds if (blkno >= 0) 26601da177e4SLinus Torvalds blkno -= arg; 26611da177e4SLinus Torvalds at_sm &= (arg == 0); 26621da177e4SLinus Torvalds break; 26631da177e4SLinus Torvalds case MTFSS: 26641da177e4SLinus Torvalds cmd[0] = SPACE; 26651da177e4SLinus Torvalds cmd[1] = 0x04; /* Space Setmarks */ 26661da177e4SLinus Torvalds cmd[2] = (arg >> 16); 26671da177e4SLinus Torvalds cmd[3] = (arg >> 8); 26681da177e4SLinus Torvalds cmd[4] = arg; 26691da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);) 26701da177e4SLinus Torvalds if (arg != 0) { 26711da177e4SLinus Torvalds blkno = fileno = (-1); 26721da177e4SLinus Torvalds at_sm = 1; 26731da177e4SLinus Torvalds } 26741da177e4SLinus Torvalds break; 26751da177e4SLinus Torvalds case MTBSS: 26761da177e4SLinus Torvalds cmd[0] = SPACE; 26771da177e4SLinus Torvalds cmd[1] = 0x04; /* Space Setmarks */ 26781da177e4SLinus Torvalds ltmp = (-arg); 26791da177e4SLinus Torvalds cmd[2] = (ltmp >> 16); 26801da177e4SLinus Torvalds cmd[3] = (ltmp >> 8); 26811da177e4SLinus Torvalds cmd[4] = ltmp; 26821da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);) 26831da177e4SLinus Torvalds if (arg != 0) { 26841da177e4SLinus Torvalds blkno = fileno = (-1); 26851da177e4SLinus Torvalds at_sm = 1; 26861da177e4SLinus Torvalds } 26871da177e4SLinus Torvalds break; 26881da177e4SLinus Torvalds case MTWEOF: 26891da177e4SLinus Torvalds case MTWSM: 26901da177e4SLinus Torvalds if (STp->write_prot) 26911da177e4SLinus Torvalds return (-EACCES); 26921da177e4SLinus Torvalds cmd[0] = WRITE_FILEMARKS; 26931da177e4SLinus Torvalds if (cmd_in == MTWSM) 26941da177e4SLinus Torvalds cmd[1] = 2; 26951da177e4SLinus Torvalds cmd[2] = (arg >> 16); 26961da177e4SLinus Torvalds cmd[3] = (arg >> 8); 26971da177e4SLinus Torvalds cmd[4] = arg; 2698a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 26991da177e4SLinus Torvalds DEBC( 27001da177e4SLinus Torvalds if (cmd_in == MTWEOF) 27011da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name, 27021da177e4SLinus Torvalds cmd[2] * 65536 + cmd[3] * 256 + cmd[4]); 27031da177e4SLinus Torvalds else 27041da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name, 27051da177e4SLinus Torvalds cmd[2] * 65536 + cmd[3] * 256 + cmd[4]); 27061da177e4SLinus Torvalds ) 27071da177e4SLinus Torvalds if (fileno >= 0) 27081da177e4SLinus Torvalds fileno += arg; 27091da177e4SLinus Torvalds blkno = 0; 27101da177e4SLinus Torvalds at_sm = (cmd_in == MTWSM); 27111da177e4SLinus Torvalds break; 27121da177e4SLinus Torvalds case MTREW: 27131da177e4SLinus Torvalds cmd[0] = REZERO_UNIT; 27141da177e4SLinus Torvalds if (STp->immediate) { 27151da177e4SLinus Torvalds cmd[1] = 1; /* Don't wait for completion */ 2716a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 27171da177e4SLinus Torvalds } 27181da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name)); 27191da177e4SLinus Torvalds fileno = blkno = at_sm = 0; 27201da177e4SLinus Torvalds break; 27211da177e4SLinus Torvalds case MTNOP: 27221da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name)); 27231da177e4SLinus Torvalds return 0; /* Should do something ? */ 27241da177e4SLinus Torvalds break; 27251da177e4SLinus Torvalds case MTRETEN: 27261da177e4SLinus Torvalds cmd[0] = START_STOP; 27271da177e4SLinus Torvalds if (STp->immediate) { 27281da177e4SLinus Torvalds cmd[1] = 1; /* Don't wait for completion */ 2729a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 27301da177e4SLinus Torvalds } 27311da177e4SLinus Torvalds cmd[4] = 3; 27321da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name)); 27331da177e4SLinus Torvalds fileno = blkno = at_sm = 0; 27341da177e4SLinus Torvalds break; 27351da177e4SLinus Torvalds case MTEOM: 27361da177e4SLinus Torvalds if (!STp->fast_mteom) { 27371da177e4SLinus Torvalds /* space to the end of tape */ 27381da177e4SLinus Torvalds ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff); 27391da177e4SLinus Torvalds fileno = STps->drv_file; 27401da177e4SLinus Torvalds if (STps->eof >= ST_EOD_1) 27411da177e4SLinus Torvalds return 0; 27421da177e4SLinus Torvalds /* The next lines would hide the number of spaced FileMarks 27431da177e4SLinus Torvalds That's why I inserted the previous lines. I had no luck 27441da177e4SLinus Torvalds with detecting EOM with FSF, so we go now to EOM. 27451da177e4SLinus Torvalds Joerg Weule */ 27461da177e4SLinus Torvalds } else 27471da177e4SLinus Torvalds fileno = (-1); 27481da177e4SLinus Torvalds cmd[0] = SPACE; 27491da177e4SLinus Torvalds cmd[1] = 3; 27501da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n", 27511da177e4SLinus Torvalds name)); 27521da177e4SLinus Torvalds blkno = -1; 27531da177e4SLinus Torvalds at_sm = 0; 27541da177e4SLinus Torvalds break; 27551da177e4SLinus Torvalds case MTERASE: 27561da177e4SLinus Torvalds if (STp->write_prot) 27571da177e4SLinus Torvalds return (-EACCES); 27581da177e4SLinus Torvalds cmd[0] = ERASE; 27591da177e4SLinus Torvalds cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */ 27601da177e4SLinus Torvalds if (STp->immediate) { 27611da177e4SLinus Torvalds cmd[1] |= 2; /* Don't wait for completion */ 2762a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 27631da177e4SLinus Torvalds } 27641da177e4SLinus Torvalds else 27651da177e4SLinus Torvalds timeout = STp->long_timeout * 8; 27661da177e4SLinus Torvalds 27671da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name)); 27681da177e4SLinus Torvalds fileno = blkno = at_sm = 0; 27691da177e4SLinus Torvalds break; 27701da177e4SLinus Torvalds case MTSETBLK: /* Set block length */ 27711da177e4SLinus Torvalds case MTSETDENSITY: /* Set tape density */ 27721da177e4SLinus Torvalds case MTSETDRVBUFFER: /* Set drive buffering */ 27731da177e4SLinus Torvalds case SET_DENS_AND_BLK: /* Set density and block size */ 27741da177e4SLinus Torvalds chg_eof = 0; 27751da177e4SLinus Torvalds if (STp->dirty || (STp->buffer)->buffer_bytes != 0) 27761da177e4SLinus Torvalds return (-EIO); /* Not allowed if data in buffer */ 27771da177e4SLinus Torvalds if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) && 27781da177e4SLinus Torvalds (arg & MT_ST_BLKSIZE_MASK) != 0 && 27791da177e4SLinus Torvalds STp->max_block > 0 && 27801da177e4SLinus Torvalds ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block || 27811da177e4SLinus Torvalds (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) { 27821da177e4SLinus Torvalds printk(KERN_WARNING "%s: Illegal block size.\n", name); 27831da177e4SLinus Torvalds return (-EINVAL); 27841da177e4SLinus Torvalds } 27851da177e4SLinus Torvalds cmd[0] = MODE_SELECT; 27861da177e4SLinus Torvalds if ((STp->use_pf & USE_PF)) 27871da177e4SLinus Torvalds cmd[1] = MODE_SELECT_PAGE_FORMAT; 27881da177e4SLinus Torvalds cmd[4] = datalen = 12; 27891da177e4SLinus Torvalds direction = DMA_TO_DEVICE; 27901da177e4SLinus Torvalds 27911da177e4SLinus Torvalds memset((STp->buffer)->b_data, 0, 12); 27921da177e4SLinus Torvalds if (cmd_in == MTSETDRVBUFFER) 27931da177e4SLinus Torvalds (STp->buffer)->b_data[2] = (arg & 7) << 4; 27941da177e4SLinus Torvalds else 27951da177e4SLinus Torvalds (STp->buffer)->b_data[2] = 27961da177e4SLinus Torvalds STp->drv_buffer << 4; 27971da177e4SLinus Torvalds (STp->buffer)->b_data[3] = 8; /* block descriptor length */ 27981da177e4SLinus Torvalds if (cmd_in == MTSETDENSITY) { 27991da177e4SLinus Torvalds (STp->buffer)->b_data[4] = arg; 28001da177e4SLinus Torvalds STp->density_changed = 1; /* At least we tried ;-) */ 28011da177e4SLinus Torvalds } else if (cmd_in == SET_DENS_AND_BLK) 28021da177e4SLinus Torvalds (STp->buffer)->b_data[4] = arg >> 24; 28031da177e4SLinus Torvalds else 28041da177e4SLinus Torvalds (STp->buffer)->b_data[4] = STp->density; 28051da177e4SLinus Torvalds if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) { 28061da177e4SLinus Torvalds ltmp = arg & MT_ST_BLKSIZE_MASK; 28071da177e4SLinus Torvalds if (cmd_in == MTSETBLK) 28081da177e4SLinus Torvalds STp->blksize_changed = 1; /* At least we tried ;-) */ 28091da177e4SLinus Torvalds } else 28101da177e4SLinus Torvalds ltmp = STp->block_size; 28111da177e4SLinus Torvalds (STp->buffer)->b_data[9] = (ltmp >> 16); 28121da177e4SLinus Torvalds (STp->buffer)->b_data[10] = (ltmp >> 8); 28131da177e4SLinus Torvalds (STp->buffer)->b_data[11] = ltmp; 2814a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 28151da177e4SLinus Torvalds DEBC( 28161da177e4SLinus Torvalds if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) 28171da177e4SLinus Torvalds printk(ST_DEB_MSG 28181da177e4SLinus Torvalds "%s: Setting block size to %d bytes.\n", name, 28191da177e4SLinus Torvalds (STp->buffer)->b_data[9] * 65536 + 28201da177e4SLinus Torvalds (STp->buffer)->b_data[10] * 256 + 28211da177e4SLinus Torvalds (STp->buffer)->b_data[11]); 28221da177e4SLinus Torvalds if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK) 28231da177e4SLinus Torvalds printk(ST_DEB_MSG 28241da177e4SLinus Torvalds "%s: Setting density code to %x.\n", name, 28251da177e4SLinus Torvalds (STp->buffer)->b_data[4]); 28261da177e4SLinus Torvalds if (cmd_in == MTSETDRVBUFFER) 28271da177e4SLinus Torvalds printk(ST_DEB_MSG 28281da177e4SLinus Torvalds "%s: Setting drive buffer code to %d.\n", name, 28291da177e4SLinus Torvalds ((STp->buffer)->b_data[2] >> 4) & 7); 28301da177e4SLinus Torvalds ) 28311da177e4SLinus Torvalds break; 28321da177e4SLinus Torvalds default: 28331da177e4SLinus Torvalds return (-ENOSYS); 28341da177e4SLinus Torvalds } 28351da177e4SLinus Torvalds 28361da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction, 28371da177e4SLinus Torvalds timeout, MAX_RETRIES, 1); 28381da177e4SLinus Torvalds if (!SRpnt) 28391da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 28401da177e4SLinus Torvalds 28411da177e4SLinus Torvalds ioctl_result = (STp->buffer)->syscall_result; 28421da177e4SLinus Torvalds 28431da177e4SLinus Torvalds if (!ioctl_result) { /* SCSI command successful */ 28448b05b773SMike Christie st_release_request(SRpnt); 28451da177e4SLinus Torvalds SRpnt = NULL; 28461da177e4SLinus Torvalds STps->drv_block = blkno; 28471da177e4SLinus Torvalds STps->drv_file = fileno; 28481da177e4SLinus Torvalds STps->at_sm = at_sm; 28491da177e4SLinus Torvalds 28501da177e4SLinus Torvalds if (cmd_in == MTBSFM) 28511da177e4SLinus Torvalds ioctl_result = st_int_ioctl(STp, MTFSF, 1); 28521da177e4SLinus Torvalds else if (cmd_in == MTFSFM) 28531da177e4SLinus Torvalds ioctl_result = st_int_ioctl(STp, MTBSF, 1); 28541da177e4SLinus Torvalds 28551da177e4SLinus Torvalds if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) { 28561da177e4SLinus Torvalds int old_block_size = STp->block_size; 28571da177e4SLinus Torvalds STp->block_size = arg & MT_ST_BLKSIZE_MASK; 28581da177e4SLinus Torvalds if (STp->block_size != 0) { 28591da177e4SLinus Torvalds if (old_block_size == 0) 28601da177e4SLinus Torvalds normalize_buffer(STp->buffer); 28611da177e4SLinus Torvalds (STp->buffer)->buffer_blocks = 28621da177e4SLinus Torvalds (STp->buffer)->buffer_size / STp->block_size; 28631da177e4SLinus Torvalds } 28641da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0; 28651da177e4SLinus Torvalds if (cmd_in == SET_DENS_AND_BLK) 28661da177e4SLinus Torvalds STp->density = arg >> MT_ST_DENSITY_SHIFT; 28671da177e4SLinus Torvalds } else if (cmd_in == MTSETDRVBUFFER) 28681da177e4SLinus Torvalds STp->drv_buffer = (arg & 7); 28691da177e4SLinus Torvalds else if (cmd_in == MTSETDENSITY) 28701da177e4SLinus Torvalds STp->density = arg; 28711da177e4SLinus Torvalds 28721da177e4SLinus Torvalds if (cmd_in == MTEOM) 28731da177e4SLinus Torvalds STps->eof = ST_EOD; 28741da177e4SLinus Torvalds else if (cmd_in == MTFSF) 28751da177e4SLinus Torvalds STps->eof = ST_FM; 28761da177e4SLinus Torvalds else if (chg_eof) 28771da177e4SLinus Torvalds STps->eof = ST_NOEOF; 28781da177e4SLinus Torvalds 28791da177e4SLinus Torvalds if (cmd_in == MTWEOF) 28801da177e4SLinus Torvalds STps->rw = ST_IDLE; 28811da177e4SLinus Torvalds } else { /* SCSI command was not completely successful. Don't return 28821da177e4SLinus Torvalds from this block without releasing the SCSI command block! */ 28831da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 28841da177e4SLinus Torvalds 28851da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_EOM) { 28861da177e4SLinus Torvalds if (cmd_in != MTBSF && cmd_in != MTBSFM && 28871da177e4SLinus Torvalds cmd_in != MTBSR && cmd_in != MTBSS) 28881da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 28891da177e4SLinus Torvalds STps->drv_block = 0; 28901da177e4SLinus Torvalds } 28911da177e4SLinus Torvalds 28921da177e4SLinus Torvalds if (cmdstatp->remainder_valid) 28931da177e4SLinus Torvalds undone = (int)cmdstatp->uremainder64; 28941da177e4SLinus Torvalds else 28951da177e4SLinus Torvalds undone = 0; 28961da177e4SLinus Torvalds 28971da177e4SLinus Torvalds if (cmd_in == MTWEOF && 28981da177e4SLinus Torvalds cmdstatp->have_sense && 289991614c05SKai Makisara (cmdstatp->flags & SENSE_EOM)) { 290091614c05SKai Makisara if (cmdstatp->sense_hdr.sense_key == NO_SENSE || 290191614c05SKai Makisara cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) { 290291614c05SKai Makisara ioctl_result = 0; /* EOF(s) written successfully at EOM */ 29031da177e4SLinus Torvalds STps->eof = ST_NOEOF; 290491614c05SKai Makisara } else { /* Writing EOF(s) failed */ 290591614c05SKai Makisara if (fileno >= 0) 290691614c05SKai Makisara fileno -= undone; 290791614c05SKai Makisara if (undone < arg) 290891614c05SKai Makisara STps->eof = ST_NOEOF; 290991614c05SKai Makisara } 291091614c05SKai Makisara STps->drv_file = fileno; 29111da177e4SLinus Torvalds } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) { 29121da177e4SLinus Torvalds if (fileno >= 0) 29131da177e4SLinus Torvalds STps->drv_file = fileno - undone; 29141da177e4SLinus Torvalds else 29151da177e4SLinus Torvalds STps->drv_file = fileno; 29161da177e4SLinus Torvalds STps->drv_block = -1; 29171da177e4SLinus Torvalds STps->eof = ST_NOEOF; 29181da177e4SLinus Torvalds } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) { 29191da177e4SLinus Torvalds if (arg > 0 && undone < 0) /* Some drives get this wrong */ 29201da177e4SLinus Torvalds undone = (-undone); 29211da177e4SLinus Torvalds if (STps->drv_file >= 0) 29221da177e4SLinus Torvalds STps->drv_file = fileno + undone; 29231da177e4SLinus Torvalds STps->drv_block = 0; 29241da177e4SLinus Torvalds STps->eof = ST_NOEOF; 29251da177e4SLinus Torvalds } else if (cmd_in == MTFSR) { 29261da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */ 29271da177e4SLinus Torvalds if (STps->drv_file >= 0) 29281da177e4SLinus Torvalds STps->drv_file++; 29291da177e4SLinus Torvalds STps->drv_block = 0; 29301da177e4SLinus Torvalds STps->eof = ST_FM; 29311da177e4SLinus Torvalds } else { 29321da177e4SLinus Torvalds if (blkno >= undone) 29331da177e4SLinus Torvalds STps->drv_block = blkno - undone; 29341da177e4SLinus Torvalds else 29351da177e4SLinus Torvalds STps->drv_block = (-1); 29361da177e4SLinus Torvalds STps->eof = ST_NOEOF; 29371da177e4SLinus Torvalds } 29381da177e4SLinus Torvalds } else if (cmd_in == MTBSR) { 29391da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */ 29401da177e4SLinus Torvalds STps->drv_file--; 29411da177e4SLinus Torvalds STps->drv_block = (-1); 29421da177e4SLinus Torvalds } else { 29431da177e4SLinus Torvalds if (arg > 0 && undone < 0) /* Some drives get this wrong */ 29441da177e4SLinus Torvalds undone = (-undone); 29451da177e4SLinus Torvalds if (STps->drv_block >= 0) 29461da177e4SLinus Torvalds STps->drv_block = blkno + undone; 29471da177e4SLinus Torvalds } 29481da177e4SLinus Torvalds STps->eof = ST_NOEOF; 29491da177e4SLinus Torvalds } else if (cmd_in == MTEOM) { 29501da177e4SLinus Torvalds STps->drv_file = (-1); 29511da177e4SLinus Torvalds STps->drv_block = (-1); 29521da177e4SLinus Torvalds STps->eof = ST_EOD; 29531da177e4SLinus Torvalds } else if (cmd_in == MTSETBLK || 29541da177e4SLinus Torvalds cmd_in == MTSETDENSITY || 29551da177e4SLinus Torvalds cmd_in == MTSETDRVBUFFER || 29561da177e4SLinus Torvalds cmd_in == SET_DENS_AND_BLK) { 29571da177e4SLinus Torvalds if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST && 29581da177e4SLinus Torvalds !(STp->use_pf & PF_TESTED)) { 29591da177e4SLinus Torvalds /* Try the other possible state of Page Format if not 29601da177e4SLinus Torvalds already tried */ 29611da177e4SLinus Torvalds STp->use_pf = !STp->use_pf | PF_TESTED; 29628b05b773SMike Christie st_release_request(SRpnt); 29631da177e4SLinus Torvalds SRpnt = NULL; 29641da177e4SLinus Torvalds return st_int_ioctl(STp, cmd_in, arg); 29651da177e4SLinus Torvalds } 29661da177e4SLinus Torvalds } else if (chg_eof) 29671da177e4SLinus Torvalds STps->eof = ST_NOEOF; 29681da177e4SLinus Torvalds 29691da177e4SLinus Torvalds if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK) 29701da177e4SLinus Torvalds STps->eof = ST_EOD; 29711da177e4SLinus Torvalds 29728b05b773SMike Christie st_release_request(SRpnt); 29731da177e4SLinus Torvalds SRpnt = NULL; 29741da177e4SLinus Torvalds } 29751da177e4SLinus Torvalds 29761da177e4SLinus Torvalds return ioctl_result; 29771da177e4SLinus Torvalds } 29781da177e4SLinus Torvalds 29791da177e4SLinus Torvalds 29801da177e4SLinus Torvalds /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc 29811da177e4SLinus Torvalds structure. */ 29821da177e4SLinus Torvalds 29831da177e4SLinus Torvalds static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition, 29841da177e4SLinus Torvalds int logical) 29851da177e4SLinus Torvalds { 29861da177e4SLinus Torvalds int result; 29871da177e4SLinus Torvalds unsigned char scmd[MAX_COMMAND_SIZE]; 29888b05b773SMike Christie struct st_request *SRpnt; 29891da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 29901da177e4SLinus Torvalds 29911da177e4SLinus Torvalds if (STp->ready != ST_READY) 29921da177e4SLinus Torvalds return (-EIO); 29931da177e4SLinus Torvalds 29941da177e4SLinus Torvalds memset(scmd, 0, MAX_COMMAND_SIZE); 29951da177e4SLinus Torvalds if ((STp->device)->scsi_level < SCSI_2) { 29961da177e4SLinus Torvalds scmd[0] = QFA_REQUEST_BLOCK; 29971da177e4SLinus Torvalds scmd[4] = 3; 29981da177e4SLinus Torvalds } else { 29991da177e4SLinus Torvalds scmd[0] = READ_POSITION; 30001da177e4SLinus Torvalds if (!logical && !STp->scsi2_logical) 30011da177e4SLinus Torvalds scmd[1] = 1; 30021da177e4SLinus Torvalds } 30031da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE, 3004a02488edSJames Bottomley STp->device->request_queue->rq_timeout, 3005a02488edSJames Bottomley MAX_READY_RETRIES, 1); 30061da177e4SLinus Torvalds if (!SRpnt) 30071da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 30081da177e4SLinus Torvalds 30091da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0 || 30101da177e4SLinus Torvalds (STp->device->scsi_level >= SCSI_2 && 30111da177e4SLinus Torvalds ((STp->buffer)->b_data[0] & 4) != 0)) { 30121da177e4SLinus Torvalds *block = *partition = 0; 30131da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name)); 30141da177e4SLinus Torvalds result = (-EIO); 30151da177e4SLinus Torvalds } else { 30161da177e4SLinus Torvalds result = 0; 30171da177e4SLinus Torvalds if ((STp->device)->scsi_level < SCSI_2) { 30181da177e4SLinus Torvalds *block = ((STp->buffer)->b_data[0] << 16) 30191da177e4SLinus Torvalds + ((STp->buffer)->b_data[1] << 8) 30201da177e4SLinus Torvalds + (STp->buffer)->b_data[2]; 30211da177e4SLinus Torvalds *partition = 0; 30221da177e4SLinus Torvalds } else { 30231da177e4SLinus Torvalds *block = ((STp->buffer)->b_data[4] << 24) 30241da177e4SLinus Torvalds + ((STp->buffer)->b_data[5] << 16) 30251da177e4SLinus Torvalds + ((STp->buffer)->b_data[6] << 8) 30261da177e4SLinus Torvalds + (STp->buffer)->b_data[7]; 30271da177e4SLinus Torvalds *partition = (STp->buffer)->b_data[1]; 30281da177e4SLinus Torvalds if (((STp->buffer)->b_data[0] & 0x80) && 30291da177e4SLinus Torvalds (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */ 30301da177e4SLinus Torvalds STp->ps[0].drv_block = STp->ps[0].drv_file = 0; 30311da177e4SLinus Torvalds } 30321da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name, 30331da177e4SLinus Torvalds *block, *partition)); 30341da177e4SLinus Torvalds } 30358b05b773SMike Christie st_release_request(SRpnt); 30361da177e4SLinus Torvalds SRpnt = NULL; 30371da177e4SLinus Torvalds 30381da177e4SLinus Torvalds return result; 30391da177e4SLinus Torvalds } 30401da177e4SLinus Torvalds 30411da177e4SLinus Torvalds 30421da177e4SLinus Torvalds /* Set the tape block and partition. Negative partition means that only the 30431da177e4SLinus Torvalds block should be set in vendor specific way. */ 30441da177e4SLinus Torvalds static int set_location(struct scsi_tape *STp, unsigned int block, int partition, 30451da177e4SLinus Torvalds int logical) 30461da177e4SLinus Torvalds { 30471da177e4SLinus Torvalds struct st_partstat *STps; 30481da177e4SLinus Torvalds int result, p; 30491da177e4SLinus Torvalds unsigned int blk; 30501da177e4SLinus Torvalds int timeout; 30511da177e4SLinus Torvalds unsigned char scmd[MAX_COMMAND_SIZE]; 30528b05b773SMike Christie struct st_request *SRpnt; 30531da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 30541da177e4SLinus Torvalds 30551da177e4SLinus Torvalds if (STp->ready != ST_READY) 30561da177e4SLinus Torvalds return (-EIO); 30571da177e4SLinus Torvalds timeout = STp->long_timeout; 30581da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 30591da177e4SLinus Torvalds 30601da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n", 30611da177e4SLinus Torvalds name, block, partition)); 30621da177e4SLinus Torvalds DEB(if (partition < 0) 30631da177e4SLinus Torvalds return (-EIO); ) 30641da177e4SLinus Torvalds 30651da177e4SLinus Torvalds /* Update the location at the partition we are leaving */ 30661da177e4SLinus Torvalds if ((!STp->can_partitions && partition != 0) || 30671da177e4SLinus Torvalds partition >= ST_NBR_PARTITIONS) 30681da177e4SLinus Torvalds return (-EINVAL); 30691da177e4SLinus Torvalds if (partition != STp->partition) { 30701da177e4SLinus Torvalds if (get_location(STp, &blk, &p, 1)) 30711da177e4SLinus Torvalds STps->last_block_valid = 0; 30721da177e4SLinus Torvalds else { 30731da177e4SLinus Torvalds STps->last_block_valid = 1; 30741da177e4SLinus Torvalds STps->last_block_visited = blk; 30751da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 30761da177e4SLinus Torvalds "%s: Visited block %d for partition %d saved.\n", 30771da177e4SLinus Torvalds name, blk, STp->partition)); 30781da177e4SLinus Torvalds } 30791da177e4SLinus Torvalds } 30801da177e4SLinus Torvalds 30811da177e4SLinus Torvalds memset(scmd, 0, MAX_COMMAND_SIZE); 30821da177e4SLinus Torvalds if ((STp->device)->scsi_level < SCSI_2) { 30831da177e4SLinus Torvalds scmd[0] = QFA_SEEK_BLOCK; 30841da177e4SLinus Torvalds scmd[2] = (block >> 16); 30851da177e4SLinus Torvalds scmd[3] = (block >> 8); 30861da177e4SLinus Torvalds scmd[4] = block; 30871da177e4SLinus Torvalds scmd[5] = 0; 30881da177e4SLinus Torvalds } else { 30891da177e4SLinus Torvalds scmd[0] = SEEK_10; 30901da177e4SLinus Torvalds scmd[3] = (block >> 24); 30911da177e4SLinus Torvalds scmd[4] = (block >> 16); 30921da177e4SLinus Torvalds scmd[5] = (block >> 8); 30931da177e4SLinus Torvalds scmd[6] = block; 30941da177e4SLinus Torvalds if (!logical && !STp->scsi2_logical) 30951da177e4SLinus Torvalds scmd[1] = 4; 30961da177e4SLinus Torvalds if (STp->partition != partition) { 30971da177e4SLinus Torvalds scmd[1] |= 2; 30981da177e4SLinus Torvalds scmd[8] = partition; 30991da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 31001da177e4SLinus Torvalds "%s: Trying to change partition from %d to %d\n", 31011da177e4SLinus Torvalds name, STp->partition, partition)); 31021da177e4SLinus Torvalds } 31031da177e4SLinus Torvalds } 31041da177e4SLinus Torvalds if (STp->immediate) { 31051da177e4SLinus Torvalds scmd[1] |= 1; /* Don't wait for completion */ 3106a02488edSJames Bottomley timeout = STp->device->request_queue->rq_timeout; 31071da177e4SLinus Torvalds } 31081da177e4SLinus Torvalds 31093c0bf16cSFUJITA Tomonori SRpnt = st_allocate_request(STp); 31101da177e4SLinus Torvalds if (!SRpnt) 31113c0bf16cSFUJITA Tomonori return STp->buffer->syscall_result; 31123c0bf16cSFUJITA Tomonori 31133c0bf16cSFUJITA Tomonori result = st_scsi_kern_execute(SRpnt, scmd, DMA_NONE, NULL, 0, 31143c0bf16cSFUJITA Tomonori timeout, MAX_READY_RETRIES); 31153c0bf16cSFUJITA Tomonori if (result) 31163c0bf16cSFUJITA Tomonori goto out; 31171da177e4SLinus Torvalds 31181da177e4SLinus Torvalds STps->drv_block = STps->drv_file = (-1); 31191da177e4SLinus Torvalds STps->eof = ST_NOEOF; 31201da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0) { 31211da177e4SLinus Torvalds result = (-EIO); 31221da177e4SLinus Torvalds if (STp->can_partitions && 31231da177e4SLinus Torvalds (STp->device)->scsi_level >= SCSI_2 && 31241da177e4SLinus Torvalds (p = find_partition(STp)) >= 0) 31251da177e4SLinus Torvalds STp->partition = p; 31261da177e4SLinus Torvalds } else { 31271da177e4SLinus Torvalds if (STp->can_partitions) { 31281da177e4SLinus Torvalds STp->partition = partition; 31291da177e4SLinus Torvalds STps = &(STp->ps[partition]); 31301da177e4SLinus Torvalds if (!STps->last_block_valid || 31311da177e4SLinus Torvalds STps->last_block_visited != block) { 31321da177e4SLinus Torvalds STps->at_sm = 0; 31331da177e4SLinus Torvalds STps->rw = ST_IDLE; 31341da177e4SLinus Torvalds } 31351da177e4SLinus Torvalds } else 31361da177e4SLinus Torvalds STps->at_sm = 0; 31371da177e4SLinus Torvalds if (block == 0) 31381da177e4SLinus Torvalds STps->drv_block = STps->drv_file = 0; 31391da177e4SLinus Torvalds result = 0; 31401da177e4SLinus Torvalds } 31413c0bf16cSFUJITA Tomonori out: 31428b05b773SMike Christie st_release_request(SRpnt); 31431da177e4SLinus Torvalds SRpnt = NULL; 31441da177e4SLinus Torvalds 31451da177e4SLinus Torvalds return result; 31461da177e4SLinus Torvalds } 31471da177e4SLinus Torvalds 31481da177e4SLinus Torvalds 31491da177e4SLinus Torvalds /* Find the current partition number for the drive status. Called from open and 31501da177e4SLinus Torvalds returns either partition number of negative error code. */ 31511da177e4SLinus Torvalds static int find_partition(struct scsi_tape *STp) 31521da177e4SLinus Torvalds { 31531da177e4SLinus Torvalds int i, partition; 31541da177e4SLinus Torvalds unsigned int block; 31551da177e4SLinus Torvalds 31561da177e4SLinus Torvalds if ((i = get_location(STp, &block, &partition, 1)) < 0) 31571da177e4SLinus Torvalds return i; 31581da177e4SLinus Torvalds if (partition >= ST_NBR_PARTITIONS) 31591da177e4SLinus Torvalds return (-EIO); 31601da177e4SLinus Torvalds return partition; 31611da177e4SLinus Torvalds } 31621da177e4SLinus Torvalds 31631da177e4SLinus Torvalds 31641da177e4SLinus Torvalds /* Change the partition if necessary */ 31651da177e4SLinus Torvalds static int switch_partition(struct scsi_tape *STp) 31661da177e4SLinus Torvalds { 31671da177e4SLinus Torvalds struct st_partstat *STps; 31681da177e4SLinus Torvalds 31691da177e4SLinus Torvalds if (STp->partition == STp->new_partition) 31701da177e4SLinus Torvalds return 0; 31711da177e4SLinus Torvalds STps = &(STp->ps[STp->new_partition]); 31721da177e4SLinus Torvalds if (!STps->last_block_valid) 31731da177e4SLinus Torvalds STps->last_block_visited = 0; 31741da177e4SLinus Torvalds return set_location(STp, STps->last_block_visited, STp->new_partition, 1); 31751da177e4SLinus Torvalds } 31761da177e4SLinus Torvalds 31771da177e4SLinus Torvalds /* Functions for reading and writing the medium partition mode page. */ 31781da177e4SLinus Torvalds 31791da177e4SLinus Torvalds #define PART_PAGE 0x11 31801da177e4SLinus Torvalds #define PART_PAGE_FIXED_LENGTH 8 31811da177e4SLinus Torvalds 31821da177e4SLinus Torvalds #define PP_OFF_MAX_ADD_PARTS 2 31831da177e4SLinus Torvalds #define PP_OFF_NBR_ADD_PARTS 3 31841da177e4SLinus Torvalds #define PP_OFF_FLAGS 4 31851da177e4SLinus Torvalds #define PP_OFF_PART_UNITS 6 31861da177e4SLinus Torvalds #define PP_OFF_RESERVED 7 31871da177e4SLinus Torvalds 31881da177e4SLinus Torvalds #define PP_BIT_IDP 0x20 31891da177e4SLinus Torvalds #define PP_MSK_PSUM_MB 0x10 31901da177e4SLinus Torvalds 31911da177e4SLinus Torvalds /* Get the number of partitions on the tape. As a side effect reads the 31921da177e4SLinus Torvalds mode page into the tape buffer. */ 31931da177e4SLinus Torvalds static int nbr_partitions(struct scsi_tape *STp) 31941da177e4SLinus Torvalds { 31951da177e4SLinus Torvalds int result; 31961da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 31971da177e4SLinus Torvalds 31981da177e4SLinus Torvalds if (STp->ready != ST_READY) 31991da177e4SLinus Torvalds return (-EIO); 32001da177e4SLinus Torvalds 32011da177e4SLinus Torvalds result = read_mode_page(STp, PART_PAGE, 1); 32021da177e4SLinus Torvalds 32031da177e4SLinus Torvalds if (result) { 32041da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n", 32051da177e4SLinus Torvalds name)); 32061da177e4SLinus Torvalds result = (-EIO); 32071da177e4SLinus Torvalds } else { 32081da177e4SLinus Torvalds result = (STp->buffer)->b_data[MODE_HEADER_LENGTH + 32091da177e4SLinus Torvalds PP_OFF_NBR_ADD_PARTS] + 1; 32101da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result)); 32111da177e4SLinus Torvalds } 32121da177e4SLinus Torvalds 32131da177e4SLinus Torvalds return result; 32141da177e4SLinus Torvalds } 32151da177e4SLinus Torvalds 32161da177e4SLinus Torvalds 32171da177e4SLinus Torvalds /* Partition the tape into two partitions if size > 0 or one partition if 32181da177e4SLinus Torvalds size == 0. 32191da177e4SLinus Torvalds 32201da177e4SLinus Torvalds The block descriptors are read and written because Sony SDT-7000 does not 32211da177e4SLinus Torvalds work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>). 32221da177e4SLinus Torvalds 32231da177e4SLinus Torvalds My HP C1533A drive returns only one partition size field. This is used to 32241da177e4SLinus Torvalds set the size of partition 1. There is no size field for the default partition. 32251da177e4SLinus Torvalds Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is 32261da177e4SLinus Torvalds used to set the size of partition 1 (this is what the SCSI-3 standard specifies). 32271da177e4SLinus Torvalds The following algorithm is used to accommodate both drives: if the number of 32281da177e4SLinus Torvalds partition size fields is greater than the maximum number of additional partitions 32291da177e4SLinus Torvalds in the mode page, the second field is used. Otherwise the first field is used. 32301da177e4SLinus Torvalds 32311da177e4SLinus Torvalds For Seagate DDS drives the page length must be 8 when no partitions is defined 32321da177e4SLinus Torvalds and 10 when 1 partition is defined (information from Eric Lee Green). This is 32331da177e4SLinus Torvalds is acceptable also to some other old drives and enforced if the first partition 32341da177e4SLinus Torvalds size field is used for the first additional partition size. 32351da177e4SLinus Torvalds */ 32361da177e4SLinus Torvalds static int partition_tape(struct scsi_tape *STp, int size) 32371da177e4SLinus Torvalds { 32381da177e4SLinus Torvalds char *name = tape_name(STp); 32391da177e4SLinus Torvalds int result; 32401da177e4SLinus Torvalds int pgo, psd_cnt, psdo; 32411da177e4SLinus Torvalds unsigned char *bp; 32421da177e4SLinus Torvalds 32431da177e4SLinus Torvalds result = read_mode_page(STp, PART_PAGE, 0); 32441da177e4SLinus Torvalds if (result) { 32451da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name)); 32461da177e4SLinus Torvalds return result; 32471da177e4SLinus Torvalds } 32481da177e4SLinus Torvalds /* The mode page is in the buffer. Let's modify it and write it. */ 32491da177e4SLinus Torvalds bp = (STp->buffer)->b_data; 32501da177e4SLinus Torvalds pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH]; 32511da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n", 32521da177e4SLinus Torvalds name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2)); 32531da177e4SLinus Torvalds 32541da177e4SLinus Torvalds psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2; 32551da177e4SLinus Torvalds psdo = pgo + PART_PAGE_FIXED_LENGTH; 32561da177e4SLinus Torvalds if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) { 32571da177e4SLinus Torvalds bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */ 32581da177e4SLinus Torvalds psdo += 2; 32591da177e4SLinus Torvalds } 32601da177e4SLinus Torvalds memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2); 32611da177e4SLinus Torvalds 32621da177e4SLinus Torvalds DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name, 32631da177e4SLinus Torvalds psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS], 32641da177e4SLinus Torvalds bp[pgo + PP_OFF_NBR_ADD_PARTS])); 32651da177e4SLinus Torvalds 32661da177e4SLinus Torvalds if (size <= 0) { 32671da177e4SLinus Torvalds bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0; 32681da177e4SLinus Torvalds if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS]) 32691da177e4SLinus Torvalds bp[pgo + MP_OFF_PAGE_LENGTH] = 6; 32701da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n", 32711da177e4SLinus Torvalds name)); 32721da177e4SLinus Torvalds } else { 32731da177e4SLinus Torvalds bp[psdo] = (size >> 8) & 0xff; 32741da177e4SLinus Torvalds bp[psdo + 1] = size & 0xff; 32751da177e4SLinus Torvalds bp[pgo + 3] = 1; 32761da177e4SLinus Torvalds if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8) 32771da177e4SLinus Torvalds bp[pgo + MP_OFF_PAGE_LENGTH] = 8; 32781da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 32791da177e4SLinus Torvalds "%s: Formatting tape with two partitions (1 = %d MB).\n", 32801da177e4SLinus Torvalds name, size)); 32811da177e4SLinus Torvalds } 32821da177e4SLinus Torvalds bp[pgo + PP_OFF_PART_UNITS] = 0; 32831da177e4SLinus Torvalds bp[pgo + PP_OFF_RESERVED] = 0; 32841da177e4SLinus Torvalds bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB; 32851da177e4SLinus Torvalds 32861da177e4SLinus Torvalds result = write_mode_page(STp, PART_PAGE, 1); 32871da177e4SLinus Torvalds if (result) { 32881da177e4SLinus Torvalds printk(KERN_INFO "%s: Partitioning of tape failed.\n", name); 32891da177e4SLinus Torvalds result = (-EIO); 32901da177e4SLinus Torvalds } 32911da177e4SLinus Torvalds 32921da177e4SLinus Torvalds return result; 32931da177e4SLinus Torvalds } 32941da177e4SLinus Torvalds 32951da177e4SLinus Torvalds 32961da177e4SLinus Torvalds 32971da177e4SLinus Torvalds /* The ioctl command */ 3298fd66c1b4SKai Makisara static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) 32991da177e4SLinus Torvalds { 33001da177e4SLinus Torvalds int i, cmd_nr, cmd_type, bt; 33011da177e4SLinus Torvalds int retval = 0; 33021da177e4SLinus Torvalds unsigned int blk; 33031da177e4SLinus Torvalds struct scsi_tape *STp = file->private_data; 33041da177e4SLinus Torvalds struct st_modedef *STm; 33051da177e4SLinus Torvalds struct st_partstat *STps; 33061da177e4SLinus Torvalds char *name = tape_name(STp); 33071da177e4SLinus Torvalds void __user *p = (void __user *)arg; 33081da177e4SLinus Torvalds 330928f85009SMatthias Kaehlcke if (mutex_lock_interruptible(&STp->lock)) 33101da177e4SLinus Torvalds return -ERESTARTSYS; 33111da177e4SLinus Torvalds 33121da177e4SLinus Torvalds DEB( 33131da177e4SLinus Torvalds if (debugging && !STp->in_use) { 33141da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Incorrect device.\n", name); 33151da177e4SLinus Torvalds retval = (-EIO); 33161da177e4SLinus Torvalds goto out; 33171da177e4SLinus Torvalds } ) /* end DEB */ 33181da177e4SLinus Torvalds 33191da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 33201da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 33211da177e4SLinus Torvalds 33221da177e4SLinus Torvalds /* 33231da177e4SLinus Torvalds * If we are in the middle of error recovery, don't let anyone 33241da177e4SLinus Torvalds * else try and use this device. Also, if error recovery fails, it 33251da177e4SLinus Torvalds * may try and take the device offline, in which case all further 33261da177e4SLinus Torvalds * access to the device is prohibited. 33271da177e4SLinus Torvalds */ 332883ff6fe8SAl Viro retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p, 332983ff6fe8SAl Viro file->f_flags & O_NDELAY); 33301da177e4SLinus Torvalds if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV) 33311da177e4SLinus Torvalds goto out; 33321da177e4SLinus Torvalds retval = 0; 33331da177e4SLinus Torvalds 33341da177e4SLinus Torvalds cmd_type = _IOC_TYPE(cmd_in); 33351da177e4SLinus Torvalds cmd_nr = _IOC_NR(cmd_in); 33361da177e4SLinus Torvalds 33371da177e4SLinus Torvalds if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) { 33381da177e4SLinus Torvalds struct mtop mtc; 33391da177e4SLinus Torvalds 33401da177e4SLinus Torvalds if (_IOC_SIZE(cmd_in) != sizeof(mtc)) { 33411da177e4SLinus Torvalds retval = (-EINVAL); 33421da177e4SLinus Torvalds goto out; 33431da177e4SLinus Torvalds } 33441da177e4SLinus Torvalds 33451da177e4SLinus Torvalds i = copy_from_user(&mtc, p, sizeof(struct mtop)); 33461da177e4SLinus Torvalds if (i) { 33471da177e4SLinus Torvalds retval = (-EFAULT); 33481da177e4SLinus Torvalds goto out; 33491da177e4SLinus Torvalds } 33501da177e4SLinus Torvalds 33511da177e4SLinus Torvalds if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) { 33521da177e4SLinus Torvalds printk(KERN_WARNING 33531da177e4SLinus Torvalds "%s: MTSETDRVBUFFER only allowed for root.\n", name); 33541da177e4SLinus Torvalds retval = (-EPERM); 33551da177e4SLinus Torvalds goto out; 33561da177e4SLinus Torvalds } 33571da177e4SLinus Torvalds if (!STm->defined && 33581da177e4SLinus Torvalds (mtc.mt_op != MTSETDRVBUFFER && 33591da177e4SLinus Torvalds (mtc.mt_count & MT_ST_OPTIONS) == 0)) { 33601da177e4SLinus Torvalds retval = (-ENXIO); 33611da177e4SLinus Torvalds goto out; 33621da177e4SLinus Torvalds } 33631da177e4SLinus Torvalds 33641da177e4SLinus Torvalds if (!STp->pos_unknown) { 33651da177e4SLinus Torvalds 33661da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) { 33671da177e4SLinus Torvalds if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 33681da177e4SLinus Torvalds mtc.mt_op == MTEOM) { 33691da177e4SLinus Torvalds mtc.mt_count -= 1; 33701da177e4SLinus Torvalds if (STps->drv_file >= 0) 33711da177e4SLinus Torvalds STps->drv_file += 1; 33721da177e4SLinus Torvalds } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) { 33731da177e4SLinus Torvalds mtc.mt_count += 1; 33741da177e4SLinus Torvalds if (STps->drv_file >= 0) 33751da177e4SLinus Torvalds STps->drv_file += 1; 33761da177e4SLinus Torvalds } 33771da177e4SLinus Torvalds } 33781da177e4SLinus Torvalds 33791da177e4SLinus Torvalds if (mtc.mt_op == MTSEEK) { 33801da177e4SLinus Torvalds /* Old position must be restored if partition will be 33811da177e4SLinus Torvalds changed */ 33821da177e4SLinus Torvalds i = !STp->can_partitions || 33831da177e4SLinus Torvalds (STp->new_partition != STp->partition); 33841da177e4SLinus Torvalds } else { 33851da177e4SLinus Torvalds i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 33861da177e4SLinus Torvalds mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM || 33871da177e4SLinus Torvalds mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD || 33881da177e4SLinus Torvalds mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 33891da177e4SLinus Torvalds mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM || 33901da177e4SLinus Torvalds mtc.mt_op == MTCOMPRESSION; 33911da177e4SLinus Torvalds } 33921da177e4SLinus Torvalds i = flush_buffer(STp, i); 33931da177e4SLinus Torvalds if (i < 0) { 33941da177e4SLinus Torvalds retval = i; 33951da177e4SLinus Torvalds goto out; 33961da177e4SLinus Torvalds } 33971da177e4SLinus Torvalds if (STps->rw == ST_WRITING && 33981da177e4SLinus Torvalds (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 33991da177e4SLinus Torvalds mtc.mt_op == MTSEEK || 34001da177e4SLinus Torvalds mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) { 34011da177e4SLinus Torvalds i = st_int_ioctl(STp, MTWEOF, 1); 34021da177e4SLinus Torvalds if (i < 0) { 34031da177e4SLinus Torvalds retval = i; 34041da177e4SLinus Torvalds goto out; 34051da177e4SLinus Torvalds } 34061da177e4SLinus Torvalds if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) 34071da177e4SLinus Torvalds mtc.mt_count++; 34081da177e4SLinus Torvalds STps->rw = ST_IDLE; 34091da177e4SLinus Torvalds } 34101da177e4SLinus Torvalds 34111da177e4SLinus Torvalds } else { 34121da177e4SLinus Torvalds /* 34131da177e4SLinus Torvalds * If there was a bus reset, block further access 34141da177e4SLinus Torvalds * to this device. If the user wants to rewind the tape, 34151da177e4SLinus Torvalds * then reset the flag and allow access again. 34161da177e4SLinus Torvalds */ 34171da177e4SLinus Torvalds if (mtc.mt_op != MTREW && 34181da177e4SLinus Torvalds mtc.mt_op != MTOFFL && 34191da177e4SLinus Torvalds mtc.mt_op != MTRETEN && 34201da177e4SLinus Torvalds mtc.mt_op != MTERASE && 34211da177e4SLinus Torvalds mtc.mt_op != MTSEEK && 34221da177e4SLinus Torvalds mtc.mt_op != MTEOM) { 34231da177e4SLinus Torvalds retval = (-EIO); 34241da177e4SLinus Torvalds goto out; 34251da177e4SLinus Torvalds } 34261da177e4SLinus Torvalds reset_state(STp); 34271da177e4SLinus Torvalds /* remove this when the midlevel properly clears was_reset */ 34281da177e4SLinus Torvalds STp->device->was_reset = 0; 34291da177e4SLinus Torvalds } 34301da177e4SLinus Torvalds 34311da177e4SLinus Torvalds if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK && 34321da177e4SLinus Torvalds mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM && 34331da177e4SLinus Torvalds mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART) 34341da177e4SLinus Torvalds STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */ 34351da177e4SLinus Torvalds 34361da177e4SLinus Torvalds if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED) 34371da177e4SLinus Torvalds do_door_lock(STp, 0); /* Ignore result! */ 34381da177e4SLinus Torvalds 34391da177e4SLinus Torvalds if (mtc.mt_op == MTSETDRVBUFFER && 34401da177e4SLinus Torvalds (mtc.mt_count & MT_ST_OPTIONS) != 0) { 34411da177e4SLinus Torvalds retval = st_set_options(STp, mtc.mt_count); 34421da177e4SLinus Torvalds goto out; 34431da177e4SLinus Torvalds } 34441da177e4SLinus Torvalds 34451da177e4SLinus Torvalds if (mtc.mt_op == MTSETPART) { 34461da177e4SLinus Torvalds if (!STp->can_partitions || 34471da177e4SLinus Torvalds mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) { 34481da177e4SLinus Torvalds retval = (-EINVAL); 34491da177e4SLinus Torvalds goto out; 34501da177e4SLinus Torvalds } 34511da177e4SLinus Torvalds if (mtc.mt_count >= STp->nbr_partitions && 34521da177e4SLinus Torvalds (STp->nbr_partitions = nbr_partitions(STp)) < 0) { 34531da177e4SLinus Torvalds retval = (-EIO); 34541da177e4SLinus Torvalds goto out; 34551da177e4SLinus Torvalds } 34561da177e4SLinus Torvalds if (mtc.mt_count >= STp->nbr_partitions) { 34571da177e4SLinus Torvalds retval = (-EINVAL); 34581da177e4SLinus Torvalds goto out; 34591da177e4SLinus Torvalds } 34601da177e4SLinus Torvalds STp->new_partition = mtc.mt_count; 34611da177e4SLinus Torvalds retval = 0; 34621da177e4SLinus Torvalds goto out; 34631da177e4SLinus Torvalds } 34641da177e4SLinus Torvalds 34651da177e4SLinus Torvalds if (mtc.mt_op == MTMKPART) { 34661da177e4SLinus Torvalds if (!STp->can_partitions) { 34671da177e4SLinus Torvalds retval = (-EINVAL); 34681da177e4SLinus Torvalds goto out; 34691da177e4SLinus Torvalds } 34701da177e4SLinus Torvalds if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 || 34711da177e4SLinus Torvalds (i = partition_tape(STp, mtc.mt_count)) < 0) { 34721da177e4SLinus Torvalds retval = i; 34731da177e4SLinus Torvalds goto out; 34741da177e4SLinus Torvalds } 34751da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 34761da177e4SLinus Torvalds STp->ps[i].rw = ST_IDLE; 34771da177e4SLinus Torvalds STp->ps[i].at_sm = 0; 34781da177e4SLinus Torvalds STp->ps[i].last_block_valid = 0; 34791da177e4SLinus Torvalds } 34801da177e4SLinus Torvalds STp->partition = STp->new_partition = 0; 34811da177e4SLinus Torvalds STp->nbr_partitions = 1; /* Bad guess ?-) */ 34821da177e4SLinus Torvalds STps->drv_block = STps->drv_file = 0; 34831da177e4SLinus Torvalds retval = 0; 34841da177e4SLinus Torvalds goto out; 34851da177e4SLinus Torvalds } 34861da177e4SLinus Torvalds 34871da177e4SLinus Torvalds if (mtc.mt_op == MTSEEK) { 34881da177e4SLinus Torvalds i = set_location(STp, mtc.mt_count, STp->new_partition, 0); 34891da177e4SLinus Torvalds if (!STp->can_partitions) 34901da177e4SLinus Torvalds STp->ps[0].rw = ST_IDLE; 34911da177e4SLinus Torvalds retval = i; 34921da177e4SLinus Torvalds goto out; 34931da177e4SLinus Torvalds } 34941da177e4SLinus Torvalds 34951da177e4SLinus Torvalds if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) { 34961da177e4SLinus Torvalds retval = do_load_unload(STp, file, 0); 34971da177e4SLinus Torvalds goto out; 34981da177e4SLinus Torvalds } 34991da177e4SLinus Torvalds 35001da177e4SLinus Torvalds if (mtc.mt_op == MTLOAD) { 35011da177e4SLinus Torvalds retval = do_load_unload(STp, file, max(1, mtc.mt_count)); 35021da177e4SLinus Torvalds goto out; 35031da177e4SLinus Torvalds } 35041da177e4SLinus Torvalds 35051da177e4SLinus Torvalds if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) { 35061da177e4SLinus Torvalds retval = do_door_lock(STp, (mtc.mt_op == MTLOCK)); 35071da177e4SLinus Torvalds goto out; 35081da177e4SLinus Torvalds } 35091da177e4SLinus Torvalds 35101da177e4SLinus Torvalds if (STp->can_partitions && STp->ready == ST_READY && 35111da177e4SLinus Torvalds (i = switch_partition(STp)) < 0) { 35121da177e4SLinus Torvalds retval = i; 35131da177e4SLinus Torvalds goto out; 35141da177e4SLinus Torvalds } 35151da177e4SLinus Torvalds 35161da177e4SLinus Torvalds if (mtc.mt_op == MTCOMPRESSION) 35171da177e4SLinus Torvalds retval = st_compression(STp, (mtc.mt_count & 1)); 35181da177e4SLinus Torvalds else 35191da177e4SLinus Torvalds retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count); 35201da177e4SLinus Torvalds goto out; 35211da177e4SLinus Torvalds } 35221da177e4SLinus Torvalds if (!STm->defined) { 35231da177e4SLinus Torvalds retval = (-ENXIO); 35241da177e4SLinus Torvalds goto out; 35251da177e4SLinus Torvalds } 35261da177e4SLinus Torvalds 35271da177e4SLinus Torvalds if ((i = flush_buffer(STp, 0)) < 0) { 35281da177e4SLinus Torvalds retval = i; 35291da177e4SLinus Torvalds goto out; 35301da177e4SLinus Torvalds } 35311da177e4SLinus Torvalds if (STp->can_partitions && 35321da177e4SLinus Torvalds (i = switch_partition(STp)) < 0) { 35331da177e4SLinus Torvalds retval = i; 35341da177e4SLinus Torvalds goto out; 35351da177e4SLinus Torvalds } 35361da177e4SLinus Torvalds 35371da177e4SLinus Torvalds if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) { 35381da177e4SLinus Torvalds struct mtget mt_status; 35391da177e4SLinus Torvalds 35401da177e4SLinus Torvalds if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) { 35411da177e4SLinus Torvalds retval = (-EINVAL); 35421da177e4SLinus Torvalds goto out; 35431da177e4SLinus Torvalds } 35441da177e4SLinus Torvalds 35451da177e4SLinus Torvalds mt_status.mt_type = STp->tape_type; 35461da177e4SLinus Torvalds mt_status.mt_dsreg = 35471da177e4SLinus Torvalds ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) | 35481da177e4SLinus Torvalds ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK); 35491da177e4SLinus Torvalds mt_status.mt_blkno = STps->drv_block; 35501da177e4SLinus Torvalds mt_status.mt_fileno = STps->drv_file; 35511da177e4SLinus Torvalds if (STp->block_size != 0) { 35521da177e4SLinus Torvalds if (STps->rw == ST_WRITING) 35531da177e4SLinus Torvalds mt_status.mt_blkno += 35541da177e4SLinus Torvalds (STp->buffer)->buffer_bytes / STp->block_size; 35551da177e4SLinus Torvalds else if (STps->rw == ST_READING) 35561da177e4SLinus Torvalds mt_status.mt_blkno -= 35571da177e4SLinus Torvalds ((STp->buffer)->buffer_bytes + 35581da177e4SLinus Torvalds STp->block_size - 1) / STp->block_size; 35591da177e4SLinus Torvalds } 35601da177e4SLinus Torvalds 35611da177e4SLinus Torvalds mt_status.mt_gstat = 0; 35621da177e4SLinus Torvalds if (STp->drv_write_prot) 35631da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff); 35641da177e4SLinus Torvalds if (mt_status.mt_blkno == 0) { 35651da177e4SLinus Torvalds if (mt_status.mt_fileno == 0) 35661da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_BOT(0xffffffff); 35671da177e4SLinus Torvalds else 35681da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_EOF(0xffffffff); 35691da177e4SLinus Torvalds } 35701da177e4SLinus Torvalds mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT); 35711da177e4SLinus Torvalds mt_status.mt_resid = STp->partition; 35721da177e4SLinus Torvalds if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR) 35731da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_EOT(0xffffffff); 35741da177e4SLinus Torvalds else if (STps->eof >= ST_EOM_OK) 35751da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_EOD(0xffffffff); 35761da177e4SLinus Torvalds if (STp->density == 1) 35771da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_D_800(0xffffffff); 35781da177e4SLinus Torvalds else if (STp->density == 2) 35791da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_D_1600(0xffffffff); 35801da177e4SLinus Torvalds else if (STp->density == 3) 35811da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_D_6250(0xffffffff); 35821da177e4SLinus Torvalds if (STp->ready == ST_READY) 35831da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_ONLINE(0xffffffff); 35841da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 35851da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff); 35861da177e4SLinus Torvalds if (STps->at_sm) 35871da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_SM(0xffffffff); 35881da177e4SLinus Torvalds if (STm->do_async_writes || 35891da177e4SLinus Torvalds (STm->do_buffer_writes && STp->block_size != 0) || 35901da177e4SLinus Torvalds STp->drv_buffer != 0) 35911da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff); 35921da177e4SLinus Torvalds if (STp->cleaning_req) 35931da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_CLN(0xffffffff); 35941da177e4SLinus Torvalds 35951da177e4SLinus Torvalds i = copy_to_user(p, &mt_status, sizeof(struct mtget)); 35961da177e4SLinus Torvalds if (i) { 35971da177e4SLinus Torvalds retval = (-EFAULT); 35981da177e4SLinus Torvalds goto out; 35991da177e4SLinus Torvalds } 36001da177e4SLinus Torvalds 36011da177e4SLinus Torvalds STp->recover_reg = 0; /* Clear after read */ 36021da177e4SLinus Torvalds retval = 0; 36031da177e4SLinus Torvalds goto out; 36041da177e4SLinus Torvalds } /* End of MTIOCGET */ 36051da177e4SLinus Torvalds if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) { 36061da177e4SLinus Torvalds struct mtpos mt_pos; 36071da177e4SLinus Torvalds if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) { 36081da177e4SLinus Torvalds retval = (-EINVAL); 36091da177e4SLinus Torvalds goto out; 36101da177e4SLinus Torvalds } 36111da177e4SLinus Torvalds if ((i = get_location(STp, &blk, &bt, 0)) < 0) { 36121da177e4SLinus Torvalds retval = i; 36131da177e4SLinus Torvalds goto out; 36141da177e4SLinus Torvalds } 36151da177e4SLinus Torvalds mt_pos.mt_blkno = blk; 36161da177e4SLinus Torvalds i = copy_to_user(p, &mt_pos, sizeof(struct mtpos)); 36171da177e4SLinus Torvalds if (i) 36181da177e4SLinus Torvalds retval = (-EFAULT); 36191da177e4SLinus Torvalds goto out; 36201da177e4SLinus Torvalds } 362128f85009SMatthias Kaehlcke mutex_unlock(&STp->lock); 36221da177e4SLinus Torvalds switch (cmd_in) { 36231da177e4SLinus Torvalds case SCSI_IOCTL_GET_IDLUN: 36241da177e4SLinus Torvalds case SCSI_IOCTL_GET_BUS_NUMBER: 36251da177e4SLinus Torvalds break; 36261da177e4SLinus Torvalds default: 362716c4b3e2SKai Makisara if ((cmd_in == SG_IO || 362816c4b3e2SKai Makisara cmd_in == SCSI_IOCTL_SEND_COMMAND || 362916c4b3e2SKai Makisara cmd_in == CDROM_SEND_PACKET) && 363016c4b3e2SKai Makisara !capable(CAP_SYS_RAWIO)) 36311da177e4SLinus Torvalds i = -EPERM; 36321da177e4SLinus Torvalds else 363374f3c8afSAl Viro i = scsi_cmd_ioctl(STp->disk->queue, STp->disk, 363474f3c8afSAl Viro file->f_mode, cmd_in, p); 36351da177e4SLinus Torvalds if (i != -ENOTTY) 36361da177e4SLinus Torvalds return i; 36371da177e4SLinus Torvalds break; 36381da177e4SLinus Torvalds } 363916c4b3e2SKai Makisara retval = scsi_ioctl(STp->device, cmd_in, p); 364016c4b3e2SKai Makisara if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */ 364116c4b3e2SKai Makisara STp->rew_at_close = 0; 364216c4b3e2SKai Makisara STp->ready = ST_NO_TAPE; 364316c4b3e2SKai Makisara } 364416c4b3e2SKai Makisara return retval; 36451da177e4SLinus Torvalds 36461da177e4SLinus Torvalds out: 364728f85009SMatthias Kaehlcke mutex_unlock(&STp->lock); 36481da177e4SLinus Torvalds return retval; 36491da177e4SLinus Torvalds } 36501da177e4SLinus Torvalds 36511da177e4SLinus Torvalds #ifdef CONFIG_COMPAT 36521da177e4SLinus Torvalds static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 36531da177e4SLinus Torvalds { 36541da177e4SLinus Torvalds struct scsi_tape *STp = file->private_data; 36551da177e4SLinus Torvalds struct scsi_device *sdev = STp->device; 36561da177e4SLinus Torvalds int ret = -ENOIOCTLCMD; 36571da177e4SLinus Torvalds if (sdev->host->hostt->compat_ioctl) { 36581da177e4SLinus Torvalds 36591da177e4SLinus Torvalds ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg); 36601da177e4SLinus Torvalds 36611da177e4SLinus Torvalds } 36621da177e4SLinus Torvalds return ret; 36631da177e4SLinus Torvalds } 36641da177e4SLinus Torvalds #endif 36651da177e4SLinus Torvalds 36661da177e4SLinus Torvalds 36671da177e4SLinus Torvalds 36681da177e4SLinus Torvalds /* Try to allocate a new tape buffer. Calling function must not hold 36691da177e4SLinus Torvalds dev_arr_lock. */ 36701da177e4SLinus Torvalds static struct st_buffer * 36711da177e4SLinus Torvalds new_tape_buffer(int from_initialization, int need_dma, int max_sg) 36721da177e4SLinus Torvalds { 36738b05b773SMike Christie int i, got = 0; 3674c53033f6SAl Viro gfp_t priority; 36751da177e4SLinus Torvalds struct st_buffer *tb; 36761da177e4SLinus Torvalds 36771da177e4SLinus Torvalds if (from_initialization) 36781da177e4SLinus Torvalds priority = GFP_ATOMIC; 36791da177e4SLinus Torvalds else 36801da177e4SLinus Torvalds priority = GFP_KERNEL; 36811da177e4SLinus Torvalds 36821da177e4SLinus Torvalds i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) + 36831da177e4SLinus Torvalds max_sg * sizeof(struct st_buf_fragment); 368424669f75SJes Sorensen tb = kzalloc(i, priority); 36851da177e4SLinus Torvalds if (!tb) { 36861da177e4SLinus Torvalds printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n"); 36871da177e4SLinus Torvalds return NULL; 36881da177e4SLinus Torvalds } 36898b05b773SMike Christie tb->frp_segs = tb->orig_frp_segs = 0; 36901da177e4SLinus Torvalds tb->use_sg = max_sg; 36911da177e4SLinus Torvalds tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg); 36921da177e4SLinus Torvalds 36931da177e4SLinus Torvalds tb->dma = need_dma; 36941da177e4SLinus Torvalds tb->buffer_size = got; 3695cd81621cSFUJITA Tomonori sg_init_table(tb->sg, max_sg); 36961da177e4SLinus Torvalds 36971da177e4SLinus Torvalds return tb; 36981da177e4SLinus Torvalds } 36991da177e4SLinus Torvalds 37001da177e4SLinus Torvalds 37011da177e4SLinus Torvalds /* Try to allocate enough space in the tape buffer */ 37021da177e4SLinus Torvalds static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma) 37031da177e4SLinus Torvalds { 3704c53033f6SAl Viro int segs, nbr, max_segs, b_size, order, got; 3705c53033f6SAl Viro gfp_t priority; 37061da177e4SLinus Torvalds 37071da177e4SLinus Torvalds if (new_size <= STbuffer->buffer_size) 37081da177e4SLinus Torvalds return 1; 37091da177e4SLinus Torvalds 37101da177e4SLinus Torvalds if (STbuffer->buffer_size <= PAGE_SIZE) 37111da177e4SLinus Torvalds normalize_buffer(STbuffer); /* Avoid extra segment */ 37121da177e4SLinus Torvalds 37131da177e4SLinus Torvalds max_segs = STbuffer->use_sg; 37141da177e4SLinus Torvalds nbr = max_segs - STbuffer->frp_segs; 37151da177e4SLinus Torvalds if (nbr <= 0) 37161da177e4SLinus Torvalds return 0; 37171da177e4SLinus Torvalds 37181da177e4SLinus Torvalds priority = GFP_KERNEL | __GFP_NOWARN; 37191da177e4SLinus Torvalds if (need_dma) 37201da177e4SLinus Torvalds priority |= GFP_DMA; 37218b05b773SMike Christie for (b_size = PAGE_SIZE, order=0; order <= 6 && 37221da177e4SLinus Torvalds b_size < new_size - STbuffer->buffer_size; 37231da177e4SLinus Torvalds order++, b_size *= 2) 37241da177e4SLinus Torvalds ; /* empty */ 37251da177e4SLinus Torvalds 37261da177e4SLinus Torvalds for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size; 37271da177e4SLinus Torvalds segs < max_segs && got < new_size;) { 37281da177e4SLinus Torvalds STbuffer->frp[segs].page = alloc_pages(priority, order); 37291da177e4SLinus Torvalds if (STbuffer->frp[segs].page == NULL) { 37301da177e4SLinus Torvalds if (new_size - got <= (max_segs - segs) * b_size / 2) { 37311da177e4SLinus Torvalds b_size /= 2; /* Large enough for the rest of the buffers */ 37321da177e4SLinus Torvalds order--; 37331da177e4SLinus Torvalds continue; 37341da177e4SLinus Torvalds } 37351da177e4SLinus Torvalds DEB(STbuffer->buffer_size = got); 37361da177e4SLinus Torvalds normalize_buffer(STbuffer); 37371da177e4SLinus Torvalds return 0; 37381da177e4SLinus Torvalds } 37391da177e4SLinus Torvalds STbuffer->frp[segs].length = b_size; 37401da177e4SLinus Torvalds STbuffer->frp_segs += 1; 37411da177e4SLinus Torvalds got += b_size; 37421da177e4SLinus Torvalds STbuffer->buffer_size = got; 374340f6b36cSKai Makisara if (STbuffer->cleared) 374440f6b36cSKai Makisara memset(page_address(STbuffer->frp[segs].page), 0, b_size); 37451da177e4SLinus Torvalds segs++; 37461da177e4SLinus Torvalds } 37471da177e4SLinus Torvalds STbuffer->b_data = page_address(STbuffer->frp[0].page); 37481da177e4SLinus Torvalds 37491da177e4SLinus Torvalds return 1; 37501da177e4SLinus Torvalds } 37511da177e4SLinus Torvalds 37521da177e4SLinus Torvalds 375340f6b36cSKai Makisara /* Make sure that no data from previous user is in the internal buffer */ 375440f6b36cSKai Makisara static void clear_buffer(struct st_buffer * st_bp) 375540f6b36cSKai Makisara { 375640f6b36cSKai Makisara int i; 375740f6b36cSKai Makisara 375840f6b36cSKai Makisara for (i=0; i < st_bp->frp_segs; i++) 375940f6b36cSKai Makisara memset(page_address(st_bp->frp[i].page), 0, st_bp->frp[i].length); 376040f6b36cSKai Makisara st_bp->cleared = 1; 376140f6b36cSKai Makisara } 376240f6b36cSKai Makisara 376340f6b36cSKai Makisara 37641da177e4SLinus Torvalds /* Release the extra buffer */ 37651da177e4SLinus Torvalds static void normalize_buffer(struct st_buffer * STbuffer) 37661da177e4SLinus Torvalds { 37671da177e4SLinus Torvalds int i, order; 37681da177e4SLinus Torvalds 37691da177e4SLinus Torvalds for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) { 37701da177e4SLinus Torvalds order = get_order(STbuffer->frp[i].length); 37711da177e4SLinus Torvalds __free_pages(STbuffer->frp[i].page, order); 37721da177e4SLinus Torvalds STbuffer->buffer_size -= STbuffer->frp[i].length; 37731da177e4SLinus Torvalds } 37741da177e4SLinus Torvalds STbuffer->frp_segs = STbuffer->orig_frp_segs; 37751da177e4SLinus Torvalds STbuffer->frp_sg_current = 0; 37768b05b773SMike Christie STbuffer->sg_segs = 0; 37771da177e4SLinus Torvalds } 37781da177e4SLinus Torvalds 37791da177e4SLinus Torvalds 37801da177e4SLinus Torvalds /* Move data from the user buffer to the tape buffer. Returns zero (success) or 37811da177e4SLinus Torvalds negative error code. */ 37821da177e4SLinus Torvalds static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count) 37831da177e4SLinus Torvalds { 37841da177e4SLinus Torvalds int i, cnt, res, offset; 37851da177e4SLinus Torvalds 37861da177e4SLinus Torvalds for (i = 0, offset = st_bp->buffer_bytes; 37871da177e4SLinus Torvalds i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++) 37881da177e4SLinus Torvalds offset -= st_bp->frp[i].length; 37891da177e4SLinus Torvalds if (i == st_bp->frp_segs) { /* Should never happen */ 37901da177e4SLinus Torvalds printk(KERN_WARNING "st: append_to_buffer offset overflow.\n"); 37911da177e4SLinus Torvalds return (-EIO); 37921da177e4SLinus Torvalds } 37931da177e4SLinus Torvalds for (; i < st_bp->frp_segs && do_count > 0; i++) { 37941da177e4SLinus Torvalds cnt = st_bp->frp[i].length - offset < do_count ? 37951da177e4SLinus Torvalds st_bp->frp[i].length - offset : do_count; 37961da177e4SLinus Torvalds res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt); 37971da177e4SLinus Torvalds if (res) 37981da177e4SLinus Torvalds return (-EFAULT); 37991da177e4SLinus Torvalds do_count -= cnt; 38001da177e4SLinus Torvalds st_bp->buffer_bytes += cnt; 38011da177e4SLinus Torvalds ubp += cnt; 38021da177e4SLinus Torvalds offset = 0; 38031da177e4SLinus Torvalds } 38041da177e4SLinus Torvalds if (do_count) /* Should never happen */ 38051da177e4SLinus Torvalds return (-EIO); 38061da177e4SLinus Torvalds 38071da177e4SLinus Torvalds return 0; 38081da177e4SLinus Torvalds } 38091da177e4SLinus Torvalds 38101da177e4SLinus Torvalds 38111da177e4SLinus Torvalds /* Move data from the tape buffer to the user buffer. Returns zero (success) or 38121da177e4SLinus Torvalds negative error code. */ 38131da177e4SLinus Torvalds static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count) 38141da177e4SLinus Torvalds { 38151da177e4SLinus Torvalds int i, cnt, res, offset; 38161da177e4SLinus Torvalds 38171da177e4SLinus Torvalds for (i = 0, offset = st_bp->read_pointer; 38181da177e4SLinus Torvalds i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++) 38191da177e4SLinus Torvalds offset -= st_bp->frp[i].length; 38201da177e4SLinus Torvalds if (i == st_bp->frp_segs) { /* Should never happen */ 38211da177e4SLinus Torvalds printk(KERN_WARNING "st: from_buffer offset overflow.\n"); 38221da177e4SLinus Torvalds return (-EIO); 38231da177e4SLinus Torvalds } 38241da177e4SLinus Torvalds for (; i < st_bp->frp_segs && do_count > 0; i++) { 38251da177e4SLinus Torvalds cnt = st_bp->frp[i].length - offset < do_count ? 38261da177e4SLinus Torvalds st_bp->frp[i].length - offset : do_count; 38271da177e4SLinus Torvalds res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt); 38281da177e4SLinus Torvalds if (res) 38291da177e4SLinus Torvalds return (-EFAULT); 38301da177e4SLinus Torvalds do_count -= cnt; 38311da177e4SLinus Torvalds st_bp->buffer_bytes -= cnt; 38321da177e4SLinus Torvalds st_bp->read_pointer += cnt; 38331da177e4SLinus Torvalds ubp += cnt; 38341da177e4SLinus Torvalds offset = 0; 38351da177e4SLinus Torvalds } 38361da177e4SLinus Torvalds if (do_count) /* Should never happen */ 38371da177e4SLinus Torvalds return (-EIO); 38381da177e4SLinus Torvalds 38391da177e4SLinus Torvalds return 0; 38401da177e4SLinus Torvalds } 38411da177e4SLinus Torvalds 38421da177e4SLinus Torvalds 38431da177e4SLinus Torvalds /* Move data towards start of buffer */ 38441da177e4SLinus Torvalds static void move_buffer_data(struct st_buffer * st_bp, int offset) 38451da177e4SLinus Torvalds { 38461da177e4SLinus Torvalds int src_seg, dst_seg, src_offset = 0, dst_offset; 38471da177e4SLinus Torvalds int count, total; 38481da177e4SLinus Torvalds 38491da177e4SLinus Torvalds if (offset == 0) 38501da177e4SLinus Torvalds return; 38511da177e4SLinus Torvalds 38521da177e4SLinus Torvalds total=st_bp->buffer_bytes - offset; 38531da177e4SLinus Torvalds for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) { 38541da177e4SLinus Torvalds src_offset = offset; 38551da177e4SLinus Torvalds if (src_offset < st_bp->frp[src_seg].length) 38561da177e4SLinus Torvalds break; 38571da177e4SLinus Torvalds offset -= st_bp->frp[src_seg].length; 38581da177e4SLinus Torvalds } 38591da177e4SLinus Torvalds 38601da177e4SLinus Torvalds st_bp->buffer_bytes = st_bp->read_pointer = total; 38611da177e4SLinus Torvalds for (dst_seg=dst_offset=0; total > 0; ) { 38621da177e4SLinus Torvalds count = min(st_bp->frp[dst_seg].length - dst_offset, 38631da177e4SLinus Torvalds st_bp->frp[src_seg].length - src_offset); 38641da177e4SLinus Torvalds memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset, 38651da177e4SLinus Torvalds page_address(st_bp->frp[src_seg].page) + src_offset, count); 38661da177e4SLinus Torvalds src_offset += count; 38671da177e4SLinus Torvalds if (src_offset >= st_bp->frp[src_seg].length) { 38681da177e4SLinus Torvalds src_seg++; 38691da177e4SLinus Torvalds src_offset = 0; 38701da177e4SLinus Torvalds } 38711da177e4SLinus Torvalds dst_offset += count; 38721da177e4SLinus Torvalds if (dst_offset >= st_bp->frp[dst_seg].length) { 38731da177e4SLinus Torvalds dst_seg++; 38741da177e4SLinus Torvalds dst_offset = 0; 38751da177e4SLinus Torvalds } 38761da177e4SLinus Torvalds total -= count; 38771da177e4SLinus Torvalds } 38781da177e4SLinus Torvalds } 38791da177e4SLinus Torvalds 38801da177e4SLinus Torvalds 38811da177e4SLinus Torvalds /* Fill the s/g list up to the length required for this transfer */ 38821da177e4SLinus Torvalds static void buf_to_sg(struct st_buffer *STbp, unsigned int length) 38831da177e4SLinus Torvalds { 38841da177e4SLinus Torvalds int i; 38851da177e4SLinus Torvalds unsigned int count; 38861da177e4SLinus Torvalds struct scatterlist *sg; 38871da177e4SLinus Torvalds struct st_buf_fragment *frp; 38881da177e4SLinus Torvalds 38891da177e4SLinus Torvalds if (length == STbp->frp_sg_current) 38901da177e4SLinus Torvalds return; /* work already done */ 38911da177e4SLinus Torvalds 38921da177e4SLinus Torvalds sg = &(STbp->sg[0]); 38931da177e4SLinus Torvalds frp = STbp->frp; 38941da177e4SLinus Torvalds for (i=count=0; count < length; i++) { 38951da177e4SLinus Torvalds if (length - count > frp[i].length) 3896642f1490SJens Axboe sg_set_page(&sg[i], frp[i].page, frp[i].length, 0); 38971da177e4SLinus Torvalds else 3898642f1490SJens Axboe sg_set_page(&sg[i], frp[i].page, length - count, 0); 38991da177e4SLinus Torvalds count += sg[i].length; 39001da177e4SLinus Torvalds } 39011da177e4SLinus Torvalds STbp->sg_segs = i; 39021da177e4SLinus Torvalds STbp->frp_sg_current = length; 39031da177e4SLinus Torvalds } 39041da177e4SLinus Torvalds 39051da177e4SLinus Torvalds 39061da177e4SLinus Torvalds /* Validate the options from command line or module parameters */ 39071da177e4SLinus Torvalds static void validate_options(void) 39081da177e4SLinus Torvalds { 39091da177e4SLinus Torvalds if (buffer_kbs > 0) 39101da177e4SLinus Torvalds st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE; 39111da177e4SLinus Torvalds if (max_sg_segs >= ST_FIRST_SG) 39121da177e4SLinus Torvalds st_max_sg_segs = max_sg_segs; 39131da177e4SLinus Torvalds } 39141da177e4SLinus Torvalds 39151da177e4SLinus Torvalds #ifndef MODULE 39161da177e4SLinus Torvalds /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt. 39171da177e4SLinus Torvalds */ 39181da177e4SLinus Torvalds static int __init st_setup(char *str) 39191da177e4SLinus Torvalds { 39201da177e4SLinus Torvalds int i, len, ints[5]; 39211da177e4SLinus Torvalds char *stp; 39221da177e4SLinus Torvalds 39231da177e4SLinus Torvalds stp = get_options(str, ARRAY_SIZE(ints), ints); 39241da177e4SLinus Torvalds 39251da177e4SLinus Torvalds if (ints[0] > 0) { 39261da177e4SLinus Torvalds for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++) 39271da177e4SLinus Torvalds if (parms[i].val) 39281da177e4SLinus Torvalds *parms[i].val = ints[i + 1]; 39291da177e4SLinus Torvalds } else { 39301da177e4SLinus Torvalds while (stp != NULL) { 39311da177e4SLinus Torvalds for (i = 0; i < ARRAY_SIZE(parms); i++) { 39321da177e4SLinus Torvalds len = strlen(parms[i].name); 39331da177e4SLinus Torvalds if (!strncmp(stp, parms[i].name, len) && 39341da177e4SLinus Torvalds (*(stp + len) == ':' || *(stp + len) == '=')) { 39351da177e4SLinus Torvalds if (parms[i].val) 39361da177e4SLinus Torvalds *parms[i].val = 39371da177e4SLinus Torvalds simple_strtoul(stp + len + 1, NULL, 0); 39381da177e4SLinus Torvalds else 39391da177e4SLinus Torvalds printk(KERN_WARNING "st: Obsolete parameter %s\n", 39401da177e4SLinus Torvalds parms[i].name); 39411da177e4SLinus Torvalds break; 39421da177e4SLinus Torvalds } 39431da177e4SLinus Torvalds } 39446391a113STobias Klauser if (i >= ARRAY_SIZE(parms)) 39451da177e4SLinus Torvalds printk(KERN_WARNING "st: invalid parameter in '%s'\n", 39461da177e4SLinus Torvalds stp); 39471da177e4SLinus Torvalds stp = strchr(stp, ','); 39481da177e4SLinus Torvalds if (stp) 39491da177e4SLinus Torvalds stp++; 39501da177e4SLinus Torvalds } 39511da177e4SLinus Torvalds } 39521da177e4SLinus Torvalds 39531da177e4SLinus Torvalds validate_options(); 39541da177e4SLinus Torvalds 39551da177e4SLinus Torvalds return 1; 39561da177e4SLinus Torvalds } 39571da177e4SLinus Torvalds 39581da177e4SLinus Torvalds __setup("st=", st_setup); 39591da177e4SLinus Torvalds 39601da177e4SLinus Torvalds #endif 39611da177e4SLinus Torvalds 396200977a59SArjan van de Ven static const struct file_operations st_fops = 39631da177e4SLinus Torvalds { 39641da177e4SLinus Torvalds .owner = THIS_MODULE, 39651da177e4SLinus Torvalds .read = st_read, 39661da177e4SLinus Torvalds .write = st_write, 3967fd66c1b4SKai Makisara .unlocked_ioctl = st_ioctl, 39681da177e4SLinus Torvalds #ifdef CONFIG_COMPAT 39691da177e4SLinus Torvalds .compat_ioctl = st_compat_ioctl, 39701da177e4SLinus Torvalds #endif 39711da177e4SLinus Torvalds .open = st_open, 39721da177e4SLinus Torvalds .flush = st_flush, 39731da177e4SLinus Torvalds .release = st_release, 39741da177e4SLinus Torvalds }; 39751da177e4SLinus Torvalds 39761da177e4SLinus Torvalds static int st_probe(struct device *dev) 39771da177e4SLinus Torvalds { 39781da177e4SLinus Torvalds struct scsi_device *SDp = to_scsi_device(dev); 39791da177e4SLinus Torvalds struct gendisk *disk = NULL; 39801da177e4SLinus Torvalds struct cdev *cdev = NULL; 39811da177e4SLinus Torvalds struct scsi_tape *tpnt = NULL; 39821da177e4SLinus Torvalds struct st_modedef *STm; 39831da177e4SLinus Torvalds struct st_partstat *STps; 39841da177e4SLinus Torvalds struct st_buffer *buffer; 39851da177e4SLinus Torvalds int i, j, mode, dev_num, error; 39861da177e4SLinus Torvalds char *stp; 39871da177e4SLinus Torvalds 39881da177e4SLinus Torvalds if (SDp->type != TYPE_TAPE) 39891da177e4SLinus Torvalds return -ENODEV; 39901da177e4SLinus Torvalds if ((stp = st_incompatible(SDp))) { 39913bf743e7SJeff Garzik sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n"); 39921da177e4SLinus Torvalds printk(KERN_INFO "st: The suggested driver is %s.\n", stp); 39931da177e4SLinus Torvalds return -ENODEV; 39941da177e4SLinus Torvalds } 39951da177e4SLinus Torvalds 39968b05b773SMike Christie i = min(SDp->request_queue->max_hw_segments, 39978b05b773SMike Christie SDp->request_queue->max_phys_segments); 39981da177e4SLinus Torvalds if (st_max_sg_segs < i) 39991da177e4SLinus Torvalds i = st_max_sg_segs; 40001da177e4SLinus Torvalds buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i); 40011da177e4SLinus Torvalds if (buffer == NULL) { 40021da177e4SLinus Torvalds printk(KERN_ERR 40031da177e4SLinus Torvalds "st: Can't allocate new tape buffer. Device not attached.\n"); 40041da177e4SLinus Torvalds goto out; 40051da177e4SLinus Torvalds } 40061da177e4SLinus Torvalds 40071da177e4SLinus Torvalds disk = alloc_disk(1); 40081da177e4SLinus Torvalds if (!disk) { 40091da177e4SLinus Torvalds printk(KERN_ERR "st: out of memory. Device not attached.\n"); 40101da177e4SLinus Torvalds goto out_buffer_free; 40111da177e4SLinus Torvalds } 40121da177e4SLinus Torvalds 40131da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 40141da177e4SLinus Torvalds if (st_nr_dev >= st_dev_max) { 40151da177e4SLinus Torvalds struct scsi_tape **tmp_da; 40161da177e4SLinus Torvalds int tmp_dev_max; 40171da177e4SLinus Torvalds 40181da177e4SLinus Torvalds tmp_dev_max = max(st_nr_dev * 2, 8); 40191da177e4SLinus Torvalds if (tmp_dev_max > ST_MAX_TAPES) 40201da177e4SLinus Torvalds tmp_dev_max = ST_MAX_TAPES; 40211da177e4SLinus Torvalds if (tmp_dev_max <= st_nr_dev) { 40221da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 40231da177e4SLinus Torvalds printk(KERN_ERR "st: Too many tape devices (max. %d).\n", 40241da177e4SLinus Torvalds ST_MAX_TAPES); 40251da177e4SLinus Torvalds goto out_put_disk; 40261da177e4SLinus Torvalds } 40271da177e4SLinus Torvalds 402824669f75SJes Sorensen tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC); 40291da177e4SLinus Torvalds if (tmp_da == NULL) { 40301da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 40311da177e4SLinus Torvalds printk(KERN_ERR "st: Can't extend device array.\n"); 40321da177e4SLinus Torvalds goto out_put_disk; 40331da177e4SLinus Torvalds } 40341da177e4SLinus Torvalds 40351da177e4SLinus Torvalds if (scsi_tapes != NULL) { 40361da177e4SLinus Torvalds memcpy(tmp_da, scsi_tapes, 40371da177e4SLinus Torvalds st_dev_max * sizeof(struct scsi_tape *)); 40381da177e4SLinus Torvalds kfree(scsi_tapes); 40391da177e4SLinus Torvalds } 40401da177e4SLinus Torvalds scsi_tapes = tmp_da; 40411da177e4SLinus Torvalds 40421da177e4SLinus Torvalds st_dev_max = tmp_dev_max; 40431da177e4SLinus Torvalds } 40441da177e4SLinus Torvalds 40451da177e4SLinus Torvalds for (i = 0; i < st_dev_max; i++) 40461da177e4SLinus Torvalds if (scsi_tapes[i] == NULL) 40471da177e4SLinus Torvalds break; 40481da177e4SLinus Torvalds if (i >= st_dev_max) 40491da177e4SLinus Torvalds panic("scsi_devices corrupt (st)"); 40501da177e4SLinus Torvalds 405124669f75SJes Sorensen tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC); 40521da177e4SLinus Torvalds if (tpnt == NULL) { 40531da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 40541da177e4SLinus Torvalds printk(KERN_ERR "st: Can't allocate device descriptor.\n"); 40551da177e4SLinus Torvalds goto out_put_disk; 40561da177e4SLinus Torvalds } 4057f03a5670SKai Makisara kref_init(&tpnt->kref); 40581da177e4SLinus Torvalds tpnt->disk = disk; 40591da177e4SLinus Torvalds sprintf(disk->disk_name, "st%d", i); 40601da177e4SLinus Torvalds disk->private_data = &tpnt->driver; 40611da177e4SLinus Torvalds disk->queue = SDp->request_queue; 40621da177e4SLinus Torvalds tpnt->driver = &st_template; 40631da177e4SLinus Torvalds scsi_tapes[i] = tpnt; 40641da177e4SLinus Torvalds dev_num = i; 40651da177e4SLinus Torvalds 40661da177e4SLinus Torvalds tpnt->device = SDp; 40671da177e4SLinus Torvalds if (SDp->scsi_level <= 2) 40681da177e4SLinus Torvalds tpnt->tape_type = MT_ISSCSI1; 40691da177e4SLinus Torvalds else 40701da177e4SLinus Torvalds tpnt->tape_type = MT_ISSCSI2; 40711da177e4SLinus Torvalds 40721da177e4SLinus Torvalds tpnt->buffer = buffer; 4073f03a5670SKai Makisara tpnt->buffer->last_SRpnt = NULL; 40741da177e4SLinus Torvalds 40751da177e4SLinus Torvalds tpnt->inited = 0; 40761da177e4SLinus Torvalds tpnt->dirty = 0; 40771da177e4SLinus Torvalds tpnt->in_use = 0; 40781da177e4SLinus Torvalds tpnt->drv_buffer = 1; /* Try buffering if no mode sense */ 40791da177e4SLinus Torvalds tpnt->restr_dma = (SDp->host)->unchecked_isa_dma; 40801da177e4SLinus Torvalds tpnt->use_pf = (SDp->scsi_level >= SCSI_2); 40811da177e4SLinus Torvalds tpnt->density = 0; 40821da177e4SLinus Torvalds tpnt->do_auto_lock = ST_AUTO_LOCK; 40831da177e4SLinus Torvalds tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */ 40841da177e4SLinus Torvalds tpnt->can_partitions = 0; 40851da177e4SLinus Torvalds tpnt->two_fm = ST_TWO_FM; 40861da177e4SLinus Torvalds tpnt->fast_mteom = ST_FAST_MTEOM; 40871da177e4SLinus Torvalds tpnt->scsi2_logical = ST_SCSI2LOGICAL; 408840f6b36cSKai Makisara tpnt->sili = ST_SILI; 40891da177e4SLinus Torvalds tpnt->immediate = ST_NOWAIT; 40901da177e4SLinus Torvalds tpnt->default_drvbuffer = 0xff; /* No forced buffering */ 40911da177e4SLinus Torvalds tpnt->partition = 0; 40921da177e4SLinus Torvalds tpnt->new_partition = 0; 40931da177e4SLinus Torvalds tpnt->nbr_partitions = 0; 4094a02488edSJames Bottomley blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT); 40951da177e4SLinus Torvalds tpnt->long_timeout = ST_LONG_TIMEOUT; 40961da177e4SLinus Torvalds tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma; 40971da177e4SLinus Torvalds 40981da177e4SLinus Torvalds for (i = 0; i < ST_NBR_MODES; i++) { 40991da177e4SLinus Torvalds STm = &(tpnt->modes[i]); 41001da177e4SLinus Torvalds STm->defined = 0; 41011da177e4SLinus Torvalds STm->sysv = ST_SYSV; 41021da177e4SLinus Torvalds STm->defaults_for_writes = 0; 41031da177e4SLinus Torvalds STm->do_async_writes = ST_ASYNC_WRITES; 41041da177e4SLinus Torvalds STm->do_buffer_writes = ST_BUFFER_WRITES; 41051da177e4SLinus Torvalds STm->do_read_ahead = ST_READ_AHEAD; 41061da177e4SLinus Torvalds STm->default_compression = ST_DONT_TOUCH; 41071da177e4SLinus Torvalds STm->default_blksize = (-1); /* No forced size */ 41081da177e4SLinus Torvalds STm->default_density = (-1); /* No forced density */ 41091da177e4SLinus Torvalds } 41101da177e4SLinus Torvalds 41111da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 41121da177e4SLinus Torvalds STps = &(tpnt->ps[i]); 41131da177e4SLinus Torvalds STps->rw = ST_IDLE; 41141da177e4SLinus Torvalds STps->eof = ST_NOEOF; 41151da177e4SLinus Torvalds STps->at_sm = 0; 41161da177e4SLinus Torvalds STps->last_block_valid = 0; 41171da177e4SLinus Torvalds STps->drv_block = (-1); 41181da177e4SLinus Torvalds STps->drv_file = (-1); 41191da177e4SLinus Torvalds } 41201da177e4SLinus Torvalds 41211da177e4SLinus Torvalds tpnt->current_mode = 0; 41221da177e4SLinus Torvalds tpnt->modes[0].defined = 1; 41231da177e4SLinus Torvalds 41241da177e4SLinus Torvalds tpnt->density_changed = tpnt->compression_changed = 41251da177e4SLinus Torvalds tpnt->blksize_changed = 0; 412628f85009SMatthias Kaehlcke mutex_init(&tpnt->lock); 41271da177e4SLinus Torvalds 41281da177e4SLinus Torvalds st_nr_dev++; 41291da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 41301da177e4SLinus Torvalds 41311da177e4SLinus Torvalds for (mode = 0; mode < ST_NBR_MODES; ++mode) { 41321da177e4SLinus Torvalds STm = &(tpnt->modes[mode]); 41331da177e4SLinus Torvalds for (j=0; j < 2; j++) { 41341da177e4SLinus Torvalds cdev = cdev_alloc(); 41351da177e4SLinus Torvalds if (!cdev) { 41361da177e4SLinus Torvalds printk(KERN_ERR 41371da177e4SLinus Torvalds "st%d: out of memory. Device not attached.\n", 41381da177e4SLinus Torvalds dev_num); 41391da177e4SLinus Torvalds goto out_free_tape; 41401da177e4SLinus Torvalds } 41411da177e4SLinus Torvalds cdev->owner = THIS_MODULE; 41421da177e4SLinus Torvalds cdev->ops = &st_fops; 41431da177e4SLinus Torvalds 41441da177e4SLinus Torvalds error = cdev_add(cdev, 41451da177e4SLinus Torvalds MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)), 41461da177e4SLinus Torvalds 1); 41471da177e4SLinus Torvalds if (error) { 41481da177e4SLinus Torvalds printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n", 41491da177e4SLinus Torvalds dev_num, j ? "non" : "auto", mode); 41501da177e4SLinus Torvalds printk(KERN_ERR "st%d: Device not attached.\n", dev_num); 41511da177e4SLinus Torvalds goto out_free_tape; 41521da177e4SLinus Torvalds } 41531da177e4SLinus Torvalds STm->cdevs[j] = cdev; 41541da177e4SLinus Torvalds 41551da177e4SLinus Torvalds } 415613026a6bSJeff Garzik error = do_create_class_files(tpnt, dev_num, mode); 415713026a6bSJeff Garzik if (error) 415813026a6bSJeff Garzik goto out_free_tape; 41591da177e4SLinus Torvalds } 41601da177e4SLinus Torvalds 416142252854SKai Makisara sdev_printk(KERN_NOTICE, SDp, 41628b1ea24cSRene Herman "Attached scsi tape %s\n", tape_name(tpnt)); 416342252854SKai Makisara sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n", 41641da177e4SLinus Torvalds tape_name(tpnt), tpnt->try_dio ? "yes" : "no", 41658b05b773SMike Christie queue_dma_alignment(SDp->request_queue) + 1); 41661da177e4SLinus Torvalds 41671da177e4SLinus Torvalds return 0; 41681da177e4SLinus Torvalds 41691da177e4SLinus Torvalds out_free_tape: 41701da177e4SLinus Torvalds for (mode=0; mode < ST_NBR_MODES; mode++) { 41711da177e4SLinus Torvalds STm = &(tpnt->modes[mode]); 41721da177e4SLinus Torvalds sysfs_remove_link(&tpnt->device->sdev_gendev.kobj, 41731da177e4SLinus Torvalds "tape"); 41741da177e4SLinus Torvalds for (j=0; j < 2; j++) { 41751da177e4SLinus Torvalds if (STm->cdevs[j]) { 41761da177e4SLinus Torvalds if (cdev == STm->cdevs[j]) 41771da177e4SLinus Torvalds cdev = NULL; 4178ee959b00STony Jones device_destroy(st_sysfs_class, 4179d253878bSgregkh@suse.de MKDEV(SCSI_TAPE_MAJOR, 41801da177e4SLinus Torvalds TAPE_MINOR(i, mode, j))); 41811da177e4SLinus Torvalds cdev_del(STm->cdevs[j]); 41821da177e4SLinus Torvalds } 41831da177e4SLinus Torvalds } 41841da177e4SLinus Torvalds } 41851da177e4SLinus Torvalds if (cdev) 41861da177e4SLinus Torvalds cdev_del(cdev); 41871da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 41881da177e4SLinus Torvalds scsi_tapes[dev_num] = NULL; 41891da177e4SLinus Torvalds st_nr_dev--; 41901da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 41911da177e4SLinus Torvalds out_put_disk: 41921da177e4SLinus Torvalds put_disk(disk); 41931da177e4SLinus Torvalds kfree(tpnt); 41941da177e4SLinus Torvalds out_buffer_free: 41951da177e4SLinus Torvalds kfree(buffer); 41961da177e4SLinus Torvalds out: 41971da177e4SLinus Torvalds return -ENODEV; 41981da177e4SLinus Torvalds }; 41991da177e4SLinus Torvalds 42001da177e4SLinus Torvalds 42011da177e4SLinus Torvalds static int st_remove(struct device *dev) 42021da177e4SLinus Torvalds { 42031da177e4SLinus Torvalds struct scsi_device *SDp = to_scsi_device(dev); 42041da177e4SLinus Torvalds struct scsi_tape *tpnt; 42051da177e4SLinus Torvalds int i, j, mode; 42061da177e4SLinus Torvalds 42071da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 42081da177e4SLinus Torvalds for (i = 0; i < st_dev_max; i++) { 42091da177e4SLinus Torvalds tpnt = scsi_tapes[i]; 42101da177e4SLinus Torvalds if (tpnt != NULL && tpnt->device == SDp) { 42111da177e4SLinus Torvalds scsi_tapes[i] = NULL; 42121da177e4SLinus Torvalds st_nr_dev--; 42131da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 42141da177e4SLinus Torvalds sysfs_remove_link(&tpnt->device->sdev_gendev.kobj, 42151da177e4SLinus Torvalds "tape"); 42161da177e4SLinus Torvalds for (mode = 0; mode < ST_NBR_MODES; ++mode) { 42171da177e4SLinus Torvalds for (j=0; j < 2; j++) { 4218ee959b00STony Jones device_destroy(st_sysfs_class, 4219d253878bSgregkh@suse.de MKDEV(SCSI_TAPE_MAJOR, 42201da177e4SLinus Torvalds TAPE_MINOR(i, mode, j))); 42211da177e4SLinus Torvalds cdev_del(tpnt->modes[mode].cdevs[j]); 42221da177e4SLinus Torvalds tpnt->modes[mode].cdevs[j] = NULL; 42231da177e4SLinus Torvalds } 42241da177e4SLinus Torvalds } 4225f03a5670SKai Makisara 42260b950672SArjan van de Ven mutex_lock(&st_ref_mutex); 4227f03a5670SKai Makisara kref_put(&tpnt->kref, scsi_tape_release); 42280b950672SArjan van de Ven mutex_unlock(&st_ref_mutex); 4229f03a5670SKai Makisara return 0; 4230f03a5670SKai Makisara } 4231f03a5670SKai Makisara } 4232f03a5670SKai Makisara 4233f03a5670SKai Makisara write_unlock(&st_dev_arr_lock); 4234f03a5670SKai Makisara return 0; 4235f03a5670SKai Makisara } 4236f03a5670SKai Makisara 4237f03a5670SKai Makisara /** 4238f03a5670SKai Makisara * scsi_tape_release - Called to free the Scsi_Tape structure 4239f03a5670SKai Makisara * @kref: pointer to embedded kref 4240f03a5670SKai Makisara * 42410b950672SArjan van de Ven * st_ref_mutex must be held entering this routine. Because it is 4242f03a5670SKai Makisara * called on last put, you should always use the scsi_tape_get() 4243f03a5670SKai Makisara * scsi_tape_put() helpers which manipulate the semaphore directly 4244f03a5670SKai Makisara * and never do a direct kref_put(). 4245f03a5670SKai Makisara **/ 4246f03a5670SKai Makisara static void scsi_tape_release(struct kref *kref) 4247f03a5670SKai Makisara { 4248f03a5670SKai Makisara struct scsi_tape *tpnt = to_scsi_tape(kref); 4249f03a5670SKai Makisara struct gendisk *disk = tpnt->disk; 4250f03a5670SKai Makisara 42511da177e4SLinus Torvalds tpnt->device = NULL; 42521da177e4SLinus Torvalds 42531da177e4SLinus Torvalds if (tpnt->buffer) { 42541da177e4SLinus Torvalds tpnt->buffer->orig_frp_segs = 0; 42551da177e4SLinus Torvalds normalize_buffer(tpnt->buffer); 42561da177e4SLinus Torvalds kfree(tpnt->buffer); 42571da177e4SLinus Torvalds } 42581da177e4SLinus Torvalds 4259f03a5670SKai Makisara disk->private_data = NULL; 4260f03a5670SKai Makisara put_disk(disk); 4261f03a5670SKai Makisara kfree(tpnt); 4262f03a5670SKai Makisara return; 42631da177e4SLinus Torvalds } 42641da177e4SLinus Torvalds 42651da177e4SLinus Torvalds static int __init init_st(void) 42661da177e4SLinus Torvalds { 426713026a6bSJeff Garzik int err; 426813026a6bSJeff Garzik 42691da177e4SLinus Torvalds validate_options(); 42701da177e4SLinus Torvalds 427113026a6bSJeff Garzik printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n", 42721da177e4SLinus Torvalds verstr, st_fixed_buffer_size, st_max_sg_segs); 42731da177e4SLinus Torvalds 4274d253878bSgregkh@suse.de st_sysfs_class = class_create(THIS_MODULE, "scsi_tape"); 42751da177e4SLinus Torvalds if (IS_ERR(st_sysfs_class)) { 42761da177e4SLinus Torvalds printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n"); 427713026a6bSJeff Garzik return PTR_ERR(st_sysfs_class); 42781da177e4SLinus Torvalds } 42791da177e4SLinus Torvalds 428013026a6bSJeff Garzik err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 428113026a6bSJeff Garzik ST_MAX_TAPE_ENTRIES, "st"); 428213026a6bSJeff Garzik if (err) { 428313026a6bSJeff Garzik printk(KERN_ERR "Unable to get major %d for SCSI tapes\n", 428413026a6bSJeff Garzik SCSI_TAPE_MAJOR); 428513026a6bSJeff Garzik goto err_class; 42861da177e4SLinus Torvalds } 428713026a6bSJeff Garzik 428813026a6bSJeff Garzik err = scsi_register_driver(&st_template.gendrv); 428913026a6bSJeff Garzik if (err) 429013026a6bSJeff Garzik goto err_chrdev; 429113026a6bSJeff Garzik 4292405ae7d3SRobert P. J. Day err = do_create_sysfs_files(); 429313026a6bSJeff Garzik if (err) 429413026a6bSJeff Garzik goto err_scsidrv; 429513026a6bSJeff Garzik 429613026a6bSJeff Garzik return 0; 429713026a6bSJeff Garzik 429813026a6bSJeff Garzik err_scsidrv: 429913026a6bSJeff Garzik scsi_unregister_driver(&st_template.gendrv); 430013026a6bSJeff Garzik err_chrdev: 43011da177e4SLinus Torvalds unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 43021da177e4SLinus Torvalds ST_MAX_TAPE_ENTRIES); 430313026a6bSJeff Garzik err_class: 4304c2c96f46SKai Makisara class_destroy(st_sysfs_class); 430513026a6bSJeff Garzik return err; 43061da177e4SLinus Torvalds } 43071da177e4SLinus Torvalds 43081da177e4SLinus Torvalds static void __exit exit_st(void) 43091da177e4SLinus Torvalds { 4310405ae7d3SRobert P. J. Day do_remove_sysfs_files(); 43111da177e4SLinus Torvalds scsi_unregister_driver(&st_template.gendrv); 43121da177e4SLinus Torvalds unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 43131da177e4SLinus Torvalds ST_MAX_TAPE_ENTRIES); 4314c2c96f46SKai Makisara class_destroy(st_sysfs_class); 43151da177e4SLinus Torvalds kfree(scsi_tapes); 43161da177e4SLinus Torvalds printk(KERN_INFO "st: Unloaded.\n"); 43171da177e4SLinus Torvalds } 43181da177e4SLinus Torvalds 43191da177e4SLinus Torvalds module_init(init_st); 43201da177e4SLinus Torvalds module_exit(exit_st); 43211da177e4SLinus Torvalds 43221da177e4SLinus Torvalds 43231da177e4SLinus Torvalds /* The sysfs driver interface. Read-only at the moment */ 43241da177e4SLinus Torvalds static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf) 43251da177e4SLinus Torvalds { 43261da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io); 43271da177e4SLinus Torvalds } 43281da177e4SLinus Torvalds static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL); 43291da177e4SLinus Torvalds 43301da177e4SLinus Torvalds static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf) 43311da177e4SLinus Torvalds { 43321da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size); 43331da177e4SLinus Torvalds } 43341da177e4SLinus Torvalds static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL); 43351da177e4SLinus Torvalds 43361da177e4SLinus Torvalds static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf) 43371da177e4SLinus Torvalds { 43381da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs); 43391da177e4SLinus Torvalds } 43401da177e4SLinus Torvalds static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL); 43411da177e4SLinus Torvalds 43421da177e4SLinus Torvalds static ssize_t st_version_show(struct device_driver *ddd, char *buf) 43431da177e4SLinus Torvalds { 43441da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr); 43451da177e4SLinus Torvalds } 43461da177e4SLinus Torvalds static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL); 43471da177e4SLinus Torvalds 4348405ae7d3SRobert P. J. Day static int do_create_sysfs_files(void) 43491da177e4SLinus Torvalds { 4350405ae7d3SRobert P. J. Day struct device_driver *sysfs = &st_template.gendrv; 435113026a6bSJeff Garzik int err; 43521da177e4SLinus Torvalds 4353405ae7d3SRobert P. J. Day err = driver_create_file(sysfs, &driver_attr_try_direct_io); 435413026a6bSJeff Garzik if (err) 435513026a6bSJeff Garzik return err; 4356405ae7d3SRobert P. J. Day err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size); 435713026a6bSJeff Garzik if (err) 435813026a6bSJeff Garzik goto err_try_direct_io; 4359405ae7d3SRobert P. J. Day err = driver_create_file(sysfs, &driver_attr_max_sg_segs); 436013026a6bSJeff Garzik if (err) 436113026a6bSJeff Garzik goto err_attr_fixed_buf; 4362405ae7d3SRobert P. J. Day err = driver_create_file(sysfs, &driver_attr_version); 436313026a6bSJeff Garzik if (err) 436413026a6bSJeff Garzik goto err_attr_max_sg; 436513026a6bSJeff Garzik 436613026a6bSJeff Garzik return 0; 436713026a6bSJeff Garzik 436813026a6bSJeff Garzik err_attr_max_sg: 4369405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_max_sg_segs); 437013026a6bSJeff Garzik err_attr_fixed_buf: 4371405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_fixed_buffer_size); 437213026a6bSJeff Garzik err_try_direct_io: 4373405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_try_direct_io); 437413026a6bSJeff Garzik return err; 43751da177e4SLinus Torvalds } 43761da177e4SLinus Torvalds 4377405ae7d3SRobert P. J. Day static void do_remove_sysfs_files(void) 43781da177e4SLinus Torvalds { 4379405ae7d3SRobert P. J. Day struct device_driver *sysfs = &st_template.gendrv; 43801da177e4SLinus Torvalds 4381405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_version); 4382405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_max_sg_segs); 4383405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_fixed_buffer_size); 4384405ae7d3SRobert P. J. Day driver_remove_file(sysfs, &driver_attr_try_direct_io); 43851da177e4SLinus Torvalds } 43861da177e4SLinus Torvalds 43871da177e4SLinus Torvalds 43881da177e4SLinus Torvalds /* The sysfs simple class interface */ 4389ee959b00STony Jones static ssize_t 4390ee959b00STony Jones st_defined_show(struct device *dev, struct device_attribute *attr, char *buf) 43911da177e4SLinus Torvalds { 43927d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 43931da177e4SLinus Torvalds ssize_t l = 0; 43941da177e4SLinus Torvalds 43951da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined); 43961da177e4SLinus Torvalds return l; 43971da177e4SLinus Torvalds } 43981da177e4SLinus Torvalds 4399ee959b00STony Jones DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL); 44001da177e4SLinus Torvalds 4401ee959b00STony Jones static ssize_t 4402ee959b00STony Jones st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf) 44031da177e4SLinus Torvalds { 44047d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 44051da177e4SLinus Torvalds ssize_t l = 0; 44061da177e4SLinus Torvalds 44071da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize); 44081da177e4SLinus Torvalds return l; 44091da177e4SLinus Torvalds } 44101da177e4SLinus Torvalds 4411ee959b00STony Jones DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL); 44121da177e4SLinus Torvalds 4413ee959b00STony Jones static ssize_t 4414ee959b00STony Jones st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf) 44151da177e4SLinus Torvalds { 44167d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 44171da177e4SLinus Torvalds ssize_t l = 0; 44181da177e4SLinus Torvalds char *fmt; 44191da177e4SLinus Torvalds 44201da177e4SLinus Torvalds fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n"; 44211da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density); 44221da177e4SLinus Torvalds return l; 44231da177e4SLinus Torvalds } 44241da177e4SLinus Torvalds 4425ee959b00STony Jones DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL); 44261da177e4SLinus Torvalds 4427ee959b00STony Jones static ssize_t 4428ee959b00STony Jones st_defcompression_show(struct device *dev, struct device_attribute *attr, 4429ee959b00STony Jones char *buf) 44301da177e4SLinus Torvalds { 44317d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 44321da177e4SLinus Torvalds ssize_t l = 0; 44331da177e4SLinus Torvalds 44341da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1); 44351da177e4SLinus Torvalds return l; 44361da177e4SLinus Torvalds } 44371da177e4SLinus Torvalds 4438ee959b00STony Jones DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL); 44391da177e4SLinus Torvalds 4440ee959b00STony Jones static ssize_t 4441ee959b00STony Jones st_options_show(struct device *dev, struct device_attribute *attr, char *buf) 4442b174be02SKai Makisara { 44437d15d6a4SJames Bottomley struct st_modedef *STm = dev_get_drvdata(dev); 4444b174be02SKai Makisara struct scsi_tape *STp; 4445b174be02SKai Makisara int i, j, options; 4446b174be02SKai Makisara ssize_t l = 0; 4447b174be02SKai Makisara 4448b174be02SKai Makisara for (i=0; i < st_dev_max; i++) { 4449b174be02SKai Makisara for (j=0; j < ST_NBR_MODES; j++) 4450b174be02SKai Makisara if (&scsi_tapes[i]->modes[j] == STm) 4451b174be02SKai Makisara break; 4452b174be02SKai Makisara if (j < ST_NBR_MODES) 4453b174be02SKai Makisara break; 4454b174be02SKai Makisara } 4455b174be02SKai Makisara if (i == st_dev_max) 4456b174be02SKai Makisara return 0; /* should never happen */ 4457b174be02SKai Makisara 4458b174be02SKai Makisara STp = scsi_tapes[i]; 4459b174be02SKai Makisara 4460b174be02SKai Makisara options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0; 4461b174be02SKai Makisara options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0; 4462b174be02SKai Makisara options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0; 4463b174be02SKai Makisara DEB( options |= debugging ? MT_ST_DEBUGGING : 0 ); 4464b174be02SKai Makisara options |= STp->two_fm ? MT_ST_TWO_FM : 0; 4465b174be02SKai Makisara options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0; 4466b174be02SKai Makisara options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0; 4467b174be02SKai Makisara options |= STp->can_bsr ? MT_ST_CAN_BSR : 0; 4468b174be02SKai Makisara options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0; 4469b174be02SKai Makisara options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0; 4470b174be02SKai Makisara options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0; 4471b174be02SKai Makisara options |= STm->sysv ? MT_ST_SYSV : 0; 4472b174be02SKai Makisara options |= STp->immediate ? MT_ST_NOWAIT : 0; 4473b174be02SKai Makisara options |= STp->sili ? MT_ST_SILI : 0; 4474b174be02SKai Makisara 4475b174be02SKai Makisara l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options); 4476b174be02SKai Makisara return l; 4477b174be02SKai Makisara } 4478b174be02SKai Makisara 4479ee959b00STony Jones DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL); 4480b174be02SKai Makisara 448113026a6bSJeff Garzik static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode) 44821da177e4SLinus Torvalds { 44831da177e4SLinus Torvalds int i, rew, error; 44841da177e4SLinus Torvalds char name[10]; 4485ee959b00STony Jones struct device *st_class_member; 44861da177e4SLinus Torvalds 44871da177e4SLinus Torvalds for (rew=0; rew < 2; rew++) { 44881da177e4SLinus Torvalds /* Make sure that the minor numbers corresponding to the four 44891da177e4SLinus Torvalds first modes always get the same names */ 44901da177e4SLinus Torvalds i = mode << (4 - ST_NBR_MODE_BITS); 44911da177e4SLinus Torvalds snprintf(name, 10, "%s%s%s", rew ? "n" : "", 44921da177e4SLinus Torvalds STp->disk->disk_name, st_formats[i]); 44931da177e4SLinus Torvalds st_class_member = 4494d73a1a67SGreg Kroah-Hartman device_create(st_sysfs_class, &STp->device->sdev_gendev, 44951da177e4SLinus Torvalds MKDEV(SCSI_TAPE_MAJOR, 4496d73a1a67SGreg Kroah-Hartman TAPE_MINOR(dev_num, mode, rew)), 4497d73a1a67SGreg Kroah-Hartman &STp->modes[mode], "%s", name); 44981da177e4SLinus Torvalds if (IS_ERR(st_class_member)) { 4499ee959b00STony Jones printk(KERN_WARNING "st%d: device_create failed\n", 45001da177e4SLinus Torvalds dev_num); 450113026a6bSJeff Garzik error = PTR_ERR(st_class_member); 45021da177e4SLinus Torvalds goto out; 45031da177e4SLinus Torvalds } 45041da177e4SLinus Torvalds 4505ee959b00STony Jones error = device_create_file(st_class_member, 4506ee959b00STony Jones &dev_attr_defined); 450713026a6bSJeff Garzik if (error) goto out; 4508ee959b00STony Jones error = device_create_file(st_class_member, 4509ee959b00STony Jones &dev_attr_default_blksize); 451013026a6bSJeff Garzik if (error) goto out; 4511ee959b00STony Jones error = device_create_file(st_class_member, 4512ee959b00STony Jones &dev_attr_default_density); 451313026a6bSJeff Garzik if (error) goto out; 4514ee959b00STony Jones error = device_create_file(st_class_member, 4515ee959b00STony Jones &dev_attr_default_compression); 451613026a6bSJeff Garzik if (error) goto out; 4517ee959b00STony Jones error = device_create_file(st_class_member, 4518ee959b00STony Jones &dev_attr_options); 4519b174be02SKai Makisara if (error) goto out; 452013026a6bSJeff Garzik 45211da177e4SLinus Torvalds if (mode == 0 && rew == 0) { 45221da177e4SLinus Torvalds error = sysfs_create_link(&STp->device->sdev_gendev.kobj, 45231da177e4SLinus Torvalds &st_class_member->kobj, 45241da177e4SLinus Torvalds "tape"); 45251da177e4SLinus Torvalds if (error) { 45261da177e4SLinus Torvalds printk(KERN_ERR 45271da177e4SLinus Torvalds "st%d: Can't create sysfs link from SCSI device.\n", 45281da177e4SLinus Torvalds dev_num); 452913026a6bSJeff Garzik goto out; 45301da177e4SLinus Torvalds } 45311da177e4SLinus Torvalds } 45321da177e4SLinus Torvalds } 453313026a6bSJeff Garzik 453413026a6bSJeff Garzik return 0; 453513026a6bSJeff Garzik 45361da177e4SLinus Torvalds out: 453713026a6bSJeff Garzik return error; 45381da177e4SLinus Torvalds } 45391da177e4SLinus Torvalds 45401da177e4SLinus Torvalds /* The following functions may be useful for a larger audience. */ 45411da177e4SLinus Torvalds static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages, 45421da177e4SLinus Torvalds unsigned long uaddr, size_t count, int rw) 45431da177e4SLinus Torvalds { 454407542b83SJames Bottomley unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT; 454507542b83SJames Bottomley unsigned long start = uaddr >> PAGE_SHIFT; 454607542b83SJames Bottomley const int nr_pages = end - start; 45471da177e4SLinus Torvalds int res, i, j; 45481da177e4SLinus Torvalds struct page **pages; 45491da177e4SLinus Torvalds 45501da177e4SLinus Torvalds /* User attempted Overflow! */ 45511da177e4SLinus Torvalds if ((uaddr + count) < uaddr) 45521da177e4SLinus Torvalds return -EINVAL; 45531da177e4SLinus Torvalds 45541da177e4SLinus Torvalds /* Too big */ 45551da177e4SLinus Torvalds if (nr_pages > max_pages) 45561da177e4SLinus Torvalds return -ENOMEM; 45571da177e4SLinus Torvalds 45581da177e4SLinus Torvalds /* Hmm? */ 45591da177e4SLinus Torvalds if (count == 0) 45601da177e4SLinus Torvalds return 0; 45611da177e4SLinus Torvalds 45621da177e4SLinus Torvalds if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL) 45631da177e4SLinus Torvalds return -ENOMEM; 45641da177e4SLinus Torvalds 45651da177e4SLinus Torvalds /* Try to fault in all of the necessary pages */ 45661da177e4SLinus Torvalds down_read(¤t->mm->mmap_sem); 45671da177e4SLinus Torvalds /* rw==READ means read from drive, write into memory area */ 45681da177e4SLinus Torvalds res = get_user_pages( 45691da177e4SLinus Torvalds current, 45701da177e4SLinus Torvalds current->mm, 45711da177e4SLinus Torvalds uaddr, 45721da177e4SLinus Torvalds nr_pages, 45731da177e4SLinus Torvalds rw == READ, 45741da177e4SLinus Torvalds 0, /* don't force */ 45751da177e4SLinus Torvalds pages, 45761da177e4SLinus Torvalds NULL); 45771da177e4SLinus Torvalds up_read(¤t->mm->mmap_sem); 45781da177e4SLinus Torvalds 45791da177e4SLinus Torvalds /* Errors and no page mapped should return here */ 45801da177e4SLinus Torvalds if (res < nr_pages) 45811da177e4SLinus Torvalds goto out_unmap; 45821da177e4SLinus Torvalds 45831da177e4SLinus Torvalds for (i=0; i < nr_pages; i++) { 45841da177e4SLinus Torvalds /* FIXME: flush superflous for rw==READ, 45851da177e4SLinus Torvalds * probably wrong function for rw==WRITE 45861da177e4SLinus Torvalds */ 45871da177e4SLinus Torvalds flush_dcache_page(pages[i]); 45881da177e4SLinus Torvalds } 45891da177e4SLinus Torvalds 45901da177e4SLinus Torvalds /* Populate the scatter/gather list */ 4591642f1490SJens Axboe sg_set_page(&sgl[0], pages[0], 0, uaddr & ~PAGE_MASK); 45921da177e4SLinus Torvalds if (nr_pages > 1) { 45931da177e4SLinus Torvalds sgl[0].length = PAGE_SIZE - sgl[0].offset; 45941da177e4SLinus Torvalds count -= sgl[0].length; 45951da177e4SLinus Torvalds for (i=1; i < nr_pages ; i++) { 4596642f1490SJens Axboe sg_set_page(&sgl[i], pages[i], 4597642f1490SJens Axboe count < PAGE_SIZE ? count : PAGE_SIZE, 0);; 45981da177e4SLinus Torvalds count -= PAGE_SIZE; 45991da177e4SLinus Torvalds } 46001da177e4SLinus Torvalds } 46011da177e4SLinus Torvalds else { 46021da177e4SLinus Torvalds sgl[0].length = count; 46031da177e4SLinus Torvalds } 46041da177e4SLinus Torvalds 46051da177e4SLinus Torvalds kfree(pages); 46061da177e4SLinus Torvalds return nr_pages; 46071da177e4SLinus Torvalds 46081da177e4SLinus Torvalds out_unmap: 46091da177e4SLinus Torvalds if (res > 0) { 46101da177e4SLinus Torvalds for (j=0; j < res; j++) 46111da177e4SLinus Torvalds page_cache_release(pages[j]); 46126bc733e9SHugh Dickins res = 0; 46131da177e4SLinus Torvalds } 46141da177e4SLinus Torvalds kfree(pages); 46151da177e4SLinus Torvalds return res; 46161da177e4SLinus Torvalds } 46171da177e4SLinus Torvalds 46181da177e4SLinus Torvalds 46191da177e4SLinus Torvalds /* And unmap them... */ 46201da177e4SLinus Torvalds static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages, 46211da177e4SLinus Torvalds int dirtied) 46221da177e4SLinus Torvalds { 46231da177e4SLinus Torvalds int i; 46241da177e4SLinus Torvalds 46251da177e4SLinus Torvalds for (i=0; i < nr_pages; i++) { 462645711f1aSJens Axboe struct page *page = sg_page(&sgl[i]); 4627b5810039SNick Piggin 4628b5810039SNick Piggin if (dirtied) 4629b5810039SNick Piggin SetPageDirty(page); 46301da177e4SLinus Torvalds /* FIXME: cache flush missing for rw==READ 46311da177e4SLinus Torvalds * FIXME: call the correct reference counting function 46321da177e4SLinus Torvalds */ 4633b5810039SNick Piggin page_cache_release(page); 46341da177e4SLinus Torvalds } 46351da177e4SLinus Torvalds 46361da177e4SLinus Torvalds return 0; 46371da177e4SLinus Torvalds } 4638