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 121da177e4SLinus Torvalds Copyright 1992 - 2005 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 20f03a5670SKai Makisara static char *verstr = "20050802"; 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/devfs_fs_kernel.h> 391da177e4SLinus Torvalds #include <linux/cdev.h> 401da177e4SLinus Torvalds #include <linux/delay.h> 411da177e4SLinus Torvalds 421da177e4SLinus Torvalds #include <asm/uaccess.h> 431da177e4SLinus Torvalds #include <asm/dma.h> 441da177e4SLinus Torvalds #include <asm/system.h> 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds #include <scsi/scsi.h> 471da177e4SLinus Torvalds #include <scsi/scsi_dbg.h> 481da177e4SLinus Torvalds #include <scsi/scsi_device.h> 491da177e4SLinus Torvalds #include <scsi/scsi_driver.h> 501da177e4SLinus Torvalds #include <scsi/scsi_eh.h> 511da177e4SLinus Torvalds #include <scsi/scsi_host.h> 521da177e4SLinus Torvalds #include <scsi/scsi_ioctl.h> 531da177e4SLinus Torvalds #include <scsi/scsi_request.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"); 901da177e4SLinus Torvalds MODULE_DESCRIPTION("SCSI Tape Driver"); 911da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 921da177e4SLinus Torvalds 931da177e4SLinus Torvalds /* Set 'perm' (4th argument) to 0 to disable module_param's definition 941da177e4SLinus Torvalds * of sysfs parameters (which module_param doesn't yet support). 951da177e4SLinus Torvalds * Sysfs parameters defined explicitly later. 961da177e4SLinus Torvalds */ 971da177e4SLinus Torvalds module_param_named(buffer_kbs, buffer_kbs, int, 0); 981da177e4SLinus Torvalds MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)"); 991da177e4SLinus Torvalds module_param_named(max_sg_segs, max_sg_segs, int, 0); 1001da177e4SLinus Torvalds MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)"); 1011da177e4SLinus Torvalds module_param_named(try_direct_io, try_direct_io, int, 0); 1021da177e4SLinus Torvalds MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)"); 1031da177e4SLinus Torvalds 1041da177e4SLinus Torvalds /* Extra parameters for testing */ 1051da177e4SLinus Torvalds module_param_named(try_rdio, try_rdio, int, 0); 1061da177e4SLinus Torvalds MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible"); 1071da177e4SLinus Torvalds module_param_named(try_wdio, try_wdio, int, 0); 1081da177e4SLinus Torvalds MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible"); 1091da177e4SLinus Torvalds 1101da177e4SLinus Torvalds #ifndef MODULE 1111da177e4SLinus Torvalds static int write_threshold_kbs; /* retained for compatibility */ 1121da177e4SLinus Torvalds static struct st_dev_parm { 1131da177e4SLinus Torvalds char *name; 1141da177e4SLinus Torvalds int *val; 1151da177e4SLinus Torvalds } parms[] __initdata = { 1161da177e4SLinus Torvalds { 1171da177e4SLinus Torvalds "buffer_kbs", &buffer_kbs 1181da177e4SLinus Torvalds }, 1191da177e4SLinus Torvalds { /* Retained for compatibility with 2.4 */ 1201da177e4SLinus Torvalds "write_threshold_kbs", &write_threshold_kbs 1211da177e4SLinus Torvalds }, 1221da177e4SLinus Torvalds { 1231da177e4SLinus Torvalds "max_sg_segs", NULL 1241da177e4SLinus Torvalds }, 1251da177e4SLinus Torvalds { 1261da177e4SLinus Torvalds "try_direct_io", &try_direct_io 1271da177e4SLinus Torvalds } 1281da177e4SLinus Torvalds }; 1291da177e4SLinus Torvalds #endif 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds /* Restrict the number of modes so that names for all are assigned */ 1321da177e4SLinus Torvalds #if ST_NBR_MODES > 16 1331da177e4SLinus Torvalds #error "Maximum number of modes is 16" 1341da177e4SLinus Torvalds #endif 1351da177e4SLinus Torvalds /* Bit reversed order to get same names for same minors with all 1361da177e4SLinus Torvalds mode counts */ 1371da177e4SLinus Torvalds static char *st_formats[] = { 1381da177e4SLinus Torvalds "", "r", "k", "s", "l", "t", "o", "u", 1391da177e4SLinus Torvalds "m", "v", "p", "x", "a", "y", "q", "z"}; 1401da177e4SLinus Torvalds 1411da177e4SLinus Torvalds /* The default definitions have been moved to st_options.h */ 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE) 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds /* The buffer size should fit into the 24 bits for length in the 1461da177e4SLinus Torvalds 6-byte SCSI read and write commands. */ 1471da177e4SLinus Torvalds #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1) 1481da177e4SLinus Torvalds #error "Buffer size should not exceed (2 << 24 - 1) bytes!" 1491da177e4SLinus Torvalds #endif 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds static int debugging = DEBUG; 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds #define MAX_RETRIES 0 1541da177e4SLinus Torvalds #define MAX_WRITE_RETRIES 0 1551da177e4SLinus Torvalds #define MAX_READY_RETRIES 0 1561da177e4SLinus Torvalds #define NO_TAPE NOT_READY 1571da177e4SLinus Torvalds 1581da177e4SLinus Torvalds #define ST_TIMEOUT (900 * HZ) 1591da177e4SLinus Torvalds #define ST_LONG_TIMEOUT (14000 * HZ) 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds /* Remove mode bits and auto-rewind bit (7) */ 1621da177e4SLinus Torvalds #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \ 1631da177e4SLinus Torvalds (iminor(x) & ~(-1 << ST_MODE_SHIFT)) ) 1641da177e4SLinus Torvalds #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT) 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */ 1671da177e4SLinus Torvalds #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \ 1681da177e4SLinus Torvalds (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) ) 1691da177e4SLinus Torvalds 1701da177e4SLinus Torvalds /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower 1711da177e4SLinus Torvalds 24 bits) */ 1721da177e4SLinus Torvalds #define SET_DENS_AND_BLK 0x10001 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds static DEFINE_RWLOCK(st_dev_arr_lock); 1751da177e4SLinus Torvalds 1761da177e4SLinus Torvalds static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE; 1771da177e4SLinus Torvalds static int st_max_sg_segs = ST_MAX_SG; 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds static struct scsi_tape **scsi_tapes = NULL; 1801da177e4SLinus Torvalds 1811da177e4SLinus Torvalds static int modes_defined; 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds static struct st_buffer *new_tape_buffer(int, int, int); 1841da177e4SLinus Torvalds static int enlarge_buffer(struct st_buffer *, int, int); 1851da177e4SLinus Torvalds static void normalize_buffer(struct st_buffer *); 1861da177e4SLinus Torvalds static int append_to_buffer(const char __user *, struct st_buffer *, int); 1871da177e4SLinus Torvalds static int from_buffer(struct st_buffer *, char __user *, int); 1881da177e4SLinus Torvalds static void move_buffer_data(struct st_buffer *, int); 1891da177e4SLinus Torvalds static void buf_to_sg(struct st_buffer *, unsigned int); 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds static int st_map_user_pages(struct scatterlist *, const unsigned int, 1921da177e4SLinus Torvalds unsigned long, size_t, int, unsigned long); 1931da177e4SLinus Torvalds static int sgl_map_user_pages(struct scatterlist *, const unsigned int, 1941da177e4SLinus Torvalds unsigned long, size_t, int); 1951da177e4SLinus Torvalds static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int); 1961da177e4SLinus Torvalds 1971da177e4SLinus Torvalds static int st_probe(struct device *); 1981da177e4SLinus Torvalds static int st_remove(struct device *); 1991da177e4SLinus Torvalds static int st_init_command(struct scsi_cmnd *); 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds static void do_create_driverfs_files(void); 2021da177e4SLinus Torvalds static void do_remove_driverfs_files(void); 2031da177e4SLinus Torvalds static void 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 .init_command = st_init_command, 2131da177e4SLinus Torvalds }; 2141da177e4SLinus Torvalds 2151da177e4SLinus Torvalds static int st_compression(struct scsi_tape *, int); 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds static int find_partition(struct scsi_tape *); 2181da177e4SLinus Torvalds static int switch_partition(struct scsi_tape *); 2191da177e4SLinus Torvalds 2201da177e4SLinus Torvalds static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long); 2211da177e4SLinus Torvalds 222f03a5670SKai Makisara static void scsi_tape_release(struct kref *); 223f03a5670SKai Makisara 224f03a5670SKai Makisara #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref) 225f03a5670SKai Makisara 226f03a5670SKai Makisara static DECLARE_MUTEX(st_ref_sem); 227f03a5670SKai Makisara 2281da177e4SLinus Torvalds 2291da177e4SLinus Torvalds #include "osst_detect.h" 2301da177e4SLinus Torvalds #ifndef SIGS_FROM_OSST 2311da177e4SLinus Torvalds #define SIGS_FROM_OSST \ 2321da177e4SLinus Torvalds {"OnStream", "SC-", "", "osst"}, \ 2331da177e4SLinus Torvalds {"OnStream", "DI-", "", "osst"}, \ 2341da177e4SLinus Torvalds {"OnStream", "DP-", "", "osst"}, \ 2351da177e4SLinus Torvalds {"OnStream", "USB", "", "osst"}, \ 2361da177e4SLinus Torvalds {"OnStream", "FW-", "", "osst"} 2371da177e4SLinus Torvalds #endif 2381da177e4SLinus Torvalds 239f03a5670SKai Makisara static struct scsi_tape *scsi_tape_get(int dev) 240f03a5670SKai Makisara { 241f03a5670SKai Makisara struct scsi_tape *STp = NULL; 242f03a5670SKai Makisara 243f03a5670SKai Makisara down(&st_ref_sem); 244f03a5670SKai Makisara write_lock(&st_dev_arr_lock); 245f03a5670SKai Makisara 246f03a5670SKai Makisara if (dev < st_dev_max && scsi_tapes != NULL) 247f03a5670SKai Makisara STp = scsi_tapes[dev]; 248f03a5670SKai Makisara if (!STp) goto out; 249f03a5670SKai Makisara 250f03a5670SKai Makisara kref_get(&STp->kref); 251f03a5670SKai Makisara 252f03a5670SKai Makisara if (!STp->device) 253f03a5670SKai Makisara goto out_put; 254f03a5670SKai Makisara 255f03a5670SKai Makisara if (scsi_device_get(STp->device)) 256f03a5670SKai Makisara goto out_put; 257f03a5670SKai Makisara 258f03a5670SKai Makisara goto out; 259f03a5670SKai Makisara 260f03a5670SKai Makisara out_put: 261f03a5670SKai Makisara kref_put(&STp->kref, scsi_tape_release); 262f03a5670SKai Makisara STp = NULL; 263f03a5670SKai Makisara out: 264f03a5670SKai Makisara write_unlock(&st_dev_arr_lock); 265f03a5670SKai Makisara up(&st_ref_sem); 266f03a5670SKai Makisara return STp; 267f03a5670SKai Makisara } 268f03a5670SKai Makisara 269f03a5670SKai Makisara static void scsi_tape_put(struct scsi_tape *STp) 270f03a5670SKai Makisara { 271f03a5670SKai Makisara struct scsi_device *sdev = STp->device; 272f03a5670SKai Makisara 273f03a5670SKai Makisara down(&st_ref_sem); 274f03a5670SKai Makisara kref_put(&STp->kref, scsi_tape_release); 275f03a5670SKai Makisara scsi_device_put(sdev); 276f03a5670SKai Makisara up(&st_ref_sem); 277f03a5670SKai Makisara } 278f03a5670SKai Makisara 2791da177e4SLinus Torvalds struct st_reject_data { 2801da177e4SLinus Torvalds char *vendor; 2811da177e4SLinus Torvalds char *model; 2821da177e4SLinus Torvalds char *rev; 2831da177e4SLinus Torvalds char *driver_hint; /* Name of the correct driver, NULL if unknown */ 2841da177e4SLinus Torvalds }; 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds static struct st_reject_data reject_list[] = { 2871da177e4SLinus Torvalds /* {"XXX", "Yy-", "", NULL}, example */ 2881da177e4SLinus Torvalds SIGS_FROM_OSST, 2891da177e4SLinus Torvalds {NULL, }}; 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds /* If the device signature is on the list of incompatible drives, the 2921da177e4SLinus Torvalds function returns a pointer to the name of the correct driver (if known) */ 2931da177e4SLinus Torvalds static char * st_incompatible(struct scsi_device* SDp) 2941da177e4SLinus Torvalds { 2951da177e4SLinus Torvalds struct st_reject_data *rp; 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds for (rp=&(reject_list[0]); rp->vendor != NULL; rp++) 2981da177e4SLinus Torvalds if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) && 2991da177e4SLinus Torvalds !strncmp(rp->model, SDp->model, strlen(rp->model)) && 3001da177e4SLinus Torvalds !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) { 3011da177e4SLinus Torvalds if (rp->driver_hint) 3021da177e4SLinus Torvalds return rp->driver_hint; 3031da177e4SLinus Torvalds else 3041da177e4SLinus Torvalds return "unknown"; 3051da177e4SLinus Torvalds } 3061da177e4SLinus Torvalds return NULL; 3071da177e4SLinus Torvalds } 3081da177e4SLinus Torvalds 3091da177e4SLinus Torvalds 3101da177e4SLinus Torvalds static inline char *tape_name(struct scsi_tape *tape) 3111da177e4SLinus Torvalds { 3121da177e4SLinus Torvalds return tape->disk->disk_name; 3131da177e4SLinus Torvalds } 3141da177e4SLinus Torvalds 3151da177e4SLinus Torvalds 3161da177e4SLinus Torvalds static void st_analyze_sense(struct scsi_request *SRpnt, struct st_cmdstatus *s) 3171da177e4SLinus Torvalds { 3181da177e4SLinus Torvalds const u8 *ucp; 3191da177e4SLinus Torvalds const u8 *sense = SRpnt->sr_sense_buffer; 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds s->have_sense = scsi_request_normalize_sense(SRpnt, &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 */ 3481da177e4SLinus Torvalds static int st_chk_result(struct scsi_tape *STp, struct scsi_request * SRpnt) 3491da177e4SLinus Torvalds { 3501da177e4SLinus Torvalds int result = SRpnt->sr_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) { 3691da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x Len: %d\n", 3701da177e4SLinus Torvalds name, result, 3711da177e4SLinus Torvalds SRpnt->sr_cmnd[0], SRpnt->sr_cmnd[1], SRpnt->sr_cmnd[2], 3721da177e4SLinus Torvalds SRpnt->sr_cmnd[3], SRpnt->sr_cmnd[4], SRpnt->sr_cmnd[5], 3731da177e4SLinus Torvalds SRpnt->sr_bufflen); 3741da177e4SLinus Torvalds if (cmdstatp->have_sense) 3751da177e4SLinus Torvalds scsi_print_req_sense("st", SRpnt); 3761da177e4SLinus Torvalds } ) /* end DEB */ 3771da177e4SLinus Torvalds if (!debugging) { /* Abnormal conditions for tape */ 3781da177e4SLinus Torvalds if (!cmdstatp->have_sense) 3791da177e4SLinus Torvalds printk(KERN_WARNING 3801da177e4SLinus Torvalds "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n", 3811da177e4SLinus Torvalds name, result, suggestion(result), 3821da177e4SLinus Torvalds driver_byte(result) & DRIVER_MASK, host_byte(result)); 3831da177e4SLinus Torvalds else if (cmdstatp->have_sense && 3841da177e4SLinus Torvalds scode != NO_SENSE && 3851da177e4SLinus Torvalds scode != RECOVERED_ERROR && 3861da177e4SLinus Torvalds /* scode != UNIT_ATTENTION && */ 3871da177e4SLinus Torvalds scode != BLANK_CHECK && 3881da177e4SLinus Torvalds scode != VOLUME_OVERFLOW && 3891da177e4SLinus Torvalds SRpnt->sr_cmnd[0] != MODE_SENSE && 3901da177e4SLinus Torvalds SRpnt->sr_cmnd[0] != TEST_UNIT_READY) { 3911da177e4SLinus Torvalds printk(KERN_WARNING "%s: Error with sense data: ", name); 3921da177e4SLinus Torvalds scsi_print_req_sense("st", SRpnt); 3931da177e4SLinus Torvalds } 3941da177e4SLinus Torvalds } 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds if (cmdstatp->fixed_format && 3971da177e4SLinus Torvalds STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */ 3981da177e4SLinus Torvalds if (STp->cln_sense_value) 3991da177e4SLinus Torvalds STp->cleaning_req |= ((SRpnt->sr_sense_buffer[STp->cln_mode] & 4001da177e4SLinus Torvalds STp->cln_sense_mask) == STp->cln_sense_value); 4011da177e4SLinus Torvalds else 4021da177e4SLinus Torvalds STp->cleaning_req |= ((SRpnt->sr_sense_buffer[STp->cln_mode] & 4031da177e4SLinus Torvalds STp->cln_sense_mask) != 0); 4041da177e4SLinus Torvalds } 4051da177e4SLinus Torvalds if (cmdstatp->have_sense && 4061da177e4SLinus Torvalds cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17) 4071da177e4SLinus Torvalds STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */ 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds STp->pos_unknown |= STp->device->was_reset; 4101da177e4SLinus Torvalds 4111da177e4SLinus Torvalds if (cmdstatp->have_sense && 4121da177e4SLinus Torvalds scode == RECOVERED_ERROR 4131da177e4SLinus Torvalds #if ST_RECOVERED_WRITE_FATAL 4141da177e4SLinus Torvalds && SRpnt->sr_cmnd[0] != WRITE_6 4151da177e4SLinus Torvalds && SRpnt->sr_cmnd[0] != WRITE_FILEMARKS 4161da177e4SLinus Torvalds #endif 4171da177e4SLinus Torvalds ) { 4181da177e4SLinus Torvalds STp->recover_count++; 4191da177e4SLinus Torvalds STp->recover_reg++; 4201da177e4SLinus Torvalds 4211da177e4SLinus Torvalds DEB( 4221da177e4SLinus Torvalds if (debugging) { 4231da177e4SLinus Torvalds if (SRpnt->sr_cmnd[0] == READ_6) 4241da177e4SLinus Torvalds stp = "read"; 4251da177e4SLinus Torvalds else if (SRpnt->sr_cmnd[0] == WRITE_6) 4261da177e4SLinus Torvalds stp = "write"; 4271da177e4SLinus Torvalds else 4281da177e4SLinus Torvalds stp = "ioctl"; 4291da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp, 4301da177e4SLinus Torvalds STp->recover_count); 4311da177e4SLinus Torvalds } ) /* end DEB */ 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds if (cmdstatp->flags == 0) 4341da177e4SLinus Torvalds return 0; 4351da177e4SLinus Torvalds } 4361da177e4SLinus Torvalds return (-EIO); 4371da177e4SLinus Torvalds } 4381da177e4SLinus Torvalds 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds /* Wakeup from interrupt */ 4411da177e4SLinus Torvalds static void st_sleep_done(struct scsi_cmnd * SCpnt) 4421da177e4SLinus Torvalds { 4431da177e4SLinus Torvalds struct scsi_tape *STp = container_of(SCpnt->request->rq_disk->private_data, 4441da177e4SLinus Torvalds struct scsi_tape, driver); 4451da177e4SLinus Torvalds 4461da177e4SLinus Torvalds (STp->buffer)->cmdstat.midlevel_result = SCpnt->result; 4471da177e4SLinus Torvalds SCpnt->request->rq_status = RQ_SCSI_DONE; 4481da177e4SLinus Torvalds DEB( STp->write_pending = 0; ) 4491da177e4SLinus Torvalds 450f03a5670SKai Makisara if (SCpnt->request->waiting) 4511da177e4SLinus Torvalds complete(SCpnt->request->waiting); 4521da177e4SLinus Torvalds } 4531da177e4SLinus Torvalds 4541da177e4SLinus Torvalds /* Do the scsi command. Waits until command performed if do_wait is true. 4551da177e4SLinus Torvalds Otherwise write_behind_check() is used to check that the command 4561da177e4SLinus Torvalds has finished. */ 4571da177e4SLinus Torvalds static struct scsi_request * 4581da177e4SLinus Torvalds st_do_scsi(struct scsi_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd, 4591da177e4SLinus Torvalds int bytes, int direction, int timeout, int retries, int do_wait) 4601da177e4SLinus Torvalds { 461f03a5670SKai Makisara struct completion *waiting; 4621da177e4SLinus Torvalds unsigned char *bp; 4631da177e4SLinus Torvalds 464f03a5670SKai Makisara /* if async, make sure there's no command outstanding */ 465f03a5670SKai Makisara if (!do_wait && ((STp->buffer)->last_SRpnt)) { 466f03a5670SKai Makisara printk(KERN_ERR "%s: Async command already active.\n", 467f03a5670SKai Makisara tape_name(STp)); 468f03a5670SKai Makisara if (signal_pending(current)) 469f03a5670SKai Makisara (STp->buffer)->syscall_result = (-EINTR); 470f03a5670SKai Makisara else 471f03a5670SKai Makisara (STp->buffer)->syscall_result = (-EBUSY); 472f03a5670SKai Makisara return NULL; 473f03a5670SKai Makisara } 474f03a5670SKai Makisara 4751da177e4SLinus Torvalds if (SRpnt == NULL) { 4761da177e4SLinus Torvalds SRpnt = scsi_allocate_request(STp->device, GFP_ATOMIC); 4771da177e4SLinus Torvalds if (SRpnt == NULL) { 4781da177e4SLinus Torvalds DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n", 4791da177e4SLinus Torvalds tape_name(STp)); ); 4801da177e4SLinus Torvalds if (signal_pending(current)) 4811da177e4SLinus Torvalds (STp->buffer)->syscall_result = (-EINTR); 4821da177e4SLinus Torvalds else 4831da177e4SLinus Torvalds (STp->buffer)->syscall_result = (-EBUSY); 4841da177e4SLinus Torvalds return NULL; 4851da177e4SLinus Torvalds } 4861da177e4SLinus Torvalds } 4871da177e4SLinus Torvalds 488f03a5670SKai Makisara /* If async IO, set last_SRpnt. This ptr tells write_behind_check 489f03a5670SKai Makisara which IO is outstanding. It's nulled out when the IO completes. */ 490f03a5670SKai Makisara if (!do_wait) 491f03a5670SKai Makisara (STp->buffer)->last_SRpnt = SRpnt; 492f03a5670SKai Makisara 493f03a5670SKai Makisara waiting = &STp->wait; 494f03a5670SKai Makisara init_completion(waiting); 4951da177e4SLinus Torvalds SRpnt->sr_use_sg = STp->buffer->do_dio || (bytes > (STp->buffer)->frp[0].length); 4961da177e4SLinus Torvalds if (SRpnt->sr_use_sg) { 4971da177e4SLinus Torvalds if (!STp->buffer->do_dio) 4981da177e4SLinus Torvalds buf_to_sg(STp->buffer, bytes); 4991da177e4SLinus Torvalds SRpnt->sr_use_sg = (STp->buffer)->sg_segs; 5001da177e4SLinus Torvalds bp = (char *) &((STp->buffer)->sg[0]); 5011da177e4SLinus Torvalds } else 5021da177e4SLinus Torvalds bp = (STp->buffer)->b_data; 5031da177e4SLinus Torvalds SRpnt->sr_data_direction = direction; 5041da177e4SLinus Torvalds SRpnt->sr_cmd_len = 0; 505f03a5670SKai Makisara SRpnt->sr_request->waiting = waiting; 5061da177e4SLinus Torvalds SRpnt->sr_request->rq_status = RQ_SCSI_BUSY; 5071da177e4SLinus Torvalds SRpnt->sr_request->rq_disk = STp->disk; 508f03a5670SKai Makisara SRpnt->sr_request->end_io = blk_end_sync_rq; 5091da177e4SLinus Torvalds STp->buffer->cmdstat.have_sense = 0; 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds scsi_do_req(SRpnt, (void *) cmd, bp, bytes, 5121da177e4SLinus Torvalds st_sleep_done, timeout, retries); 5131da177e4SLinus Torvalds 5141da177e4SLinus Torvalds if (do_wait) { 515f03a5670SKai Makisara wait_for_completion(waiting); 5161da177e4SLinus Torvalds SRpnt->sr_request->waiting = NULL; 517f03a5670SKai Makisara if (SRpnt->sr_request->rq_status != RQ_SCSI_DONE) 518f03a5670SKai Makisara SRpnt->sr_result |= (DRIVER_ERROR << 24); 5191da177e4SLinus Torvalds (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt); 5201da177e4SLinus Torvalds } 5211da177e4SLinus Torvalds return SRpnt; 5221da177e4SLinus Torvalds } 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds 5251da177e4SLinus Torvalds /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if 5261da177e4SLinus Torvalds write has been correct but EOM early warning reached, -EIO if write ended in 5271da177e4SLinus Torvalds error or zero if write successful. Asynchronous writes are used only in 5281da177e4SLinus Torvalds variable block mode. */ 5291da177e4SLinus Torvalds static int write_behind_check(struct scsi_tape * STp) 5301da177e4SLinus Torvalds { 5311da177e4SLinus Torvalds int retval = 0; 5321da177e4SLinus Torvalds struct st_buffer *STbuffer; 5331da177e4SLinus Torvalds struct st_partstat *STps; 5341da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp; 535f03a5670SKai Makisara struct scsi_request *SRpnt; 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds STbuffer = STp->buffer; 5381da177e4SLinus Torvalds if (!STbuffer->writing) 5391da177e4SLinus Torvalds return 0; 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds DEB( 5421da177e4SLinus Torvalds if (STp->write_pending) 5431da177e4SLinus Torvalds STp->nbr_waits++; 5441da177e4SLinus Torvalds else 5451da177e4SLinus Torvalds STp->nbr_finished++; 5461da177e4SLinus Torvalds ) /* end DEB */ 5471da177e4SLinus Torvalds 5481da177e4SLinus Torvalds wait_for_completion(&(STp->wait)); 549f03a5670SKai Makisara SRpnt = STbuffer->last_SRpnt; 550f03a5670SKai Makisara STbuffer->last_SRpnt = NULL; 551f03a5670SKai Makisara SRpnt->sr_request->waiting = NULL; 552f03a5670SKai Makisara if (SRpnt->sr_request->rq_status != RQ_SCSI_DONE) 553f03a5670SKai Makisara SRpnt->sr_result |= (DRIVER_ERROR << 24); 5541da177e4SLinus Torvalds 555f03a5670SKai Makisara (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt); 556f03a5670SKai Makisara scsi_release_request(SRpnt); 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds STbuffer->buffer_bytes -= STbuffer->writing; 5591da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 5601da177e4SLinus Torvalds if (STps->drv_block >= 0) { 5611da177e4SLinus Torvalds if (STp->block_size == 0) 5621da177e4SLinus Torvalds STps->drv_block++; 5631da177e4SLinus Torvalds else 5641da177e4SLinus Torvalds STps->drv_block += STbuffer->writing / STp->block_size; 5651da177e4SLinus Torvalds } 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds cmdstatp = &STbuffer->cmdstat; 5681da177e4SLinus Torvalds if (STbuffer->syscall_result) { 5691da177e4SLinus Torvalds retval = -EIO; 5701da177e4SLinus Torvalds if (cmdstatp->have_sense && !cmdstatp->deferred && 5711da177e4SLinus Torvalds (cmdstatp->flags & SENSE_EOM) && 5721da177e4SLinus Torvalds (cmdstatp->sense_hdr.sense_key == NO_SENSE || 5731da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) { 5741da177e4SLinus Torvalds /* EOM at write-behind, has all data been written? */ 5751da177e4SLinus Torvalds if (!cmdstatp->remainder_valid || 5761da177e4SLinus Torvalds cmdstatp->uremainder64 == 0) 5771da177e4SLinus Torvalds retval = -ENOSPC; 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds if (retval == -EIO) 5801da177e4SLinus Torvalds STps->drv_block = -1; 5811da177e4SLinus Torvalds } 5821da177e4SLinus Torvalds STbuffer->writing = 0; 5831da177e4SLinus Torvalds 5841da177e4SLinus Torvalds DEB(if (debugging && retval) 5851da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n", 5861da177e4SLinus Torvalds tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */ 5871da177e4SLinus Torvalds 5881da177e4SLinus Torvalds return retval; 5891da177e4SLinus Torvalds } 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds 5921da177e4SLinus Torvalds /* Step over EOF if it has been inadvertently crossed (ioctl not used because 5931da177e4SLinus Torvalds it messes up the block number). */ 5941da177e4SLinus Torvalds static int cross_eof(struct scsi_tape * STp, int forward) 5951da177e4SLinus Torvalds { 5961da177e4SLinus Torvalds struct scsi_request *SRpnt; 5971da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds cmd[0] = SPACE; 6001da177e4SLinus Torvalds cmd[1] = 0x01; /* Space FileMarks */ 6011da177e4SLinus Torvalds if (forward) { 6021da177e4SLinus Torvalds cmd[2] = cmd[3] = 0; 6031da177e4SLinus Torvalds cmd[4] = 1; 6041da177e4SLinus Torvalds } else 6051da177e4SLinus Torvalds cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */ 6061da177e4SLinus Torvalds cmd[5] = 0; 6071da177e4SLinus Torvalds 6081da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n", 6091da177e4SLinus Torvalds tape_name(STp), forward ? "forward" : "backward")); 6101da177e4SLinus Torvalds 6111da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE, 6121da177e4SLinus Torvalds STp->device->timeout, MAX_RETRIES, 1); 6131da177e4SLinus Torvalds if (!SRpnt) 6141da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds scsi_release_request(SRpnt); 6171da177e4SLinus Torvalds SRpnt = NULL; 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds if ((STp->buffer)->cmdstat.midlevel_result != 0) 6201da177e4SLinus Torvalds printk(KERN_ERR "%s: Stepping over filemark %s failed.\n", 6211da177e4SLinus Torvalds tape_name(STp), forward ? "forward" : "backward"); 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 6241da177e4SLinus Torvalds } 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds /* Flush the write buffer (never need to write if variable blocksize). */ 6281da177e4SLinus Torvalds static int flush_write_buffer(struct scsi_tape * STp) 6291da177e4SLinus Torvalds { 6301da177e4SLinus Torvalds int offset, transfer, blks; 6311da177e4SLinus Torvalds int result; 6321da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 6331da177e4SLinus Torvalds struct scsi_request *SRpnt; 6341da177e4SLinus Torvalds struct st_partstat *STps; 6351da177e4SLinus Torvalds 6361da177e4SLinus Torvalds result = write_behind_check(STp); 6371da177e4SLinus Torvalds if (result) 6381da177e4SLinus Torvalds return result; 6391da177e4SLinus Torvalds 6401da177e4SLinus Torvalds result = 0; 6411da177e4SLinus Torvalds if (STp->dirty == 1) { 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds offset = (STp->buffer)->buffer_bytes; 6441da177e4SLinus Torvalds transfer = ((offset + STp->block_size - 1) / 6451da177e4SLinus Torvalds STp->block_size) * STp->block_size; 6461da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n", 6471da177e4SLinus Torvalds tape_name(STp), transfer)); 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds memset((STp->buffer)->b_data + offset, 0, transfer - offset); 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 6521da177e4SLinus Torvalds cmd[0] = WRITE_6; 6531da177e4SLinus Torvalds cmd[1] = 1; 6541da177e4SLinus Torvalds blks = transfer / STp->block_size; 6551da177e4SLinus Torvalds cmd[2] = blks >> 16; 6561da177e4SLinus Torvalds cmd[3] = blks >> 8; 6571da177e4SLinus Torvalds cmd[4] = blks; 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE, 6601da177e4SLinus Torvalds STp->device->timeout, MAX_WRITE_RETRIES, 1); 6611da177e4SLinus Torvalds if (!SRpnt) 6621da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 6631da177e4SLinus Torvalds 6641da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 6651da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0) { 6661da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 6671da177e4SLinus Torvalds 6681da177e4SLinus Torvalds if (cmdstatp->have_sense && !cmdstatp->deferred && 6691da177e4SLinus Torvalds (cmdstatp->flags & SENSE_EOM) && 6701da177e4SLinus Torvalds (cmdstatp->sense_hdr.sense_key == NO_SENSE || 6711da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) && 6721da177e4SLinus Torvalds (!cmdstatp->remainder_valid || 6731da177e4SLinus Torvalds cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */ 6741da177e4SLinus Torvalds STp->dirty = 0; 6751da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = 0; 6761da177e4SLinus Torvalds if (STps->drv_block >= 0) 6771da177e4SLinus Torvalds STps->drv_block += blks; 6781da177e4SLinus Torvalds result = (-ENOSPC); 6791da177e4SLinus Torvalds } else { 6801da177e4SLinus Torvalds printk(KERN_ERR "%s: Error on flush.\n", 6811da177e4SLinus Torvalds tape_name(STp)); 6821da177e4SLinus Torvalds STps->drv_block = (-1); 6831da177e4SLinus Torvalds result = (-EIO); 6841da177e4SLinus Torvalds } 6851da177e4SLinus Torvalds } else { 6861da177e4SLinus Torvalds if (STps->drv_block >= 0) 6871da177e4SLinus Torvalds STps->drv_block += blks; 6881da177e4SLinus Torvalds STp->dirty = 0; 6891da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = 0; 6901da177e4SLinus Torvalds } 6911da177e4SLinus Torvalds scsi_release_request(SRpnt); 6921da177e4SLinus Torvalds SRpnt = NULL; 6931da177e4SLinus Torvalds } 6941da177e4SLinus Torvalds return result; 6951da177e4SLinus Torvalds } 6961da177e4SLinus Torvalds 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds /* Flush the tape buffer. The tape will be positioned correctly unless 6991da177e4SLinus Torvalds seek_next is true. */ 7001da177e4SLinus Torvalds static int flush_buffer(struct scsi_tape *STp, int seek_next) 7011da177e4SLinus Torvalds { 7021da177e4SLinus Torvalds int backspace, result; 7031da177e4SLinus Torvalds struct st_buffer *STbuffer; 7041da177e4SLinus Torvalds struct st_partstat *STps; 7051da177e4SLinus Torvalds 7061da177e4SLinus Torvalds STbuffer = STp->buffer; 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds /* 7091da177e4SLinus Torvalds * If there was a bus reset, block further access 7101da177e4SLinus Torvalds * to this device. 7111da177e4SLinus Torvalds */ 7121da177e4SLinus Torvalds if (STp->pos_unknown) 7131da177e4SLinus Torvalds return (-EIO); 7141da177e4SLinus Torvalds 7151da177e4SLinus Torvalds if (STp->ready != ST_READY) 7161da177e4SLinus Torvalds return 0; 7171da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 7181da177e4SLinus Torvalds if (STps->rw == ST_WRITING) /* Writing */ 7191da177e4SLinus Torvalds return flush_write_buffer(STp); 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds if (STp->block_size == 0) 7221da177e4SLinus Torvalds return 0; 7231da177e4SLinus Torvalds 7241da177e4SLinus Torvalds backspace = ((STp->buffer)->buffer_bytes + 7251da177e4SLinus Torvalds (STp->buffer)->read_pointer) / STp->block_size - 7261da177e4SLinus Torvalds ((STp->buffer)->read_pointer + STp->block_size - 1) / 7271da177e4SLinus Torvalds STp->block_size; 7281da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = 0; 7291da177e4SLinus Torvalds (STp->buffer)->read_pointer = 0; 7301da177e4SLinus Torvalds result = 0; 7311da177e4SLinus Torvalds if (!seek_next) { 7321da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) { 7331da177e4SLinus Torvalds result = cross_eof(STp, 0); /* Back over the EOF hit */ 7341da177e4SLinus Torvalds if (!result) 7351da177e4SLinus Torvalds STps->eof = ST_NOEOF; 7361da177e4SLinus Torvalds else { 7371da177e4SLinus Torvalds if (STps->drv_file >= 0) 7381da177e4SLinus Torvalds STps->drv_file++; 7391da177e4SLinus Torvalds STps->drv_block = 0; 7401da177e4SLinus Torvalds } 7411da177e4SLinus Torvalds } 7421da177e4SLinus Torvalds if (!result && backspace > 0) 7431da177e4SLinus Torvalds result = st_int_ioctl(STp, MTBSR, backspace); 7441da177e4SLinus Torvalds } else if (STps->eof == ST_FM_HIT) { 7451da177e4SLinus Torvalds if (STps->drv_file >= 0) 7461da177e4SLinus Torvalds STps->drv_file++; 7471da177e4SLinus Torvalds STps->drv_block = 0; 7481da177e4SLinus Torvalds STps->eof = ST_NOEOF; 7491da177e4SLinus Torvalds } 7501da177e4SLinus Torvalds return result; 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds } 7531da177e4SLinus Torvalds 7541da177e4SLinus Torvalds /* Set the mode parameters */ 7551da177e4SLinus Torvalds static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm) 7561da177e4SLinus Torvalds { 7571da177e4SLinus Torvalds int set_it = 0; 7581da177e4SLinus Torvalds unsigned long arg; 7591da177e4SLinus Torvalds char *name = tape_name(STp); 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds if (!STp->density_changed && 7621da177e4SLinus Torvalds STm->default_density >= 0 && 7631da177e4SLinus Torvalds STm->default_density != STp->density) { 7641da177e4SLinus Torvalds arg = STm->default_density; 7651da177e4SLinus Torvalds set_it = 1; 7661da177e4SLinus Torvalds } else 7671da177e4SLinus Torvalds arg = STp->density; 7681da177e4SLinus Torvalds arg <<= MT_ST_DENSITY_SHIFT; 7691da177e4SLinus Torvalds if (!STp->blksize_changed && 7701da177e4SLinus Torvalds STm->default_blksize >= 0 && 7711da177e4SLinus Torvalds STm->default_blksize != STp->block_size) { 7721da177e4SLinus Torvalds arg |= STm->default_blksize; 7731da177e4SLinus Torvalds set_it = 1; 7741da177e4SLinus Torvalds } else 7751da177e4SLinus Torvalds arg |= STp->block_size; 7761da177e4SLinus Torvalds if (set_it && 7771da177e4SLinus Torvalds st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) { 7781da177e4SLinus Torvalds printk(KERN_WARNING 7791da177e4SLinus Torvalds "%s: Can't set default block size to %d bytes and density %x.\n", 7801da177e4SLinus Torvalds name, STm->default_blksize, STm->default_density); 7811da177e4SLinus Torvalds if (modes_defined) 7821da177e4SLinus Torvalds return (-EINVAL); 7831da177e4SLinus Torvalds } 7841da177e4SLinus Torvalds return 0; 7851da177e4SLinus Torvalds } 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds 7881da177e4SLinus Torvalds /* Lock or unlock the drive door. Don't use when scsi_request allocated. */ 7891da177e4SLinus Torvalds static int do_door_lock(struct scsi_tape * STp, int do_lock) 7901da177e4SLinus Torvalds { 7911da177e4SLinus Torvalds int retval, cmd; 7921da177e4SLinus Torvalds DEB(char *name = tape_name(STp);) 7931da177e4SLinus Torvalds 7941da177e4SLinus Torvalds 7951da177e4SLinus Torvalds cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK; 7961da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name, 7971da177e4SLinus Torvalds do_lock ? "L" : "Unl")); 7981da177e4SLinus Torvalds retval = scsi_ioctl(STp->device, cmd, NULL); 7991da177e4SLinus Torvalds if (!retval) { 8001da177e4SLinus Torvalds STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED; 8011da177e4SLinus Torvalds } 8021da177e4SLinus Torvalds else { 8031da177e4SLinus Torvalds STp->door_locked = ST_LOCK_FAILS; 8041da177e4SLinus Torvalds } 8051da177e4SLinus Torvalds return retval; 8061da177e4SLinus Torvalds } 8071da177e4SLinus Torvalds 8081da177e4SLinus Torvalds 8091da177e4SLinus Torvalds /* Set the internal state after reset */ 8101da177e4SLinus Torvalds static void reset_state(struct scsi_tape *STp) 8111da177e4SLinus Torvalds { 8121da177e4SLinus Torvalds int i; 8131da177e4SLinus Torvalds struct st_partstat *STps; 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds STp->pos_unknown = 0; 8161da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 8171da177e4SLinus Torvalds STps = &(STp->ps[i]); 8181da177e4SLinus Torvalds STps->rw = ST_IDLE; 8191da177e4SLinus Torvalds STps->eof = ST_NOEOF; 8201da177e4SLinus Torvalds STps->at_sm = 0; 8211da177e4SLinus Torvalds STps->last_block_valid = 0; 8221da177e4SLinus Torvalds STps->drv_block = -1; 8231da177e4SLinus Torvalds STps->drv_file = -1; 8241da177e4SLinus Torvalds } 8251da177e4SLinus Torvalds if (STp->can_partitions) { 8261da177e4SLinus Torvalds STp->partition = find_partition(STp); 8271da177e4SLinus Torvalds if (STp->partition < 0) 8281da177e4SLinus Torvalds STp->partition = 0; 8291da177e4SLinus Torvalds STp->new_partition = STp->partition; 8301da177e4SLinus Torvalds } 8311da177e4SLinus Torvalds } 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds /* Test if the drive is ready. Returns either one of the codes below or a negative system 8341da177e4SLinus Torvalds error code. */ 8351da177e4SLinus Torvalds #define CHKRES_READY 0 8361da177e4SLinus Torvalds #define CHKRES_NEW_SESSION 1 8371da177e4SLinus Torvalds #define CHKRES_NOT_READY 2 8381da177e4SLinus Torvalds #define CHKRES_NO_TAPE 3 8391da177e4SLinus Torvalds 8401da177e4SLinus Torvalds #define MAX_ATTENTIONS 10 8411da177e4SLinus Torvalds 8421da177e4SLinus Torvalds static int test_ready(struct scsi_tape *STp, int do_wait) 8431da177e4SLinus Torvalds { 8441da177e4SLinus Torvalds int attentions, waits, max_wait, scode; 8451da177e4SLinus Torvalds int retval = CHKRES_READY, new_session = 0; 8461da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 8471da177e4SLinus Torvalds struct scsi_request *SRpnt = NULL; 8481da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 8491da177e4SLinus Torvalds 8501da177e4SLinus Torvalds max_wait = do_wait ? ST_BLOCK_SECONDS : 0; 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds for (attentions=waits=0; ; ) { 8531da177e4SLinus Torvalds memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 8541da177e4SLinus Torvalds cmd[0] = TEST_UNIT_READY; 8551da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, 8561da177e4SLinus Torvalds STp->long_timeout, MAX_READY_RETRIES, 1); 8571da177e4SLinus Torvalds 8581da177e4SLinus Torvalds if (!SRpnt) { 8591da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 8601da177e4SLinus Torvalds break; 8611da177e4SLinus Torvalds } 8621da177e4SLinus Torvalds 8631da177e4SLinus Torvalds if (cmdstatp->have_sense) { 8641da177e4SLinus Torvalds 8651da177e4SLinus Torvalds scode = cmdstatp->sense_hdr.sense_key; 8661da177e4SLinus Torvalds 8671da177e4SLinus Torvalds if (scode == UNIT_ATTENTION) { /* New media? */ 8681da177e4SLinus Torvalds new_session = 1; 8691da177e4SLinus Torvalds if (attentions < MAX_ATTENTIONS) { 8701da177e4SLinus Torvalds attentions++; 8711da177e4SLinus Torvalds continue; 8721da177e4SLinus Torvalds } 8731da177e4SLinus Torvalds else { 8741da177e4SLinus Torvalds retval = (-EIO); 8751da177e4SLinus Torvalds break; 8761da177e4SLinus Torvalds } 8771da177e4SLinus Torvalds } 8781da177e4SLinus Torvalds 8791da177e4SLinus Torvalds if (scode == NOT_READY) { 8801da177e4SLinus Torvalds if (waits < max_wait) { 8811da177e4SLinus Torvalds if (msleep_interruptible(1000)) { 8821da177e4SLinus Torvalds retval = (-EINTR); 8831da177e4SLinus Torvalds break; 8841da177e4SLinus Torvalds } 8851da177e4SLinus Torvalds waits++; 8861da177e4SLinus Torvalds continue; 8871da177e4SLinus Torvalds } 8881da177e4SLinus Torvalds else { 8891da177e4SLinus Torvalds if ((STp->device)->scsi_level >= SCSI_2 && 8901da177e4SLinus Torvalds cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */ 8911da177e4SLinus Torvalds retval = CHKRES_NO_TAPE; 8921da177e4SLinus Torvalds else 8931da177e4SLinus Torvalds retval = CHKRES_NOT_READY; 8941da177e4SLinus Torvalds break; 8951da177e4SLinus Torvalds } 8961da177e4SLinus Torvalds } 8971da177e4SLinus Torvalds } 8981da177e4SLinus Torvalds 8991da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 9001da177e4SLinus Torvalds if (!retval) 9011da177e4SLinus Torvalds retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY; 9021da177e4SLinus Torvalds break; 9031da177e4SLinus Torvalds } 9041da177e4SLinus Torvalds 9051da177e4SLinus Torvalds if (SRpnt != NULL) 9061da177e4SLinus Torvalds scsi_release_request(SRpnt); 9071da177e4SLinus Torvalds return retval; 9081da177e4SLinus Torvalds } 9091da177e4SLinus Torvalds 9101da177e4SLinus Torvalds 9111da177e4SLinus Torvalds /* See if the drive is ready and gather information about the tape. Return values: 9121da177e4SLinus Torvalds < 0 negative error code from errno.h 9131da177e4SLinus Torvalds 0 drive ready 9141da177e4SLinus Torvalds 1 drive not ready (possibly no tape) 9151da177e4SLinus Torvalds */ 9161da177e4SLinus Torvalds static int check_tape(struct scsi_tape *STp, struct file *filp) 9171da177e4SLinus Torvalds { 9181da177e4SLinus Torvalds int i, retval, new_session = 0, do_wait; 9191da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning; 9201da177e4SLinus Torvalds unsigned short st_flags = filp->f_flags; 9211da177e4SLinus Torvalds struct scsi_request *SRpnt = NULL; 9221da177e4SLinus Torvalds struct st_modedef *STm; 9231da177e4SLinus Torvalds struct st_partstat *STps; 9241da177e4SLinus Torvalds char *name = tape_name(STp); 9251da177e4SLinus Torvalds struct inode *inode = filp->f_dentry->d_inode; 9261da177e4SLinus Torvalds int mode = TAPE_MODE(inode); 9271da177e4SLinus Torvalds 9281da177e4SLinus Torvalds STp->ready = ST_READY; 9291da177e4SLinus Torvalds 9301da177e4SLinus Torvalds if (mode != STp->current_mode) { 9311da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n", 9321da177e4SLinus Torvalds name, STp->current_mode, mode)); 9331da177e4SLinus Torvalds new_session = 1; 9341da177e4SLinus Torvalds STp->current_mode = mode; 9351da177e4SLinus Torvalds } 9361da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 9371da177e4SLinus Torvalds 9381da177e4SLinus Torvalds saved_cleaning = STp->cleaning_req; 9391da177e4SLinus Torvalds STp->cleaning_req = 0; 9401da177e4SLinus Torvalds 9411da177e4SLinus Torvalds do_wait = ((filp->f_flags & O_NONBLOCK) == 0); 9421da177e4SLinus Torvalds retval = test_ready(STp, do_wait); 9431da177e4SLinus Torvalds 9441da177e4SLinus Torvalds if (retval < 0) 9451da177e4SLinus Torvalds goto err_out; 9461da177e4SLinus Torvalds 9471da177e4SLinus Torvalds if (retval == CHKRES_NEW_SESSION) { 9481da177e4SLinus Torvalds STp->pos_unknown = 0; 9491da177e4SLinus Torvalds STp->partition = STp->new_partition = 0; 9501da177e4SLinus Torvalds if (STp->can_partitions) 9511da177e4SLinus Torvalds STp->nbr_partitions = 1; /* This guess will be updated later 9521da177e4SLinus Torvalds if necessary */ 9531da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 9541da177e4SLinus Torvalds STps = &(STp->ps[i]); 9551da177e4SLinus Torvalds STps->rw = ST_IDLE; 9561da177e4SLinus Torvalds STps->eof = ST_NOEOF; 9571da177e4SLinus Torvalds STps->at_sm = 0; 9581da177e4SLinus Torvalds STps->last_block_valid = 0; 9591da177e4SLinus Torvalds STps->drv_block = 0; 9601da177e4SLinus Torvalds STps->drv_file = 0; 9611da177e4SLinus Torvalds } 9621da177e4SLinus Torvalds new_session = 1; 9631da177e4SLinus Torvalds } 9641da177e4SLinus Torvalds else { 9651da177e4SLinus Torvalds STp->cleaning_req |= saved_cleaning; 9661da177e4SLinus Torvalds 9671da177e4SLinus Torvalds if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) { 9681da177e4SLinus Torvalds if (retval == CHKRES_NO_TAPE) 9691da177e4SLinus Torvalds STp->ready = ST_NO_TAPE; 9701da177e4SLinus Torvalds else 9711da177e4SLinus Torvalds STp->ready = ST_NOT_READY; 9721da177e4SLinus Torvalds 9731da177e4SLinus Torvalds STp->density = 0; /* Clear the erroneous "residue" */ 9741da177e4SLinus Torvalds STp->write_prot = 0; 9751da177e4SLinus Torvalds STp->block_size = 0; 9761da177e4SLinus Torvalds STp->ps[0].drv_file = STp->ps[0].drv_block = (-1); 9771da177e4SLinus Torvalds STp->partition = STp->new_partition = 0; 9781da177e4SLinus Torvalds STp->door_locked = ST_UNLOCKED; 9791da177e4SLinus Torvalds return CHKRES_NOT_READY; 9801da177e4SLinus Torvalds } 9811da177e4SLinus Torvalds } 9821da177e4SLinus Torvalds 9831da177e4SLinus Torvalds if (STp->omit_blklims) 9841da177e4SLinus Torvalds STp->min_block = STp->max_block = (-1); 9851da177e4SLinus Torvalds else { 9861da177e4SLinus Torvalds memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 9871da177e4SLinus Torvalds cmd[0] = READ_BLOCK_LIMITS; 9881da177e4SLinus Torvalds 9891da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE, 9901da177e4SLinus Torvalds STp->device->timeout, MAX_READY_RETRIES, 1); 9911da177e4SLinus Torvalds if (!SRpnt) { 9921da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 9931da177e4SLinus Torvalds goto err_out; 9941da177e4SLinus Torvalds } 9951da177e4SLinus Torvalds 9961da177e4SLinus Torvalds if (!SRpnt->sr_result && !STp->buffer->cmdstat.have_sense) { 9971da177e4SLinus Torvalds STp->max_block = ((STp->buffer)->b_data[1] << 16) | 9981da177e4SLinus Torvalds ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3]; 9991da177e4SLinus Torvalds STp->min_block = ((STp->buffer)->b_data[4] << 8) | 10001da177e4SLinus Torvalds (STp->buffer)->b_data[5]; 10011da177e4SLinus Torvalds if ( DEB( debugging || ) !STp->inited) 10021da177e4SLinus Torvalds printk(KERN_WARNING 10031da177e4SLinus Torvalds "%s: Block limits %d - %d bytes.\n", name, 10041da177e4SLinus Torvalds STp->min_block, STp->max_block); 10051da177e4SLinus Torvalds } else { 10061da177e4SLinus Torvalds STp->min_block = STp->max_block = (-1); 10071da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n", 10081da177e4SLinus Torvalds name)); 10091da177e4SLinus Torvalds } 10101da177e4SLinus Torvalds } 10111da177e4SLinus Torvalds 10121da177e4SLinus Torvalds memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 10131da177e4SLinus Torvalds cmd[0] = MODE_SENSE; 10141da177e4SLinus Torvalds cmd[4] = 12; 10151da177e4SLinus Torvalds 10161da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE, 10171da177e4SLinus Torvalds STp->device->timeout, MAX_READY_RETRIES, 1); 10181da177e4SLinus Torvalds if (!SRpnt) { 10191da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 10201da177e4SLinus Torvalds goto err_out; 10211da177e4SLinus Torvalds } 10221da177e4SLinus Torvalds 10231da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0) { 10241da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name)); 10251da177e4SLinus Torvalds STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */ 10261da177e4SLinus Torvalds (STp->buffer)->syscall_result = 0; /* Prevent error propagation */ 10271da177e4SLinus Torvalds STp->drv_write_prot = 0; 10281da177e4SLinus Torvalds } else { 10291da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 10301da177e4SLinus Torvalds "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n", 10311da177e4SLinus Torvalds name, 10321da177e4SLinus Torvalds (STp->buffer)->b_data[0], (STp->buffer)->b_data[1], 10331da177e4SLinus Torvalds (STp->buffer)->b_data[2], (STp->buffer)->b_data[3])); 10341da177e4SLinus Torvalds 10351da177e4SLinus Torvalds if ((STp->buffer)->b_data[3] >= 8) { 10361da177e4SLinus Torvalds STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7; 10371da177e4SLinus Torvalds STp->density = (STp->buffer)->b_data[4]; 10381da177e4SLinus Torvalds STp->block_size = (STp->buffer)->b_data[9] * 65536 + 10391da177e4SLinus Torvalds (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11]; 10401da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 10411da177e4SLinus Torvalds "%s: Density %x, tape length: %x, drv buffer: %d\n", 10421da177e4SLinus Torvalds name, STp->density, (STp->buffer)->b_data[5] * 65536 + 10431da177e4SLinus Torvalds (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7], 10441da177e4SLinus Torvalds STp->drv_buffer)); 10451da177e4SLinus Torvalds } 10461da177e4SLinus Torvalds STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0; 10471da177e4SLinus Torvalds } 10481da177e4SLinus Torvalds scsi_release_request(SRpnt); 10491da177e4SLinus Torvalds SRpnt = NULL; 10501da177e4SLinus Torvalds STp->inited = 1; 10511da177e4SLinus Torvalds 10521da177e4SLinus Torvalds if (STp->block_size > 0) 10531da177e4SLinus Torvalds (STp->buffer)->buffer_blocks = 10541da177e4SLinus Torvalds (STp->buffer)->buffer_size / STp->block_size; 10551da177e4SLinus Torvalds else 10561da177e4SLinus Torvalds (STp->buffer)->buffer_blocks = 1; 10571da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0; 10581da177e4SLinus Torvalds 10591da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 10601da177e4SLinus Torvalds "%s: Block size: %d, buffer size: %d (%d blocks).\n", name, 10611da177e4SLinus Torvalds STp->block_size, (STp->buffer)->buffer_size, 10621da177e4SLinus Torvalds (STp->buffer)->buffer_blocks)); 10631da177e4SLinus Torvalds 10641da177e4SLinus Torvalds if (STp->drv_write_prot) { 10651da177e4SLinus Torvalds STp->write_prot = 1; 10661da177e4SLinus Torvalds 10671da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name)); 10681da177e4SLinus Torvalds 10691da177e4SLinus Torvalds if (do_wait && 10701da177e4SLinus Torvalds ((st_flags & O_ACCMODE) == O_WRONLY || 10711da177e4SLinus Torvalds (st_flags & O_ACCMODE) == O_RDWR)) { 10721da177e4SLinus Torvalds retval = (-EROFS); 10731da177e4SLinus Torvalds goto err_out; 10741da177e4SLinus Torvalds } 10751da177e4SLinus Torvalds } 10761da177e4SLinus Torvalds 10771da177e4SLinus Torvalds if (STp->can_partitions && STp->nbr_partitions < 1) { 10781da177e4SLinus Torvalds /* This code is reached when the device is opened for the first time 10791da177e4SLinus Torvalds after the driver has been initialized with tape in the drive and the 10801da177e4SLinus Torvalds partition support has been enabled. */ 10811da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 10821da177e4SLinus Torvalds "%s: Updating partition number in status.\n", name)); 10831da177e4SLinus Torvalds if ((STp->partition = find_partition(STp)) < 0) { 10841da177e4SLinus Torvalds retval = STp->partition; 10851da177e4SLinus Torvalds goto err_out; 10861da177e4SLinus Torvalds } 10871da177e4SLinus Torvalds STp->new_partition = STp->partition; 10881da177e4SLinus Torvalds STp->nbr_partitions = 1; /* This guess will be updated when necessary */ 10891da177e4SLinus Torvalds } 10901da177e4SLinus Torvalds 10911da177e4SLinus Torvalds if (new_session) { /* Change the drive parameters for the new mode */ 10921da177e4SLinus Torvalds STp->density_changed = STp->blksize_changed = 0; 10931da177e4SLinus Torvalds STp->compression_changed = 0; 10941da177e4SLinus Torvalds if (!(STm->defaults_for_writes) && 10951da177e4SLinus Torvalds (retval = set_mode_densblk(STp, STm)) < 0) 10961da177e4SLinus Torvalds goto err_out; 10971da177e4SLinus Torvalds 10981da177e4SLinus Torvalds if (STp->default_drvbuffer != 0xff) { 10991da177e4SLinus Torvalds if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer)) 11001da177e4SLinus Torvalds printk(KERN_WARNING 11011da177e4SLinus Torvalds "%s: Can't set default drive buffering to %d.\n", 11021da177e4SLinus Torvalds name, STp->default_drvbuffer); 11031da177e4SLinus Torvalds } 11041da177e4SLinus Torvalds } 11051da177e4SLinus Torvalds 11061da177e4SLinus Torvalds return CHKRES_READY; 11071da177e4SLinus Torvalds 11081da177e4SLinus Torvalds err_out: 11091da177e4SLinus Torvalds return retval; 11101da177e4SLinus Torvalds } 11111da177e4SLinus Torvalds 11121da177e4SLinus Torvalds 11131da177e4SLinus Torvalds /* Open the device. Needs to be called with BKL only because of incrementing the SCSI host 11141da177e4SLinus Torvalds module count. */ 11151da177e4SLinus Torvalds static int st_open(struct inode *inode, struct file *filp) 11161da177e4SLinus Torvalds { 11171da177e4SLinus Torvalds int i, retval = (-EIO); 11181da177e4SLinus Torvalds struct scsi_tape *STp; 11191da177e4SLinus Torvalds struct st_partstat *STps; 11201da177e4SLinus Torvalds int dev = TAPE_NR(inode); 11211da177e4SLinus Torvalds char *name; 11221da177e4SLinus Torvalds 11231da177e4SLinus Torvalds /* 11241da177e4SLinus Torvalds * We really want to do nonseekable_open(inode, filp); here, but some 11251da177e4SLinus Torvalds * versions of tar incorrectly call lseek on tapes and bail out if that 11261da177e4SLinus Torvalds * fails. So we disallow pread() and pwrite(), but permit lseeks. 11271da177e4SLinus Torvalds */ 11281da177e4SLinus Torvalds filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE); 11291da177e4SLinus Torvalds 1130f03a5670SKai Makisara if (!(STp = scsi_tape_get(dev))) 1131f03a5670SKai Makisara return -ENXIO; 1132f03a5670SKai Makisara 11331da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 11341da177e4SLinus Torvalds filp->private_data = STp; 11351da177e4SLinus Torvalds name = tape_name(STp); 11361da177e4SLinus Torvalds 11371da177e4SLinus Torvalds if (STp->in_use) { 11381da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 1139f03a5670SKai Makisara scsi_tape_put(STp); 11401da177e4SLinus Torvalds DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); ) 11411da177e4SLinus Torvalds return (-EBUSY); 11421da177e4SLinus Torvalds } 11431da177e4SLinus Torvalds 11441da177e4SLinus Torvalds STp->in_use = 1; 11451da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 11461da177e4SLinus Torvalds STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0; 11471da177e4SLinus Torvalds 11481da177e4SLinus Torvalds if (!scsi_block_when_processing_errors(STp->device)) { 11491da177e4SLinus Torvalds retval = (-ENXIO); 11501da177e4SLinus Torvalds goto err_out; 11511da177e4SLinus Torvalds } 11521da177e4SLinus Torvalds 11531da177e4SLinus Torvalds /* See that we have at least a one page buffer available */ 11541da177e4SLinus Torvalds if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) { 11551da177e4SLinus Torvalds printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n", 11561da177e4SLinus Torvalds name); 11571da177e4SLinus Torvalds retval = (-EOVERFLOW); 11581da177e4SLinus Torvalds goto err_out; 11591da177e4SLinus Torvalds } 11601da177e4SLinus Torvalds 11611da177e4SLinus Torvalds (STp->buffer)->writing = 0; 11621da177e4SLinus Torvalds (STp->buffer)->syscall_result = 0; 11631da177e4SLinus Torvalds 11641da177e4SLinus Torvalds STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY); 11651da177e4SLinus Torvalds 11661da177e4SLinus Torvalds STp->dirty = 0; 11671da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 11681da177e4SLinus Torvalds STps = &(STp->ps[i]); 11691da177e4SLinus Torvalds STps->rw = ST_IDLE; 11701da177e4SLinus Torvalds } 11711da177e4SLinus Torvalds STp->recover_count = 0; 11721da177e4SLinus Torvalds DEB( STp->nbr_waits = STp->nbr_finished = 0; 11731da177e4SLinus Torvalds STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = STp->nbr_combinable = 0; ) 11741da177e4SLinus Torvalds 11751da177e4SLinus Torvalds retval = check_tape(STp, filp); 11761da177e4SLinus Torvalds if (retval < 0) 11771da177e4SLinus Torvalds goto err_out; 11781da177e4SLinus Torvalds if ((filp->f_flags & O_NONBLOCK) == 0 && 11791da177e4SLinus Torvalds retval != CHKRES_READY) { 11801da177e4SLinus Torvalds retval = (-EIO); 11811da177e4SLinus Torvalds goto err_out; 11821da177e4SLinus Torvalds } 11831da177e4SLinus Torvalds return 0; 11841da177e4SLinus Torvalds 11851da177e4SLinus Torvalds err_out: 11861da177e4SLinus Torvalds normalize_buffer(STp->buffer); 11871da177e4SLinus Torvalds STp->in_use = 0; 1188f03a5670SKai Makisara scsi_tape_put(STp); 11891da177e4SLinus Torvalds return retval; 11901da177e4SLinus Torvalds 11911da177e4SLinus Torvalds } 11921da177e4SLinus Torvalds 11931da177e4SLinus Torvalds 11941da177e4SLinus Torvalds /* Flush the tape buffer before close */ 11951da177e4SLinus Torvalds static int st_flush(struct file *filp) 11961da177e4SLinus Torvalds { 11971da177e4SLinus Torvalds int result = 0, result2; 11981da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 11991da177e4SLinus Torvalds struct scsi_request *SRpnt; 12001da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 12011da177e4SLinus Torvalds struct st_modedef *STm = &(STp->modes[STp->current_mode]); 12021da177e4SLinus Torvalds struct st_partstat *STps = &(STp->ps[STp->partition]); 12031da177e4SLinus Torvalds char *name = tape_name(STp); 12041da177e4SLinus Torvalds 12051da177e4SLinus Torvalds if (file_count(filp) > 1) 12061da177e4SLinus Torvalds return 0; 12071da177e4SLinus Torvalds 12081da177e4SLinus Torvalds if (STps->rw == ST_WRITING && !STp->pos_unknown) { 12091da177e4SLinus Torvalds result = flush_write_buffer(STp); 12101da177e4SLinus Torvalds if (result != 0 && result != (-ENOSPC)) 12111da177e4SLinus Torvalds goto out; 12121da177e4SLinus Torvalds } 12131da177e4SLinus Torvalds 12141da177e4SLinus Torvalds if (STp->can_partitions && 12151da177e4SLinus Torvalds (result2 = switch_partition(STp)) < 0) { 12161da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 12171da177e4SLinus Torvalds "%s: switch_partition at close failed.\n", name)); 12181da177e4SLinus Torvalds if (result == 0) 12191da177e4SLinus Torvalds result = result2; 12201da177e4SLinus Torvalds goto out; 12211da177e4SLinus Torvalds } 12221da177e4SLinus Torvalds 12231da177e4SLinus Torvalds DEBC( if (STp->nbr_requests) 12241da177e4SLinus Torvalds printk(KERN_WARNING "%s: Number of r/w requests %d, dio used in %d, pages %d (%d).\n", 12251da177e4SLinus Torvalds name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages, STp->nbr_combinable)); 12261da177e4SLinus Torvalds 12271da177e4SLinus Torvalds if (STps->rw == ST_WRITING && !STp->pos_unknown) { 12281da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 12291da177e4SLinus Torvalds 12301da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n", 12311da177e4SLinus Torvalds name, STp->nbr_waits, STp->nbr_finished); 12321da177e4SLinus Torvalds ) 12331da177e4SLinus Torvalds 12341da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 12351da177e4SLinus Torvalds cmd[0] = WRITE_FILEMARKS; 12361da177e4SLinus Torvalds cmd[4] = 1 + STp->two_fm; 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE, 12391da177e4SLinus Torvalds STp->device->timeout, MAX_WRITE_RETRIES, 1); 12401da177e4SLinus Torvalds if (!SRpnt) { 12411da177e4SLinus Torvalds result = (STp->buffer)->syscall_result; 12421da177e4SLinus Torvalds goto out; 12431da177e4SLinus Torvalds } 12441da177e4SLinus Torvalds 12451da177e4SLinus Torvalds if (STp->buffer->syscall_result == 0 || 12461da177e4SLinus Torvalds (cmdstatp->have_sense && !cmdstatp->deferred && 12471da177e4SLinus Torvalds (cmdstatp->flags & SENSE_EOM) && 12481da177e4SLinus Torvalds (cmdstatp->sense_hdr.sense_key == NO_SENSE || 12491da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) && 12501da177e4SLinus Torvalds (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) { 12511da177e4SLinus Torvalds /* Write successful at EOM */ 12521da177e4SLinus Torvalds scsi_release_request(SRpnt); 12531da177e4SLinus Torvalds SRpnt = NULL; 12541da177e4SLinus Torvalds if (STps->drv_file >= 0) 12551da177e4SLinus Torvalds STps->drv_file++; 12561da177e4SLinus Torvalds STps->drv_block = 0; 12571da177e4SLinus Torvalds if (STp->two_fm) 12581da177e4SLinus Torvalds cross_eof(STp, 0); 12591da177e4SLinus Torvalds STps->eof = ST_FM; 12601da177e4SLinus Torvalds } 12611da177e4SLinus Torvalds else { /* Write error */ 12621da177e4SLinus Torvalds scsi_release_request(SRpnt); 12631da177e4SLinus Torvalds SRpnt = NULL; 12641da177e4SLinus Torvalds printk(KERN_ERR "%s: Error on write filemark.\n", name); 12651da177e4SLinus Torvalds if (result == 0) 12661da177e4SLinus Torvalds result = (-EIO); 12671da177e4SLinus Torvalds } 12681da177e4SLinus Torvalds 12691da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n", 12701da177e4SLinus Torvalds name, cmd[4])); 12711da177e4SLinus Torvalds } else if (!STp->rew_at_close) { 12721da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 12731da177e4SLinus Torvalds if (!STm->sysv || STps->rw != ST_READING) { 12741da177e4SLinus Torvalds if (STp->can_bsr) 12751da177e4SLinus Torvalds result = flush_buffer(STp, 0); 12761da177e4SLinus Torvalds else if (STps->eof == ST_FM_HIT) { 12771da177e4SLinus Torvalds result = cross_eof(STp, 0); 12781da177e4SLinus Torvalds if (result) { 12791da177e4SLinus Torvalds if (STps->drv_file >= 0) 12801da177e4SLinus Torvalds STps->drv_file++; 12811da177e4SLinus Torvalds STps->drv_block = 0; 12821da177e4SLinus Torvalds STps->eof = ST_FM; 12831da177e4SLinus Torvalds } else 12841da177e4SLinus Torvalds STps->eof = ST_NOEOF; 12851da177e4SLinus Torvalds } 12861da177e4SLinus Torvalds } else if ((STps->eof == ST_NOEOF && 12871da177e4SLinus Torvalds !(result = cross_eof(STp, 1))) || 12881da177e4SLinus Torvalds STps->eof == ST_FM_HIT) { 12891da177e4SLinus Torvalds if (STps->drv_file >= 0) 12901da177e4SLinus Torvalds STps->drv_file++; 12911da177e4SLinus Torvalds STps->drv_block = 0; 12921da177e4SLinus Torvalds STps->eof = ST_FM; 12931da177e4SLinus Torvalds } 12941da177e4SLinus Torvalds } 12951da177e4SLinus Torvalds 12961da177e4SLinus Torvalds out: 12971da177e4SLinus Torvalds if (STp->rew_at_close) { 12981da177e4SLinus Torvalds result2 = st_int_ioctl(STp, MTREW, 1); 12991da177e4SLinus Torvalds if (result == 0) 13001da177e4SLinus Torvalds result = result2; 13011da177e4SLinus Torvalds } 13021da177e4SLinus Torvalds return result; 13031da177e4SLinus Torvalds } 13041da177e4SLinus Torvalds 13051da177e4SLinus Torvalds 13061da177e4SLinus Torvalds /* Close the device and release it. BKL is not needed: this is the only thread 13071da177e4SLinus Torvalds accessing this tape. */ 13081da177e4SLinus Torvalds static int st_release(struct inode *inode, struct file *filp) 13091da177e4SLinus Torvalds { 13101da177e4SLinus Torvalds int result = 0; 13111da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 13121da177e4SLinus Torvalds 13131da177e4SLinus Torvalds if (STp->door_locked == ST_LOCKED_AUTO) 13141da177e4SLinus Torvalds do_door_lock(STp, 0); 13151da177e4SLinus Torvalds 13161da177e4SLinus Torvalds normalize_buffer(STp->buffer); 13171da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 13181da177e4SLinus Torvalds STp->in_use = 0; 13191da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 1320f03a5670SKai Makisara scsi_tape_put(STp); 13211da177e4SLinus Torvalds 13221da177e4SLinus Torvalds return result; 13231da177e4SLinus Torvalds } 13241da177e4SLinus Torvalds 13251da177e4SLinus Torvalds /* The checks common to both reading and writing */ 13261da177e4SLinus Torvalds static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count) 13271da177e4SLinus Torvalds { 13281da177e4SLinus Torvalds ssize_t retval = 0; 13291da177e4SLinus Torvalds 13301da177e4SLinus Torvalds /* 13311da177e4SLinus Torvalds * If we are in the middle of error recovery, don't let anyone 13321da177e4SLinus Torvalds * else try and use this device. Also, if error recovery fails, it 13331da177e4SLinus Torvalds * may try and take the device offline, in which case all further 13341da177e4SLinus Torvalds * access to the device is prohibited. 13351da177e4SLinus Torvalds */ 13361da177e4SLinus Torvalds if (!scsi_block_when_processing_errors(STp->device)) { 13371da177e4SLinus Torvalds retval = (-ENXIO); 13381da177e4SLinus Torvalds goto out; 13391da177e4SLinus Torvalds } 13401da177e4SLinus Torvalds 13411da177e4SLinus Torvalds if (STp->ready != ST_READY) { 13421da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 13431da177e4SLinus Torvalds retval = (-ENOMEDIUM); 13441da177e4SLinus Torvalds else 13451da177e4SLinus Torvalds retval = (-EIO); 13461da177e4SLinus Torvalds goto out; 13471da177e4SLinus Torvalds } 13481da177e4SLinus Torvalds 13491da177e4SLinus Torvalds if (! STp->modes[STp->current_mode].defined) { 13501da177e4SLinus Torvalds retval = (-ENXIO); 13511da177e4SLinus Torvalds goto out; 13521da177e4SLinus Torvalds } 13531da177e4SLinus Torvalds 13541da177e4SLinus Torvalds 13551da177e4SLinus Torvalds /* 13561da177e4SLinus Torvalds * If there was a bus reset, block further access 13571da177e4SLinus Torvalds * to this device. 13581da177e4SLinus Torvalds */ 13591da177e4SLinus Torvalds if (STp->pos_unknown) { 13601da177e4SLinus Torvalds retval = (-EIO); 13611da177e4SLinus Torvalds goto out; 13621da177e4SLinus Torvalds } 13631da177e4SLinus Torvalds 13641da177e4SLinus Torvalds if (count == 0) 13651da177e4SLinus Torvalds goto out; 13661da177e4SLinus Torvalds 13671da177e4SLinus Torvalds DEB( 13681da177e4SLinus Torvalds if (!STp->in_use) { 13691da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp)); 13701da177e4SLinus Torvalds retval = (-EIO); 13711da177e4SLinus Torvalds goto out; 13721da177e4SLinus Torvalds } ) /* end DEB */ 13731da177e4SLinus Torvalds 13741da177e4SLinus Torvalds if (STp->can_partitions && 13751da177e4SLinus Torvalds (retval = switch_partition(STp)) < 0) 13761da177e4SLinus Torvalds goto out; 13771da177e4SLinus Torvalds 13781da177e4SLinus Torvalds if (STp->block_size == 0 && STp->max_block > 0 && 13791da177e4SLinus Torvalds (count < STp->min_block || count > STp->max_block)) { 13801da177e4SLinus Torvalds retval = (-EINVAL); 13811da177e4SLinus Torvalds goto out; 13821da177e4SLinus Torvalds } 13831da177e4SLinus Torvalds 13841da177e4SLinus Torvalds if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && 13851da177e4SLinus Torvalds !do_door_lock(STp, 1)) 13861da177e4SLinus Torvalds STp->door_locked = ST_LOCKED_AUTO; 13871da177e4SLinus Torvalds 13881da177e4SLinus Torvalds out: 13891da177e4SLinus Torvalds return retval; 13901da177e4SLinus Torvalds } 13911da177e4SLinus Torvalds 13921da177e4SLinus Torvalds 13931da177e4SLinus Torvalds static int setup_buffering(struct scsi_tape *STp, const char __user *buf, 13941da177e4SLinus Torvalds size_t count, int is_read) 13951da177e4SLinus Torvalds { 13961da177e4SLinus Torvalds int i, bufsize, retval = 0; 13971da177e4SLinus Torvalds struct st_buffer *STbp = STp->buffer; 13981da177e4SLinus Torvalds 13991da177e4SLinus Torvalds if (is_read) 14001da177e4SLinus Torvalds i = STp->try_dio && try_rdio; 14011da177e4SLinus Torvalds else 14021da177e4SLinus Torvalds i = STp->try_dio && try_wdio; 14031da177e4SLinus Torvalds if (i && ((unsigned long)buf & queue_dma_alignment( 14041da177e4SLinus Torvalds STp->device->request_queue)) == 0) { 14051da177e4SLinus Torvalds i = st_map_user_pages(&(STbp->sg[0]), STbp->use_sg, 14061da177e4SLinus Torvalds (unsigned long)buf, count, (is_read ? READ : WRITE), 14071da177e4SLinus Torvalds STp->max_pfn); 14081da177e4SLinus Torvalds if (i > 0) { 14091da177e4SLinus Torvalds STbp->do_dio = i; 14101da177e4SLinus Torvalds STbp->buffer_bytes = 0; /* can be used as transfer counter */ 14111da177e4SLinus Torvalds } 14121da177e4SLinus Torvalds else 14131da177e4SLinus Torvalds STbp->do_dio = 0; /* fall back to buffering with any error */ 14141da177e4SLinus Torvalds STbp->sg_segs = STbp->do_dio; 14151da177e4SLinus Torvalds STbp->frp_sg_current = 0; 14161da177e4SLinus Torvalds DEB( 14171da177e4SLinus Torvalds if (STbp->do_dio) { 14181da177e4SLinus Torvalds STp->nbr_dio++; 14191da177e4SLinus Torvalds STp->nbr_pages += STbp->do_dio; 14201da177e4SLinus Torvalds for (i=1; i < STbp->do_dio; i++) 14211da177e4SLinus Torvalds if (page_to_pfn(STbp->sg[i].page) == page_to_pfn(STbp->sg[i-1].page) + 1) 14221da177e4SLinus Torvalds STp->nbr_combinable++; 14231da177e4SLinus Torvalds } 14241da177e4SLinus Torvalds ) 14251da177e4SLinus Torvalds } else 14261da177e4SLinus Torvalds STbp->do_dio = 0; 14271da177e4SLinus Torvalds DEB( STp->nbr_requests++; ) 14281da177e4SLinus Torvalds 14291da177e4SLinus Torvalds if (!STbp->do_dio) { 14301da177e4SLinus Torvalds if (STp->block_size) 14311da177e4SLinus Torvalds bufsize = STp->block_size > st_fixed_buffer_size ? 14321da177e4SLinus Torvalds STp->block_size : st_fixed_buffer_size; 14331da177e4SLinus Torvalds else 14341da177e4SLinus Torvalds bufsize = count; 14351da177e4SLinus Torvalds if (bufsize > STbp->buffer_size && 14361da177e4SLinus Torvalds !enlarge_buffer(STbp, bufsize, STp->restr_dma)) { 14371da177e4SLinus Torvalds printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n", 14381da177e4SLinus Torvalds tape_name(STp), bufsize); 14391da177e4SLinus Torvalds retval = (-EOVERFLOW); 14401da177e4SLinus Torvalds goto out; 14411da177e4SLinus Torvalds } 14421da177e4SLinus Torvalds if (STp->block_size) 14431da177e4SLinus Torvalds STbp->buffer_blocks = bufsize / STp->block_size; 14441da177e4SLinus Torvalds } 14451da177e4SLinus Torvalds 14461da177e4SLinus Torvalds out: 14471da177e4SLinus Torvalds return retval; 14481da177e4SLinus Torvalds } 14491da177e4SLinus Torvalds 14501da177e4SLinus Torvalds 14511da177e4SLinus Torvalds /* Can be called more than once after each setup_buffer() */ 14521da177e4SLinus Torvalds static void release_buffering(struct scsi_tape *STp) 14531da177e4SLinus Torvalds { 14541da177e4SLinus Torvalds struct st_buffer *STbp; 14551da177e4SLinus Torvalds 14561da177e4SLinus Torvalds STbp = STp->buffer; 14571da177e4SLinus Torvalds if (STbp->do_dio) { 14581da177e4SLinus Torvalds sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, 0); 14591da177e4SLinus Torvalds STbp->do_dio = 0; 14601da177e4SLinus Torvalds } 14611da177e4SLinus Torvalds } 14621da177e4SLinus Torvalds 14631da177e4SLinus Torvalds 14641da177e4SLinus Torvalds /* Write command */ 14651da177e4SLinus Torvalds static ssize_t 14661da177e4SLinus Torvalds st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) 14671da177e4SLinus Torvalds { 14681da177e4SLinus Torvalds ssize_t total; 14691da177e4SLinus Torvalds ssize_t i, do_count, blks, transfer; 14701da177e4SLinus Torvalds ssize_t retval; 14711da177e4SLinus Torvalds int undone, retry_eot = 0, scode; 14721da177e4SLinus Torvalds int async_write; 14731da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 14741da177e4SLinus Torvalds const char __user *b_point; 14751da177e4SLinus Torvalds struct scsi_request *SRpnt = NULL; 14761da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 14771da177e4SLinus Torvalds struct st_modedef *STm; 14781da177e4SLinus Torvalds struct st_partstat *STps; 14791da177e4SLinus Torvalds struct st_buffer *STbp; 14801da177e4SLinus Torvalds char *name = tape_name(STp); 14811da177e4SLinus Torvalds 14821da177e4SLinus Torvalds if (down_interruptible(&STp->lock)) 14831da177e4SLinus Torvalds return -ERESTARTSYS; 14841da177e4SLinus Torvalds 14851da177e4SLinus Torvalds retval = rw_checks(STp, filp, count); 14861da177e4SLinus Torvalds if (retval || count == 0) 14871da177e4SLinus Torvalds goto out; 14881da177e4SLinus Torvalds 14891da177e4SLinus Torvalds /* Write must be integral number of blocks */ 14901da177e4SLinus Torvalds if (STp->block_size != 0 && (count % STp->block_size) != 0) { 14911da177e4SLinus Torvalds printk(KERN_WARNING "%s: Write not multiple of tape block size.\n", 14921da177e4SLinus Torvalds name); 14931da177e4SLinus Torvalds retval = (-EINVAL); 14941da177e4SLinus Torvalds goto out; 14951da177e4SLinus Torvalds } 14961da177e4SLinus Torvalds 14971da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 14981da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 14991da177e4SLinus Torvalds 15001da177e4SLinus Torvalds if (STp->write_prot) { 15011da177e4SLinus Torvalds retval = (-EACCES); 15021da177e4SLinus Torvalds goto out; 15031da177e4SLinus Torvalds } 15041da177e4SLinus Torvalds 15051da177e4SLinus Torvalds 15061da177e4SLinus Torvalds if (STps->rw == ST_READING) { 15071da177e4SLinus Torvalds retval = flush_buffer(STp, 0); 15081da177e4SLinus Torvalds if (retval) 15091da177e4SLinus Torvalds goto out; 15101da177e4SLinus Torvalds STps->rw = ST_WRITING; 15111da177e4SLinus Torvalds } else if (STps->rw != ST_WRITING && 15121da177e4SLinus Torvalds STps->drv_file == 0 && STps->drv_block == 0) { 15131da177e4SLinus Torvalds if ((retval = set_mode_densblk(STp, STm)) < 0) 15141da177e4SLinus Torvalds goto out; 15151da177e4SLinus Torvalds if (STm->default_compression != ST_DONT_TOUCH && 15161da177e4SLinus Torvalds !(STp->compression_changed)) { 15171da177e4SLinus Torvalds if (st_compression(STp, (STm->default_compression == ST_YES))) { 15181da177e4SLinus Torvalds printk(KERN_WARNING "%s: Can't set default compression.\n", 15191da177e4SLinus Torvalds name); 15201da177e4SLinus Torvalds if (modes_defined) { 15211da177e4SLinus Torvalds retval = (-EINVAL); 15221da177e4SLinus Torvalds goto out; 15231da177e4SLinus Torvalds } 15241da177e4SLinus Torvalds } 15251da177e4SLinus Torvalds } 15261da177e4SLinus Torvalds } 15271da177e4SLinus Torvalds 15281da177e4SLinus Torvalds STbp = STp->buffer; 15291da177e4SLinus Torvalds i = write_behind_check(STp); 15301da177e4SLinus Torvalds if (i) { 15311da177e4SLinus Torvalds if (i == -ENOSPC) 15321da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 15331da177e4SLinus Torvalds else 15341da177e4SLinus Torvalds STps->eof = ST_EOM_ERROR; 15351da177e4SLinus Torvalds } 15361da177e4SLinus Torvalds 15371da177e4SLinus Torvalds if (STps->eof == ST_EOM_OK) { 15381da177e4SLinus Torvalds STps->eof = ST_EOD_1; /* allow next write */ 15391da177e4SLinus Torvalds retval = (-ENOSPC); 15401da177e4SLinus Torvalds goto out; 15411da177e4SLinus Torvalds } 15421da177e4SLinus Torvalds else if (STps->eof == ST_EOM_ERROR) { 15431da177e4SLinus Torvalds retval = (-EIO); 15441da177e4SLinus Torvalds goto out; 15451da177e4SLinus Torvalds } 15461da177e4SLinus Torvalds 15471da177e4SLinus Torvalds /* Check the buffer readability in cases where copy_user might catch 15481da177e4SLinus Torvalds the problems after some tape movement. */ 15491da177e4SLinus Torvalds if (STp->block_size != 0 && 15501da177e4SLinus Torvalds !STbp->do_dio && 15511da177e4SLinus Torvalds (copy_from_user(&i, buf, 1) != 0 || 15521da177e4SLinus Torvalds copy_from_user(&i, buf + count - 1, 1) != 0)) { 15531da177e4SLinus Torvalds retval = (-EFAULT); 15541da177e4SLinus Torvalds goto out; 15551da177e4SLinus Torvalds } 15561da177e4SLinus Torvalds 15571da177e4SLinus Torvalds retval = setup_buffering(STp, buf, count, 0); 15581da177e4SLinus Torvalds if (retval) 15591da177e4SLinus Torvalds goto out; 15601da177e4SLinus Torvalds 15611da177e4SLinus Torvalds total = count; 15621da177e4SLinus Torvalds 15631da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 15641da177e4SLinus Torvalds cmd[0] = WRITE_6; 15651da177e4SLinus Torvalds cmd[1] = (STp->block_size != 0); 15661da177e4SLinus Torvalds 15671da177e4SLinus Torvalds STps->rw = ST_WRITING; 15681da177e4SLinus Torvalds 15691da177e4SLinus Torvalds b_point = buf; 15701da177e4SLinus Torvalds while (count > 0 && !retry_eot) { 15711da177e4SLinus Torvalds 15721da177e4SLinus Torvalds if (STbp->do_dio) { 15731da177e4SLinus Torvalds do_count = count; 15741da177e4SLinus Torvalds } 15751da177e4SLinus Torvalds else { 15761da177e4SLinus Torvalds if (STp->block_size == 0) 15771da177e4SLinus Torvalds do_count = count; 15781da177e4SLinus Torvalds else { 15791da177e4SLinus Torvalds do_count = STbp->buffer_blocks * STp->block_size - 15801da177e4SLinus Torvalds STbp->buffer_bytes; 15811da177e4SLinus Torvalds if (do_count > count) 15821da177e4SLinus Torvalds do_count = count; 15831da177e4SLinus Torvalds } 15841da177e4SLinus Torvalds 15851da177e4SLinus Torvalds i = append_to_buffer(b_point, STbp, do_count); 15861da177e4SLinus Torvalds if (i) { 15871da177e4SLinus Torvalds retval = i; 15881da177e4SLinus Torvalds goto out; 15891da177e4SLinus Torvalds } 15901da177e4SLinus Torvalds } 15911da177e4SLinus Torvalds count -= do_count; 15921da177e4SLinus Torvalds b_point += do_count; 15931da177e4SLinus Torvalds 15941da177e4SLinus Torvalds async_write = STp->block_size == 0 && !STbp->do_dio && 15951da177e4SLinus Torvalds STm->do_async_writes && STps->eof < ST_EOM_OK; 15961da177e4SLinus Torvalds 15971da177e4SLinus Torvalds if (STp->block_size != 0 && STm->do_buffer_writes && 15981da177e4SLinus Torvalds !(STp->try_dio && try_wdio) && STps->eof < ST_EOM_OK && 15991da177e4SLinus Torvalds STbp->buffer_bytes < STbp->buffer_size) { 16001da177e4SLinus Torvalds STp->dirty = 1; 16011da177e4SLinus Torvalds /* Don't write a buffer that is not full enough. */ 16021da177e4SLinus Torvalds if (!async_write && count == 0) 16031da177e4SLinus Torvalds break; 16041da177e4SLinus Torvalds } 16051da177e4SLinus Torvalds 16061da177e4SLinus Torvalds retry_write: 16071da177e4SLinus Torvalds if (STp->block_size == 0) 16081da177e4SLinus Torvalds blks = transfer = do_count; 16091da177e4SLinus Torvalds else { 16101da177e4SLinus Torvalds if (!STbp->do_dio) 16111da177e4SLinus Torvalds blks = STbp->buffer_bytes; 16121da177e4SLinus Torvalds else 16131da177e4SLinus Torvalds blks = do_count; 16141da177e4SLinus Torvalds blks /= STp->block_size; 16151da177e4SLinus Torvalds transfer = blks * STp->block_size; 16161da177e4SLinus Torvalds } 16171da177e4SLinus Torvalds cmd[2] = blks >> 16; 16181da177e4SLinus Torvalds cmd[3] = blks >> 8; 16191da177e4SLinus Torvalds cmd[4] = blks; 16201da177e4SLinus Torvalds 16211da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE, 16221da177e4SLinus Torvalds STp->device->timeout, MAX_WRITE_RETRIES, !async_write); 16231da177e4SLinus Torvalds if (!SRpnt) { 16241da177e4SLinus Torvalds retval = STbp->syscall_result; 16251da177e4SLinus Torvalds goto out; 16261da177e4SLinus Torvalds } 16271da177e4SLinus Torvalds if (async_write) { 16281da177e4SLinus Torvalds STbp->writing = transfer; 16291da177e4SLinus Torvalds STp->dirty = !(STbp->writing == 16301da177e4SLinus Torvalds STbp->buffer_bytes); 16311da177e4SLinus Torvalds SRpnt = NULL; /* Prevent releasing this request! */ 16321da177e4SLinus Torvalds DEB( STp->write_pending = 1; ) 16331da177e4SLinus Torvalds break; 16341da177e4SLinus Torvalds } 16351da177e4SLinus Torvalds 16361da177e4SLinus Torvalds if (STbp->syscall_result != 0) { 16371da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 16381da177e4SLinus Torvalds 16391da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name)); 16401da177e4SLinus Torvalds if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) { 16411da177e4SLinus Torvalds scode = cmdstatp->sense_hdr.sense_key; 16421da177e4SLinus Torvalds if (cmdstatp->remainder_valid) 16431da177e4SLinus Torvalds undone = (int)cmdstatp->uremainder64; 16441da177e4SLinus Torvalds else if (STp->block_size == 0 && 16451da177e4SLinus Torvalds scode == VOLUME_OVERFLOW) 16461da177e4SLinus Torvalds undone = transfer; 16471da177e4SLinus Torvalds else 16481da177e4SLinus Torvalds undone = 0; 16491da177e4SLinus Torvalds if (STp->block_size != 0) 16501da177e4SLinus Torvalds undone *= STp->block_size; 16511da177e4SLinus Torvalds if (undone <= do_count) { 16521da177e4SLinus Torvalds /* Only data from this write is not written */ 16531da177e4SLinus Torvalds count += undone; 16541da177e4SLinus Torvalds do_count -= undone; 16551da177e4SLinus Torvalds if (STp->block_size) 16561da177e4SLinus Torvalds blks = (transfer - undone) / STp->block_size; 16571da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 16581da177e4SLinus Torvalds /* Continue in fixed block mode if all written 16591da177e4SLinus Torvalds in this request but still something left to write 16601da177e4SLinus Torvalds (retval left to zero) 16611da177e4SLinus Torvalds */ 16621da177e4SLinus Torvalds if (STp->block_size == 0 || 16631da177e4SLinus Torvalds undone > 0 || count == 0) 16641da177e4SLinus Torvalds retval = (-ENOSPC); /* EOM within current request */ 16651da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 16661da177e4SLinus Torvalds "%s: EOM with %d bytes unwritten.\n", 16671da177e4SLinus Torvalds name, (int)count)); 16681da177e4SLinus Torvalds } else { 16691da177e4SLinus Torvalds /* EOT within data buffered earlier (possible only 16701da177e4SLinus Torvalds in fixed block mode without direct i/o) */ 16711da177e4SLinus Torvalds if (!retry_eot && !cmdstatp->deferred && 16721da177e4SLinus Torvalds (scode == NO_SENSE || scode == RECOVERED_ERROR)) { 16731da177e4SLinus Torvalds move_buffer_data(STp->buffer, transfer - undone); 16741da177e4SLinus Torvalds retry_eot = 1; 16751da177e4SLinus Torvalds if (STps->drv_block >= 0) { 16761da177e4SLinus Torvalds STps->drv_block += (transfer - undone) / 16771da177e4SLinus Torvalds STp->block_size; 16781da177e4SLinus Torvalds } 16791da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 16801da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 16811da177e4SLinus Torvalds "%s: Retry write of %d bytes at EOM.\n", 16821da177e4SLinus Torvalds name, STp->buffer->buffer_bytes)); 16831da177e4SLinus Torvalds goto retry_write; 16841da177e4SLinus Torvalds } 16851da177e4SLinus Torvalds else { 16861da177e4SLinus Torvalds /* Either error within data buffered by driver or 16871da177e4SLinus Torvalds failed retry */ 16881da177e4SLinus Torvalds count -= do_count; 16891da177e4SLinus Torvalds blks = do_count = 0; 16901da177e4SLinus Torvalds STps->eof = ST_EOM_ERROR; 16911da177e4SLinus Torvalds STps->drv_block = (-1); /* Too cautious? */ 16921da177e4SLinus Torvalds retval = (-EIO); /* EOM for old data */ 16931da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 16941da177e4SLinus Torvalds "%s: EOM with lost data.\n", 16951da177e4SLinus Torvalds name)); 16961da177e4SLinus Torvalds } 16971da177e4SLinus Torvalds } 16981da177e4SLinus Torvalds } else { 16991da177e4SLinus Torvalds count += do_count; 17001da177e4SLinus Torvalds STps->drv_block = (-1); /* Too cautious? */ 17011da177e4SLinus Torvalds retval = (-EIO); 17021da177e4SLinus Torvalds } 17031da177e4SLinus Torvalds 17041da177e4SLinus Torvalds } 17051da177e4SLinus Torvalds 17061da177e4SLinus Torvalds if (STps->drv_block >= 0) { 17071da177e4SLinus Torvalds if (STp->block_size == 0) 17081da177e4SLinus Torvalds STps->drv_block += (do_count > 0); 17091da177e4SLinus Torvalds else 17101da177e4SLinus Torvalds STps->drv_block += blks; 17111da177e4SLinus Torvalds } 17121da177e4SLinus Torvalds 17131da177e4SLinus Torvalds STbp->buffer_bytes = 0; 17141da177e4SLinus Torvalds STp->dirty = 0; 17151da177e4SLinus Torvalds 17161da177e4SLinus Torvalds if (retval || retry_eot) { 17171da177e4SLinus Torvalds if (count < total) 17181da177e4SLinus Torvalds retval = total - count; 17191da177e4SLinus Torvalds goto out; 17201da177e4SLinus Torvalds } 17211da177e4SLinus Torvalds } 17221da177e4SLinus Torvalds 17231da177e4SLinus Torvalds if (STps->eof == ST_EOD_1) 17241da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 17251da177e4SLinus Torvalds else if (STps->eof != ST_EOM_OK) 17261da177e4SLinus Torvalds STps->eof = ST_NOEOF; 17271da177e4SLinus Torvalds retval = total - count; 17281da177e4SLinus Torvalds 17291da177e4SLinus Torvalds out: 17301da177e4SLinus Torvalds if (SRpnt != NULL) 17311da177e4SLinus Torvalds scsi_release_request(SRpnt); 17321da177e4SLinus Torvalds release_buffering(STp); 17331da177e4SLinus Torvalds up(&STp->lock); 17341da177e4SLinus Torvalds 17351da177e4SLinus Torvalds return retval; 17361da177e4SLinus Torvalds } 17371da177e4SLinus Torvalds 17381da177e4SLinus Torvalds /* Read data from the tape. Returns zero in the normal case, one if the 17391da177e4SLinus Torvalds eof status has changed, and the negative error code in case of a 17401da177e4SLinus Torvalds fatal error. Otherwise updates the buffer and the eof state. 17411da177e4SLinus Torvalds 17421da177e4SLinus Torvalds Does release user buffer mapping if it is set. 17431da177e4SLinus Torvalds */ 17441da177e4SLinus Torvalds static long read_tape(struct scsi_tape *STp, long count, 17451da177e4SLinus Torvalds struct scsi_request ** aSRpnt) 17461da177e4SLinus Torvalds { 17471da177e4SLinus Torvalds int transfer, blks, bytes; 17481da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 17491da177e4SLinus Torvalds struct scsi_request *SRpnt; 17501da177e4SLinus Torvalds struct st_modedef *STm; 17511da177e4SLinus Torvalds struct st_partstat *STps; 17521da177e4SLinus Torvalds struct st_buffer *STbp; 17531da177e4SLinus Torvalds int retval = 0; 17541da177e4SLinus Torvalds char *name = tape_name(STp); 17551da177e4SLinus Torvalds 17561da177e4SLinus Torvalds if (count == 0) 17571da177e4SLinus Torvalds return 0; 17581da177e4SLinus Torvalds 17591da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 17601da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 17611da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) 17621da177e4SLinus Torvalds return 1; 17631da177e4SLinus Torvalds STbp = STp->buffer; 17641da177e4SLinus Torvalds 17651da177e4SLinus Torvalds if (STp->block_size == 0) 17661da177e4SLinus Torvalds blks = bytes = count; 17671da177e4SLinus Torvalds else { 17681da177e4SLinus Torvalds if (!(STp->try_dio && try_rdio) && STm->do_read_ahead) { 17691da177e4SLinus Torvalds blks = (STp->buffer)->buffer_blocks; 17701da177e4SLinus Torvalds bytes = blks * STp->block_size; 17711da177e4SLinus Torvalds } else { 17721da177e4SLinus Torvalds bytes = count; 17731da177e4SLinus Torvalds if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size) 17741da177e4SLinus Torvalds bytes = (STp->buffer)->buffer_size; 17751da177e4SLinus Torvalds blks = bytes / STp->block_size; 17761da177e4SLinus Torvalds bytes = blks * STp->block_size; 17771da177e4SLinus Torvalds } 17781da177e4SLinus Torvalds } 17791da177e4SLinus Torvalds 17801da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 17811da177e4SLinus Torvalds cmd[0] = READ_6; 17821da177e4SLinus Torvalds cmd[1] = (STp->block_size != 0); 17831da177e4SLinus Torvalds cmd[2] = blks >> 16; 17841da177e4SLinus Torvalds cmd[3] = blks >> 8; 17851da177e4SLinus Torvalds cmd[4] = blks; 17861da177e4SLinus Torvalds 17871da177e4SLinus Torvalds SRpnt = *aSRpnt; 17881da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE, 17891da177e4SLinus Torvalds STp->device->timeout, MAX_RETRIES, 1); 17901da177e4SLinus Torvalds release_buffering(STp); 17911da177e4SLinus Torvalds *aSRpnt = SRpnt; 17921da177e4SLinus Torvalds if (!SRpnt) 17931da177e4SLinus Torvalds return STbp->syscall_result; 17941da177e4SLinus Torvalds 17951da177e4SLinus Torvalds STbp->read_pointer = 0; 17961da177e4SLinus Torvalds STps->at_sm = 0; 17971da177e4SLinus Torvalds 17981da177e4SLinus Torvalds /* Something to check */ 17991da177e4SLinus Torvalds if (STbp->syscall_result) { 18001da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 18011da177e4SLinus Torvalds 18021da177e4SLinus Torvalds retval = 1; 18031da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n", 18041da177e4SLinus Torvalds name, 18051da177e4SLinus Torvalds SRpnt->sr_sense_buffer[0], SRpnt->sr_sense_buffer[1], 18061da177e4SLinus Torvalds SRpnt->sr_sense_buffer[2], SRpnt->sr_sense_buffer[3], 18071da177e4SLinus Torvalds SRpnt->sr_sense_buffer[4], SRpnt->sr_sense_buffer[5], 18081da177e4SLinus Torvalds SRpnt->sr_sense_buffer[6], SRpnt->sr_sense_buffer[7])); 18091da177e4SLinus Torvalds if (cmdstatp->have_sense) { 18101da177e4SLinus Torvalds 18111da177e4SLinus Torvalds if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK) 18121da177e4SLinus Torvalds cmdstatp->flags &= 0xcf; /* No need for EOM in this case */ 18131da177e4SLinus Torvalds 18141da177e4SLinus Torvalds if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */ 18151da177e4SLinus Torvalds /* Compute the residual count */ 18161da177e4SLinus Torvalds if (cmdstatp->remainder_valid) 18171da177e4SLinus Torvalds transfer = (int)cmdstatp->uremainder64; 18181da177e4SLinus Torvalds else 18191da177e4SLinus Torvalds transfer = 0; 18201da177e4SLinus Torvalds if (STp->block_size == 0 && 18211da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR) 18221da177e4SLinus Torvalds transfer = bytes; 18231da177e4SLinus Torvalds 18241da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_ILI) { /* ILI */ 18251da177e4SLinus Torvalds if (STp->block_size == 0) { 18261da177e4SLinus Torvalds if (transfer <= 0) { 18271da177e4SLinus Torvalds if (transfer < 0) 18281da177e4SLinus Torvalds printk(KERN_NOTICE 18291da177e4SLinus Torvalds "%s: Failed to read %d byte block with %d byte transfer.\n", 18301da177e4SLinus Torvalds name, bytes - transfer, bytes); 18311da177e4SLinus Torvalds if (STps->drv_block >= 0) 18321da177e4SLinus Torvalds STps->drv_block += 1; 18331da177e4SLinus Torvalds STbp->buffer_bytes = 0; 18341da177e4SLinus Torvalds return (-ENOMEM); 18351da177e4SLinus Torvalds } 18361da177e4SLinus Torvalds STbp->buffer_bytes = bytes - transfer; 18371da177e4SLinus Torvalds } else { 18381da177e4SLinus Torvalds scsi_release_request(SRpnt); 18391da177e4SLinus Torvalds SRpnt = *aSRpnt = NULL; 18401da177e4SLinus Torvalds if (transfer == blks) { /* We did not get anything, error */ 18411da177e4SLinus Torvalds printk(KERN_NOTICE "%s: Incorrect block size.\n", name); 18421da177e4SLinus Torvalds if (STps->drv_block >= 0) 18431da177e4SLinus Torvalds STps->drv_block += blks - transfer + 1; 18441da177e4SLinus Torvalds st_int_ioctl(STp, MTBSR, 1); 18451da177e4SLinus Torvalds return (-EIO); 18461da177e4SLinus Torvalds } 18471da177e4SLinus Torvalds /* We have some data, deliver it */ 18481da177e4SLinus Torvalds STbp->buffer_bytes = (blks - transfer) * 18491da177e4SLinus Torvalds STp->block_size; 18501da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 18511da177e4SLinus Torvalds "%s: ILI but enough data received %ld %d.\n", 18521da177e4SLinus Torvalds name, count, STbp->buffer_bytes)); 18531da177e4SLinus Torvalds if (STps->drv_block >= 0) 18541da177e4SLinus Torvalds STps->drv_block += 1; 18551da177e4SLinus Torvalds if (st_int_ioctl(STp, MTBSR, 1)) 18561da177e4SLinus Torvalds return (-EIO); 18571da177e4SLinus Torvalds } 18581da177e4SLinus Torvalds } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */ 18591da177e4SLinus Torvalds if (STps->eof != ST_FM_HIT) 18601da177e4SLinus Torvalds STps->eof = ST_FM_HIT; 18611da177e4SLinus Torvalds else 18621da177e4SLinus Torvalds STps->eof = ST_EOD_2; 18631da177e4SLinus Torvalds if (STp->block_size == 0) 18641da177e4SLinus Torvalds STbp->buffer_bytes = 0; 18651da177e4SLinus Torvalds else 18661da177e4SLinus Torvalds STbp->buffer_bytes = 18671da177e4SLinus Torvalds bytes - transfer * STp->block_size; 18681da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 18691da177e4SLinus Torvalds "%s: EOF detected (%d bytes read).\n", 18701da177e4SLinus Torvalds name, STbp->buffer_bytes)); 18711da177e4SLinus Torvalds } else if (cmdstatp->flags & SENSE_EOM) { 18721da177e4SLinus Torvalds if (STps->eof == ST_FM) 18731da177e4SLinus Torvalds STps->eof = ST_EOD_1; 18741da177e4SLinus Torvalds else 18751da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 18761da177e4SLinus Torvalds if (STp->block_size == 0) 18771da177e4SLinus Torvalds STbp->buffer_bytes = bytes - transfer; 18781da177e4SLinus Torvalds else 18791da177e4SLinus Torvalds STbp->buffer_bytes = 18801da177e4SLinus Torvalds bytes - transfer * STp->block_size; 18811da177e4SLinus Torvalds 18821da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n", 18831da177e4SLinus Torvalds name, STbp->buffer_bytes)); 18841da177e4SLinus Torvalds } 18851da177e4SLinus Torvalds } 18861da177e4SLinus Torvalds /* end of EOF, EOM, ILI test */ 18871da177e4SLinus Torvalds else { /* nonzero sense key */ 18881da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 18891da177e4SLinus Torvalds "%s: Tape error while reading.\n", name)); 18901da177e4SLinus Torvalds STps->drv_block = (-1); 18911da177e4SLinus Torvalds if (STps->eof == ST_FM && 18921da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == BLANK_CHECK) { 18931da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 18941da177e4SLinus Torvalds "%s: Zero returned for first BLANK CHECK after EOF.\n", 18951da177e4SLinus Torvalds name)); 18961da177e4SLinus Torvalds STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */ 18971da177e4SLinus Torvalds } else /* Some other extended sense code */ 18981da177e4SLinus Torvalds retval = (-EIO); 18991da177e4SLinus Torvalds } 19001da177e4SLinus Torvalds 19011da177e4SLinus Torvalds if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */ 19021da177e4SLinus Torvalds STbp->buffer_bytes = 0; 19031da177e4SLinus Torvalds } 19041da177e4SLinus Torvalds /* End of extended sense test */ 19051da177e4SLinus Torvalds else { /* Non-extended sense */ 19061da177e4SLinus Torvalds retval = STbp->syscall_result; 19071da177e4SLinus Torvalds } 19081da177e4SLinus Torvalds 19091da177e4SLinus Torvalds } 19101da177e4SLinus Torvalds /* End of error handling */ 19111da177e4SLinus Torvalds else /* Read successful */ 19121da177e4SLinus Torvalds STbp->buffer_bytes = bytes; 19131da177e4SLinus Torvalds 19141da177e4SLinus Torvalds if (STps->drv_block >= 0) { 19151da177e4SLinus Torvalds if (STp->block_size == 0) 19161da177e4SLinus Torvalds STps->drv_block++; 19171da177e4SLinus Torvalds else 19181da177e4SLinus Torvalds STps->drv_block += STbp->buffer_bytes / STp->block_size; 19191da177e4SLinus Torvalds } 19201da177e4SLinus Torvalds return retval; 19211da177e4SLinus Torvalds } 19221da177e4SLinus Torvalds 19231da177e4SLinus Torvalds 19241da177e4SLinus Torvalds /* Read command */ 19251da177e4SLinus Torvalds static ssize_t 19261da177e4SLinus Torvalds st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos) 19271da177e4SLinus Torvalds { 19281da177e4SLinus Torvalds ssize_t total; 19291da177e4SLinus Torvalds ssize_t retval = 0; 19301da177e4SLinus Torvalds ssize_t i, transfer; 19311da177e4SLinus Torvalds int special, do_dio = 0; 19321da177e4SLinus Torvalds struct scsi_request *SRpnt = NULL; 19331da177e4SLinus Torvalds struct scsi_tape *STp = filp->private_data; 19341da177e4SLinus Torvalds struct st_modedef *STm; 19351da177e4SLinus Torvalds struct st_partstat *STps; 19361da177e4SLinus Torvalds struct st_buffer *STbp = STp->buffer; 19371da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 19381da177e4SLinus Torvalds 19391da177e4SLinus Torvalds if (down_interruptible(&STp->lock)) 19401da177e4SLinus Torvalds return -ERESTARTSYS; 19411da177e4SLinus Torvalds 19421da177e4SLinus Torvalds retval = rw_checks(STp, filp, count); 19431da177e4SLinus Torvalds if (retval || count == 0) 19441da177e4SLinus Torvalds goto out; 19451da177e4SLinus Torvalds 19461da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 19471da177e4SLinus Torvalds if (!(STm->do_read_ahead) && STp->block_size != 0 && 19481da177e4SLinus Torvalds (count % STp->block_size) != 0) { 19491da177e4SLinus Torvalds retval = (-EINVAL); /* Read must be integral number of blocks */ 19501da177e4SLinus Torvalds goto out; 19511da177e4SLinus Torvalds } 19521da177e4SLinus Torvalds 19531da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 19541da177e4SLinus Torvalds if (STps->rw == ST_WRITING) { 19551da177e4SLinus Torvalds retval = flush_buffer(STp, 0); 19561da177e4SLinus Torvalds if (retval) 19571da177e4SLinus Torvalds goto out; 19581da177e4SLinus Torvalds STps->rw = ST_READING; 19591da177e4SLinus Torvalds } 19601da177e4SLinus Torvalds DEB( 19611da177e4SLinus Torvalds if (debugging && STps->eof != ST_NOEOF) 19621da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name, 19631da177e4SLinus Torvalds STps->eof, STbp->buffer_bytes); 19641da177e4SLinus Torvalds ) /* end DEB */ 19651da177e4SLinus Torvalds 19661da177e4SLinus Torvalds retval = setup_buffering(STp, buf, count, 1); 19671da177e4SLinus Torvalds if (retval) 19681da177e4SLinus Torvalds goto out; 19691da177e4SLinus Torvalds do_dio = STbp->do_dio; 19701da177e4SLinus Torvalds 19711da177e4SLinus Torvalds if (STbp->buffer_bytes == 0 && 19721da177e4SLinus Torvalds STps->eof >= ST_EOD_1) { 19731da177e4SLinus Torvalds if (STps->eof < ST_EOD) { 19741da177e4SLinus Torvalds STps->eof += 1; 19751da177e4SLinus Torvalds retval = 0; 19761da177e4SLinus Torvalds goto out; 19771da177e4SLinus Torvalds } 19781da177e4SLinus Torvalds retval = (-EIO); /* EOM or Blank Check */ 19791da177e4SLinus Torvalds goto out; 19801da177e4SLinus Torvalds } 19811da177e4SLinus Torvalds 19821da177e4SLinus Torvalds if (do_dio) { 19831da177e4SLinus Torvalds /* Check the buffer writability before any tape movement. Don't alter 19841da177e4SLinus Torvalds buffer data. */ 19851da177e4SLinus Torvalds if (copy_from_user(&i, buf, 1) != 0 || 19861da177e4SLinus Torvalds copy_to_user(buf, &i, 1) != 0 || 19871da177e4SLinus Torvalds copy_from_user(&i, buf + count - 1, 1) != 0 || 19881da177e4SLinus Torvalds copy_to_user(buf + count - 1, &i, 1) != 0) { 19891da177e4SLinus Torvalds retval = (-EFAULT); 19901da177e4SLinus Torvalds goto out; 19911da177e4SLinus Torvalds } 19921da177e4SLinus Torvalds } 19931da177e4SLinus Torvalds 19941da177e4SLinus Torvalds STps->rw = ST_READING; 19951da177e4SLinus Torvalds 19961da177e4SLinus Torvalds 19971da177e4SLinus Torvalds /* Loop until enough data in buffer or a special condition found */ 19981da177e4SLinus Torvalds for (total = 0, special = 0; total < count && !special;) { 19991da177e4SLinus Torvalds 20001da177e4SLinus Torvalds /* Get new data if the buffer is empty */ 20011da177e4SLinus Torvalds if (STbp->buffer_bytes == 0) { 20021da177e4SLinus Torvalds special = read_tape(STp, count - total, &SRpnt); 20031da177e4SLinus Torvalds if (special < 0) { /* No need to continue read */ 20041da177e4SLinus Torvalds retval = special; 20051da177e4SLinus Torvalds goto out; 20061da177e4SLinus Torvalds } 20071da177e4SLinus Torvalds } 20081da177e4SLinus Torvalds 20091da177e4SLinus Torvalds /* Move the data from driver buffer to user buffer */ 20101da177e4SLinus Torvalds if (STbp->buffer_bytes > 0) { 20111da177e4SLinus Torvalds DEB( 20121da177e4SLinus Torvalds if (debugging && STps->eof != ST_NOEOF) 20131da177e4SLinus Torvalds printk(ST_DEB_MSG 20141da177e4SLinus Torvalds "%s: EOF up (%d). Left %d, needed %d.\n", name, 20151da177e4SLinus Torvalds STps->eof, STbp->buffer_bytes, 20161da177e4SLinus Torvalds (int)(count - total)); 20171da177e4SLinus Torvalds ) /* end DEB */ 20181da177e4SLinus Torvalds transfer = STbp->buffer_bytes < count - total ? 20191da177e4SLinus Torvalds STbp->buffer_bytes : count - total; 20201da177e4SLinus Torvalds if (!do_dio) { 20211da177e4SLinus Torvalds i = from_buffer(STbp, buf, transfer); 20221da177e4SLinus Torvalds if (i) { 20231da177e4SLinus Torvalds retval = i; 20241da177e4SLinus Torvalds goto out; 20251da177e4SLinus Torvalds } 20261da177e4SLinus Torvalds } 20271da177e4SLinus Torvalds buf += transfer; 20281da177e4SLinus Torvalds total += transfer; 20291da177e4SLinus Torvalds } 20301da177e4SLinus Torvalds 20311da177e4SLinus Torvalds if (STp->block_size == 0) 20321da177e4SLinus Torvalds break; /* Read only one variable length block */ 20331da177e4SLinus Torvalds 20341da177e4SLinus Torvalds } /* for (total = 0, special = 0; 20351da177e4SLinus Torvalds total < count && !special; ) */ 20361da177e4SLinus Torvalds 20371da177e4SLinus Torvalds /* Change the eof state if no data from tape or buffer */ 20381da177e4SLinus Torvalds if (total == 0) { 20391da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) { 20401da177e4SLinus Torvalds STps->eof = ST_FM; 20411da177e4SLinus Torvalds STps->drv_block = 0; 20421da177e4SLinus Torvalds if (STps->drv_file >= 0) 20431da177e4SLinus Torvalds STps->drv_file++; 20441da177e4SLinus Torvalds } else if (STps->eof == ST_EOD_1) { 20451da177e4SLinus Torvalds STps->eof = ST_EOD_2; 20461da177e4SLinus Torvalds STps->drv_block = 0; 20471da177e4SLinus Torvalds if (STps->drv_file >= 0) 20481da177e4SLinus Torvalds STps->drv_file++; 20491da177e4SLinus Torvalds } else if (STps->eof == ST_EOD_2) 20501da177e4SLinus Torvalds STps->eof = ST_EOD; 20511da177e4SLinus Torvalds } else if (STps->eof == ST_FM) 20521da177e4SLinus Torvalds STps->eof = ST_NOEOF; 20531da177e4SLinus Torvalds retval = total; 20541da177e4SLinus Torvalds 20551da177e4SLinus Torvalds out: 20561da177e4SLinus Torvalds if (SRpnt != NULL) { 20571da177e4SLinus Torvalds scsi_release_request(SRpnt); 20581da177e4SLinus Torvalds SRpnt = NULL; 20591da177e4SLinus Torvalds } 20601da177e4SLinus Torvalds if (do_dio) { 20611da177e4SLinus Torvalds release_buffering(STp); 20621da177e4SLinus Torvalds STbp->buffer_bytes = 0; 20631da177e4SLinus Torvalds } 20641da177e4SLinus Torvalds up(&STp->lock); 20651da177e4SLinus Torvalds 20661da177e4SLinus Torvalds return retval; 20671da177e4SLinus Torvalds } 20681da177e4SLinus Torvalds 20691da177e4SLinus Torvalds 20701da177e4SLinus Torvalds 20711da177e4SLinus Torvalds DEB( 20721da177e4SLinus Torvalds /* Set the driver options */ 20731da177e4SLinus Torvalds static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name) 20741da177e4SLinus Torvalds { 20751da177e4SLinus Torvalds if (debugging) { 20761da177e4SLinus Torvalds printk(KERN_INFO 20771da177e4SLinus Torvalds "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n", 20781da177e4SLinus Torvalds name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes, 20791da177e4SLinus Torvalds STm->do_read_ahead); 20801da177e4SLinus Torvalds printk(KERN_INFO 20811da177e4SLinus Torvalds "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n", 20821da177e4SLinus Torvalds name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock); 20831da177e4SLinus Torvalds printk(KERN_INFO 20841da177e4SLinus Torvalds "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n", 20851da177e4SLinus Torvalds name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions, 20861da177e4SLinus Torvalds STp->scsi2_logical); 20871da177e4SLinus Torvalds printk(KERN_INFO 20881da177e4SLinus Torvalds "%s: sysv: %d nowait: %d\n", name, STm->sysv, STp->immediate); 20891da177e4SLinus Torvalds printk(KERN_INFO "%s: debugging: %d\n", 20901da177e4SLinus Torvalds name, debugging); 20911da177e4SLinus Torvalds } 20921da177e4SLinus Torvalds } 20931da177e4SLinus Torvalds ) 20941da177e4SLinus Torvalds 20951da177e4SLinus Torvalds 20961da177e4SLinus Torvalds static int st_set_options(struct scsi_tape *STp, long options) 20971da177e4SLinus Torvalds { 20981da177e4SLinus Torvalds int value; 20991da177e4SLinus Torvalds long code; 21001da177e4SLinus Torvalds struct st_modedef *STm; 21011da177e4SLinus Torvalds char *name = tape_name(STp); 21021da177e4SLinus Torvalds struct cdev *cd0, *cd1; 21031da177e4SLinus Torvalds 21041da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 21051da177e4SLinus Torvalds if (!STm->defined) { 21061da177e4SLinus Torvalds cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1]; 21071da177e4SLinus Torvalds memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef)); 21081da177e4SLinus Torvalds STm->cdevs[0] = cd0; STm->cdevs[1] = cd1; 21091da177e4SLinus Torvalds modes_defined = 1; 21101da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 21111da177e4SLinus Torvalds "%s: Initialized mode %d definition from mode 0\n", 21121da177e4SLinus Torvalds name, STp->current_mode)); 21131da177e4SLinus Torvalds } 21141da177e4SLinus Torvalds 21151da177e4SLinus Torvalds code = options & MT_ST_OPTIONS; 21161da177e4SLinus Torvalds if (code == MT_ST_BOOLEANS) { 21171da177e4SLinus Torvalds STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0; 21181da177e4SLinus Torvalds STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0; 21191da177e4SLinus Torvalds STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0; 21201da177e4SLinus Torvalds STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0; 21211da177e4SLinus Torvalds STp->two_fm = (options & MT_ST_TWO_FM) != 0; 21221da177e4SLinus Torvalds STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0; 21231da177e4SLinus Torvalds STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0; 21241da177e4SLinus Torvalds STp->can_bsr = (options & MT_ST_CAN_BSR) != 0; 21251da177e4SLinus Torvalds STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0; 21261da177e4SLinus Torvalds if ((STp->device)->scsi_level >= SCSI_2) 21271da177e4SLinus Torvalds STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0; 21281da177e4SLinus Torvalds STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0; 21291da177e4SLinus Torvalds STp->immediate = (options & MT_ST_NOWAIT) != 0; 21301da177e4SLinus Torvalds STm->sysv = (options & MT_ST_SYSV) != 0; 21311da177e4SLinus Torvalds DEB( debugging = (options & MT_ST_DEBUGGING) != 0; 21321da177e4SLinus Torvalds st_log_options(STp, STm, name); ) 21331da177e4SLinus Torvalds } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) { 21341da177e4SLinus Torvalds value = (code == MT_ST_SETBOOLEANS); 21351da177e4SLinus Torvalds if ((options & MT_ST_BUFFER_WRITES) != 0) 21361da177e4SLinus Torvalds STm->do_buffer_writes = value; 21371da177e4SLinus Torvalds if ((options & MT_ST_ASYNC_WRITES) != 0) 21381da177e4SLinus Torvalds STm->do_async_writes = value; 21391da177e4SLinus Torvalds if ((options & MT_ST_DEF_WRITES) != 0) 21401da177e4SLinus Torvalds STm->defaults_for_writes = value; 21411da177e4SLinus Torvalds if ((options & MT_ST_READ_AHEAD) != 0) 21421da177e4SLinus Torvalds STm->do_read_ahead = value; 21431da177e4SLinus Torvalds if ((options & MT_ST_TWO_FM) != 0) 21441da177e4SLinus Torvalds STp->two_fm = value; 21451da177e4SLinus Torvalds if ((options & MT_ST_FAST_MTEOM) != 0) 21461da177e4SLinus Torvalds STp->fast_mteom = value; 21471da177e4SLinus Torvalds if ((options & MT_ST_AUTO_LOCK) != 0) 21481da177e4SLinus Torvalds STp->do_auto_lock = value; 21491da177e4SLinus Torvalds if ((options & MT_ST_CAN_BSR) != 0) 21501da177e4SLinus Torvalds STp->can_bsr = value; 21511da177e4SLinus Torvalds if ((options & MT_ST_NO_BLKLIMS) != 0) 21521da177e4SLinus Torvalds STp->omit_blklims = value; 21531da177e4SLinus Torvalds if ((STp->device)->scsi_level >= SCSI_2 && 21541da177e4SLinus Torvalds (options & MT_ST_CAN_PARTITIONS) != 0) 21551da177e4SLinus Torvalds STp->can_partitions = value; 21561da177e4SLinus Torvalds if ((options & MT_ST_SCSI2LOGICAL) != 0) 21571da177e4SLinus Torvalds STp->scsi2_logical = value; 21581da177e4SLinus Torvalds if ((options & MT_ST_NOWAIT) != 0) 21591da177e4SLinus Torvalds STp->immediate = value; 21601da177e4SLinus Torvalds if ((options & MT_ST_SYSV) != 0) 21611da177e4SLinus Torvalds STm->sysv = value; 21621da177e4SLinus Torvalds DEB( 21631da177e4SLinus Torvalds if ((options & MT_ST_DEBUGGING) != 0) 21641da177e4SLinus Torvalds debugging = value; 21651da177e4SLinus Torvalds st_log_options(STp, STm, name); ) 21661da177e4SLinus Torvalds } else if (code == MT_ST_WRITE_THRESHOLD) { 21671da177e4SLinus Torvalds /* Retained for compatibility */ 21681da177e4SLinus Torvalds } else if (code == MT_ST_DEF_BLKSIZE) { 21691da177e4SLinus Torvalds value = (options & ~MT_ST_OPTIONS); 21701da177e4SLinus Torvalds if (value == ~MT_ST_OPTIONS) { 21711da177e4SLinus Torvalds STm->default_blksize = (-1); 21721da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name)); 21731da177e4SLinus Torvalds } else { 21741da177e4SLinus Torvalds STm->default_blksize = value; 21751da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n", 21761da177e4SLinus Torvalds name, STm->default_blksize)); 21771da177e4SLinus Torvalds if (STp->ready == ST_READY) { 21781da177e4SLinus Torvalds STp->blksize_changed = 0; 21791da177e4SLinus Torvalds set_mode_densblk(STp, STm); 21801da177e4SLinus Torvalds } 21811da177e4SLinus Torvalds } 21821da177e4SLinus Torvalds } else if (code == MT_ST_TIMEOUTS) { 21831da177e4SLinus Torvalds value = (options & ~MT_ST_OPTIONS); 21841da177e4SLinus Torvalds if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) { 21851da177e4SLinus Torvalds STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ; 21861da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name, 21871da177e4SLinus Torvalds (value & ~MT_ST_SET_LONG_TIMEOUT))); 21881da177e4SLinus Torvalds } else { 21891da177e4SLinus Torvalds STp->device->timeout = value * HZ; 21901da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n", 21911da177e4SLinus Torvalds name, value) ); 21921da177e4SLinus Torvalds } 21931da177e4SLinus Torvalds } else if (code == MT_ST_SET_CLN) { 21941da177e4SLinus Torvalds value = (options & ~MT_ST_OPTIONS) & 0xff; 21951da177e4SLinus Torvalds if (value != 0 && 21961da177e4SLinus Torvalds value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE) 21971da177e4SLinus Torvalds return (-EINVAL); 21981da177e4SLinus Torvalds STp->cln_mode = value; 21991da177e4SLinus Torvalds STp->cln_sense_mask = (options >> 8) & 0xff; 22001da177e4SLinus Torvalds STp->cln_sense_value = (options >> 16) & 0xff; 22011da177e4SLinus Torvalds printk(KERN_INFO 22021da177e4SLinus Torvalds "%s: Cleaning request mode %d, mask %02x, value %02x\n", 22031da177e4SLinus Torvalds name, value, STp->cln_sense_mask, STp->cln_sense_value); 22041da177e4SLinus Torvalds } else if (code == MT_ST_DEF_OPTIONS) { 22051da177e4SLinus Torvalds code = (options & ~MT_ST_CLEAR_DEFAULT); 22061da177e4SLinus Torvalds value = (options & MT_ST_CLEAR_DEFAULT); 22071da177e4SLinus Torvalds if (code == MT_ST_DEF_DENSITY) { 22081da177e4SLinus Torvalds if (value == MT_ST_CLEAR_DEFAULT) { 22091da177e4SLinus Torvalds STm->default_density = (-1); 22101da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Density default disabled.\n", 22111da177e4SLinus Torvalds name)); 22121da177e4SLinus Torvalds } else { 22131da177e4SLinus Torvalds STm->default_density = value & 0xff; 22141da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Density default set to %x\n", 22151da177e4SLinus Torvalds name, STm->default_density)); 22161da177e4SLinus Torvalds if (STp->ready == ST_READY) { 22171da177e4SLinus Torvalds STp->density_changed = 0; 22181da177e4SLinus Torvalds set_mode_densblk(STp, STm); 22191da177e4SLinus Torvalds } 22201da177e4SLinus Torvalds } 22211da177e4SLinus Torvalds } else if (code == MT_ST_DEF_DRVBUFFER) { 22221da177e4SLinus Torvalds if (value == MT_ST_CLEAR_DEFAULT) { 22231da177e4SLinus Torvalds STp->default_drvbuffer = 0xff; 22241da177e4SLinus Torvalds DEBC( printk(KERN_INFO 22251da177e4SLinus Torvalds "%s: Drive buffer default disabled.\n", name)); 22261da177e4SLinus Torvalds } else { 22271da177e4SLinus Torvalds STp->default_drvbuffer = value & 7; 22281da177e4SLinus Torvalds DEBC( printk(KERN_INFO 22291da177e4SLinus Torvalds "%s: Drive buffer default set to %x\n", 22301da177e4SLinus Torvalds name, STp->default_drvbuffer)); 22311da177e4SLinus Torvalds if (STp->ready == ST_READY) 22321da177e4SLinus Torvalds st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer); 22331da177e4SLinus Torvalds } 22341da177e4SLinus Torvalds } else if (code == MT_ST_DEF_COMPRESSION) { 22351da177e4SLinus Torvalds if (value == MT_ST_CLEAR_DEFAULT) { 22361da177e4SLinus Torvalds STm->default_compression = ST_DONT_TOUCH; 22371da177e4SLinus Torvalds DEBC( printk(KERN_INFO 22381da177e4SLinus Torvalds "%s: Compression default disabled.\n", name)); 22391da177e4SLinus Torvalds } else { 22401da177e4SLinus Torvalds if ((value & 0xff00) != 0) { 22411da177e4SLinus Torvalds STp->c_algo = (value & 0xff00) >> 8; 22421da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n", 22431da177e4SLinus Torvalds name, STp->c_algo)); 22441da177e4SLinus Torvalds } 22451da177e4SLinus Torvalds if ((value & 0xff) != 0xff) { 22461da177e4SLinus Torvalds STm->default_compression = (value & 1 ? ST_YES : ST_NO); 22471da177e4SLinus Torvalds DEBC( printk(KERN_INFO "%s: Compression default set to %x\n", 22481da177e4SLinus Torvalds name, (value & 1))); 22491da177e4SLinus Torvalds if (STp->ready == ST_READY) { 22501da177e4SLinus Torvalds STp->compression_changed = 0; 22511da177e4SLinus Torvalds st_compression(STp, (STm->default_compression == ST_YES)); 22521da177e4SLinus Torvalds } 22531da177e4SLinus Torvalds } 22541da177e4SLinus Torvalds } 22551da177e4SLinus Torvalds } 22561da177e4SLinus Torvalds } else 22571da177e4SLinus Torvalds return (-EIO); 22581da177e4SLinus Torvalds 22591da177e4SLinus Torvalds return 0; 22601da177e4SLinus Torvalds } 22611da177e4SLinus Torvalds 22621da177e4SLinus Torvalds #define MODE_HEADER_LENGTH 4 22631da177e4SLinus Torvalds 22641da177e4SLinus Torvalds /* Mode header and page byte offsets */ 22651da177e4SLinus Torvalds #define MH_OFF_DATA_LENGTH 0 22661da177e4SLinus Torvalds #define MH_OFF_MEDIUM_TYPE 1 22671da177e4SLinus Torvalds #define MH_OFF_DEV_SPECIFIC 2 22681da177e4SLinus Torvalds #define MH_OFF_BDESCS_LENGTH 3 22691da177e4SLinus Torvalds #define MP_OFF_PAGE_NBR 0 22701da177e4SLinus Torvalds #define MP_OFF_PAGE_LENGTH 1 22711da177e4SLinus Torvalds 22721da177e4SLinus Torvalds /* Mode header and page bit masks */ 22731da177e4SLinus Torvalds #define MH_BIT_WP 0x80 22741da177e4SLinus Torvalds #define MP_MSK_PAGE_NBR 0x3f 22751da177e4SLinus Torvalds 22761da177e4SLinus Torvalds /* Don't return block descriptors */ 22771da177e4SLinus Torvalds #define MODE_SENSE_OMIT_BDESCS 0x08 22781da177e4SLinus Torvalds 22791da177e4SLinus Torvalds #define MODE_SELECT_PAGE_FORMAT 0x10 22801da177e4SLinus Torvalds 22811da177e4SLinus Torvalds /* Read a mode page into the tape buffer. The block descriptors are included 22821da177e4SLinus Torvalds if incl_block_descs is true. The page control is ored to the page number 22831da177e4SLinus Torvalds parameter, if necessary. */ 22841da177e4SLinus Torvalds static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs) 22851da177e4SLinus Torvalds { 22861da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 22871da177e4SLinus Torvalds struct scsi_request *SRpnt = NULL; 22881da177e4SLinus Torvalds 22891da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 22901da177e4SLinus Torvalds cmd[0] = MODE_SENSE; 22911da177e4SLinus Torvalds if (omit_block_descs) 22921da177e4SLinus Torvalds cmd[1] = MODE_SENSE_OMIT_BDESCS; 22931da177e4SLinus Torvalds cmd[2] = page; 22941da177e4SLinus Torvalds cmd[4] = 255; 22951da177e4SLinus Torvalds 22961da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, 22971da177e4SLinus Torvalds STp->device->timeout, 0, 1); 22981da177e4SLinus Torvalds if (SRpnt == NULL) 22991da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 23001da177e4SLinus Torvalds 23011da177e4SLinus Torvalds scsi_release_request(SRpnt); 23021da177e4SLinus Torvalds 23031da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 23041da177e4SLinus Torvalds } 23051da177e4SLinus Torvalds 23061da177e4SLinus Torvalds 23071da177e4SLinus Torvalds /* Send the mode page in the tape buffer to the drive. Assumes that the mode data 23081da177e4SLinus Torvalds in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */ 23091da177e4SLinus Torvalds static int write_mode_page(struct scsi_tape *STp, int page, int slow) 23101da177e4SLinus Torvalds { 23111da177e4SLinus Torvalds int pgo; 23121da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 23131da177e4SLinus Torvalds struct scsi_request *SRpnt = NULL; 23141da177e4SLinus Torvalds 23151da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 23161da177e4SLinus Torvalds cmd[0] = MODE_SELECT; 23171da177e4SLinus Torvalds cmd[1] = MODE_SELECT_PAGE_FORMAT; 23181da177e4SLinus Torvalds pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH]; 23191da177e4SLinus Torvalds cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2; 23201da177e4SLinus Torvalds 23211da177e4SLinus Torvalds /* Clear reserved fields */ 23221da177e4SLinus Torvalds (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0; 23231da177e4SLinus Torvalds (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0; 23241da177e4SLinus Torvalds (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP; 23251da177e4SLinus Torvalds (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR; 23261da177e4SLinus Torvalds 23271da177e4SLinus Torvalds SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, 23281da177e4SLinus Torvalds (slow ? STp->long_timeout : STp->device->timeout), 0, 1); 23291da177e4SLinus Torvalds if (SRpnt == NULL) 23301da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 23311da177e4SLinus Torvalds 23321da177e4SLinus Torvalds scsi_release_request(SRpnt); 23331da177e4SLinus Torvalds 23341da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 23351da177e4SLinus Torvalds } 23361da177e4SLinus Torvalds 23371da177e4SLinus Torvalds 23381da177e4SLinus Torvalds #define COMPRESSION_PAGE 0x0f 23391da177e4SLinus Torvalds #define COMPRESSION_PAGE_LENGTH 16 23401da177e4SLinus Torvalds 23411da177e4SLinus Torvalds #define CP_OFF_DCE_DCC 2 23421da177e4SLinus Torvalds #define CP_OFF_C_ALGO 7 23431da177e4SLinus Torvalds 23441da177e4SLinus Torvalds #define DCE_MASK 0x80 23451da177e4SLinus Torvalds #define DCC_MASK 0x40 23461da177e4SLinus Torvalds #define RED_MASK 0x60 23471da177e4SLinus Torvalds 23481da177e4SLinus Torvalds 23491da177e4SLinus Torvalds /* Control the compression with mode page 15. Algorithm not changed if zero. 23501da177e4SLinus Torvalds 23511da177e4SLinus Torvalds The block descriptors are read and written because Sony SDT-7000 does not 23521da177e4SLinus Torvalds work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>). 23531da177e4SLinus Torvalds Including block descriptors should not cause any harm to other drives. */ 23541da177e4SLinus Torvalds 23551da177e4SLinus Torvalds static int st_compression(struct scsi_tape * STp, int state) 23561da177e4SLinus Torvalds { 23571da177e4SLinus Torvalds int retval; 23581da177e4SLinus Torvalds int mpoffs; /* Offset to mode page start */ 23591da177e4SLinus Torvalds unsigned char *b_data = (STp->buffer)->b_data; 23601da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 23611da177e4SLinus Torvalds 23621da177e4SLinus Torvalds if (STp->ready != ST_READY) 23631da177e4SLinus Torvalds return (-EIO); 23641da177e4SLinus Torvalds 23651da177e4SLinus Torvalds /* Read the current page contents */ 23661da177e4SLinus Torvalds retval = read_mode_page(STp, COMPRESSION_PAGE, 0); 23671da177e4SLinus Torvalds if (retval) { 23681da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n", 23691da177e4SLinus Torvalds name)); 23701da177e4SLinus Torvalds return (-EIO); 23711da177e4SLinus Torvalds } 23721da177e4SLinus Torvalds 23731da177e4SLinus Torvalds mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH]; 23741da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name, 23751da177e4SLinus Torvalds (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0))); 23761da177e4SLinus Torvalds 23771da177e4SLinus Torvalds /* Check if compression can be changed */ 23781da177e4SLinus Torvalds if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) { 23791da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name)); 23801da177e4SLinus Torvalds return (-EIO); 23811da177e4SLinus Torvalds } 23821da177e4SLinus Torvalds 23831da177e4SLinus Torvalds /* Do the change */ 23841da177e4SLinus Torvalds if (state) { 23851da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK; 23861da177e4SLinus Torvalds if (STp->c_algo != 0) 23871da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo; 23881da177e4SLinus Torvalds } 23891da177e4SLinus Torvalds else { 23901da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK; 23911da177e4SLinus Torvalds if (STp->c_algo != 0) 23921da177e4SLinus Torvalds b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */ 23931da177e4SLinus Torvalds } 23941da177e4SLinus Torvalds 23951da177e4SLinus Torvalds retval = write_mode_page(STp, COMPRESSION_PAGE, 0); 23961da177e4SLinus Torvalds if (retval) { 23971da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name)); 23981da177e4SLinus Torvalds return (-EIO); 23991da177e4SLinus Torvalds } 24001da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n", 24011da177e4SLinus Torvalds name, state)); 24021da177e4SLinus Torvalds 24031da177e4SLinus Torvalds STp->compression_changed = 1; 24041da177e4SLinus Torvalds return 0; 24051da177e4SLinus Torvalds } 24061da177e4SLinus Torvalds 24071da177e4SLinus Torvalds 24081da177e4SLinus Torvalds /* Process the load and unload commands (does unload if the load code is zero) */ 24091da177e4SLinus Torvalds static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code) 24101da177e4SLinus Torvalds { 24111da177e4SLinus Torvalds int retval = (-EIO), timeout; 24121da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 24131da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 24141da177e4SLinus Torvalds struct st_partstat *STps; 24151da177e4SLinus Torvalds struct scsi_request *SRpnt; 24161da177e4SLinus Torvalds 24171da177e4SLinus Torvalds if (STp->ready != ST_READY && !load_code) { 24181da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 24191da177e4SLinus Torvalds return (-ENOMEDIUM); 24201da177e4SLinus Torvalds else 24211da177e4SLinus Torvalds return (-EIO); 24221da177e4SLinus Torvalds } 24231da177e4SLinus Torvalds 24241da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 24251da177e4SLinus Torvalds cmd[0] = START_STOP; 24261da177e4SLinus Torvalds if (load_code) 24271da177e4SLinus Torvalds cmd[4] |= 1; 24281da177e4SLinus Torvalds /* 24291da177e4SLinus Torvalds * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A 24301da177e4SLinus Torvalds */ 24311da177e4SLinus Torvalds if (load_code >= 1 + MT_ST_HPLOADER_OFFSET 24321da177e4SLinus Torvalds && load_code <= 6 + MT_ST_HPLOADER_OFFSET) { 24331da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n", 24341da177e4SLinus Torvalds name, (cmd[4]) ? "" : "un", 24351da177e4SLinus Torvalds load_code - MT_ST_HPLOADER_OFFSET)); 24361da177e4SLinus Torvalds cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */ 24371da177e4SLinus Torvalds } 24381da177e4SLinus Torvalds if (STp->immediate) { 24391da177e4SLinus Torvalds cmd[1] = 1; /* Don't wait for completion */ 24401da177e4SLinus Torvalds timeout = STp->device->timeout; 24411da177e4SLinus Torvalds } 24421da177e4SLinus Torvalds else 24431da177e4SLinus Torvalds timeout = STp->long_timeout; 24441da177e4SLinus Torvalds 24451da177e4SLinus Torvalds DEBC( 24461da177e4SLinus Torvalds if (!load_code) 24471da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Unloading tape.\n", name); 24481da177e4SLinus Torvalds else 24491da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Loading tape.\n", name); 24501da177e4SLinus Torvalds ); 24511da177e4SLinus Torvalds 24521da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE, 24531da177e4SLinus Torvalds timeout, MAX_RETRIES, 1); 24541da177e4SLinus Torvalds if (!SRpnt) 24551da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 24561da177e4SLinus Torvalds 24571da177e4SLinus Torvalds retval = (STp->buffer)->syscall_result; 24581da177e4SLinus Torvalds scsi_release_request(SRpnt); 24591da177e4SLinus Torvalds 24601da177e4SLinus Torvalds if (!retval) { /* SCSI command successful */ 24611da177e4SLinus Torvalds 24621da177e4SLinus Torvalds if (!load_code) { 24631da177e4SLinus Torvalds STp->rew_at_close = 0; 24641da177e4SLinus Torvalds STp->ready = ST_NO_TAPE; 24651da177e4SLinus Torvalds } 24661da177e4SLinus Torvalds else { 24671da177e4SLinus Torvalds STp->rew_at_close = STp->autorew_dev; 24681da177e4SLinus Torvalds retval = check_tape(STp, filp); 24691da177e4SLinus Torvalds if (retval > 0) 24701da177e4SLinus Torvalds retval = 0; 24711da177e4SLinus Torvalds } 24721da177e4SLinus Torvalds } 24731da177e4SLinus Torvalds else { 24741da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 24751da177e4SLinus Torvalds STps->drv_file = STps->drv_block = (-1); 24761da177e4SLinus Torvalds } 24771da177e4SLinus Torvalds 24781da177e4SLinus Torvalds return retval; 24791da177e4SLinus Torvalds } 24801da177e4SLinus Torvalds 24811da177e4SLinus Torvalds #if DEBUG 24821da177e4SLinus Torvalds #define ST_DEB_FORWARD 0 24831da177e4SLinus Torvalds #define ST_DEB_BACKWARD 1 24841da177e4SLinus Torvalds static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd) 24851da177e4SLinus Torvalds { 24861da177e4SLinus Torvalds s32 sc; 24871da177e4SLinus Torvalds 24881da177e4SLinus Torvalds sc = cmd[2] & 0x80 ? 0xff000000 : 0; 24891da177e4SLinus Torvalds sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4]; 24901da177e4SLinus Torvalds if (direction) 24911da177e4SLinus Torvalds sc = -sc; 24921da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name, 24931da177e4SLinus Torvalds direction ? "backward" : "forward", sc, units); 24941da177e4SLinus Torvalds } 24951da177e4SLinus Torvalds #endif 24961da177e4SLinus Torvalds 24971da177e4SLinus Torvalds 24981da177e4SLinus Torvalds /* Internal ioctl function */ 24991da177e4SLinus Torvalds static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg) 25001da177e4SLinus Torvalds { 25011da177e4SLinus Torvalds int timeout; 25021da177e4SLinus Torvalds long ltmp; 25031da177e4SLinus Torvalds int ioctl_result; 25041da177e4SLinus Torvalds int chg_eof = 1; 25051da177e4SLinus Torvalds unsigned char cmd[MAX_COMMAND_SIZE]; 25061da177e4SLinus Torvalds struct scsi_request *SRpnt; 25071da177e4SLinus Torvalds struct st_partstat *STps; 25081da177e4SLinus Torvalds int fileno, blkno, at_sm, undone; 25091da177e4SLinus Torvalds int datalen = 0, direction = DMA_NONE; 25101da177e4SLinus Torvalds char *name = tape_name(STp); 25111da177e4SLinus Torvalds 25121da177e4SLinus Torvalds WARN_ON(STp->buffer->do_dio != 0); 25131da177e4SLinus Torvalds if (STp->ready != ST_READY) { 25141da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 25151da177e4SLinus Torvalds return (-ENOMEDIUM); 25161da177e4SLinus Torvalds else 25171da177e4SLinus Torvalds return (-EIO); 25181da177e4SLinus Torvalds } 25191da177e4SLinus Torvalds timeout = STp->long_timeout; 25201da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 25211da177e4SLinus Torvalds fileno = STps->drv_file; 25221da177e4SLinus Torvalds blkno = STps->drv_block; 25231da177e4SLinus Torvalds at_sm = STps->at_sm; 25241da177e4SLinus Torvalds 25251da177e4SLinus Torvalds memset(cmd, 0, MAX_COMMAND_SIZE); 25261da177e4SLinus Torvalds switch (cmd_in) { 25271da177e4SLinus Torvalds case MTFSFM: 25281da177e4SLinus Torvalds chg_eof = 0; /* Changed from the FSF after this */ 25291da177e4SLinus Torvalds case MTFSF: 25301da177e4SLinus Torvalds cmd[0] = SPACE; 25311da177e4SLinus Torvalds cmd[1] = 0x01; /* Space FileMarks */ 25321da177e4SLinus Torvalds cmd[2] = (arg >> 16); 25331da177e4SLinus Torvalds cmd[3] = (arg >> 8); 25341da177e4SLinus Torvalds cmd[4] = arg; 25351da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);) 25361da177e4SLinus Torvalds if (fileno >= 0) 25371da177e4SLinus Torvalds fileno += arg; 25381da177e4SLinus Torvalds blkno = 0; 25391da177e4SLinus Torvalds at_sm &= (arg == 0); 25401da177e4SLinus Torvalds break; 25411da177e4SLinus Torvalds case MTBSFM: 25421da177e4SLinus Torvalds chg_eof = 0; /* Changed from the FSF after this */ 25431da177e4SLinus Torvalds case MTBSF: 25441da177e4SLinus Torvalds cmd[0] = SPACE; 25451da177e4SLinus Torvalds cmd[1] = 0x01; /* Space FileMarks */ 25461da177e4SLinus Torvalds ltmp = (-arg); 25471da177e4SLinus Torvalds cmd[2] = (ltmp >> 16); 25481da177e4SLinus Torvalds cmd[3] = (ltmp >> 8); 25491da177e4SLinus Torvalds cmd[4] = ltmp; 25501da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);) 25511da177e4SLinus Torvalds if (fileno >= 0) 25521da177e4SLinus Torvalds fileno -= arg; 25531da177e4SLinus Torvalds blkno = (-1); /* We can't know the block number */ 25541da177e4SLinus Torvalds at_sm &= (arg == 0); 25551da177e4SLinus Torvalds break; 25561da177e4SLinus Torvalds case MTFSR: 25571da177e4SLinus Torvalds cmd[0] = SPACE; 25581da177e4SLinus Torvalds cmd[1] = 0x00; /* Space Blocks */ 25591da177e4SLinus Torvalds cmd[2] = (arg >> 16); 25601da177e4SLinus Torvalds cmd[3] = (arg >> 8); 25611da177e4SLinus Torvalds cmd[4] = arg; 25621da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);) 25631da177e4SLinus Torvalds if (blkno >= 0) 25641da177e4SLinus Torvalds blkno += arg; 25651da177e4SLinus Torvalds at_sm &= (arg == 0); 25661da177e4SLinus Torvalds break; 25671da177e4SLinus Torvalds case MTBSR: 25681da177e4SLinus Torvalds cmd[0] = SPACE; 25691da177e4SLinus Torvalds cmd[1] = 0x00; /* Space Blocks */ 25701da177e4SLinus Torvalds ltmp = (-arg); 25711da177e4SLinus Torvalds cmd[2] = (ltmp >> 16); 25721da177e4SLinus Torvalds cmd[3] = (ltmp >> 8); 25731da177e4SLinus Torvalds cmd[4] = ltmp; 25741da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);) 25751da177e4SLinus Torvalds if (blkno >= 0) 25761da177e4SLinus Torvalds blkno -= arg; 25771da177e4SLinus Torvalds at_sm &= (arg == 0); 25781da177e4SLinus Torvalds break; 25791da177e4SLinus Torvalds case MTFSS: 25801da177e4SLinus Torvalds cmd[0] = SPACE; 25811da177e4SLinus Torvalds cmd[1] = 0x04; /* Space Setmarks */ 25821da177e4SLinus Torvalds cmd[2] = (arg >> 16); 25831da177e4SLinus Torvalds cmd[3] = (arg >> 8); 25841da177e4SLinus Torvalds cmd[4] = arg; 25851da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);) 25861da177e4SLinus Torvalds if (arg != 0) { 25871da177e4SLinus Torvalds blkno = fileno = (-1); 25881da177e4SLinus Torvalds at_sm = 1; 25891da177e4SLinus Torvalds } 25901da177e4SLinus Torvalds break; 25911da177e4SLinus Torvalds case MTBSS: 25921da177e4SLinus Torvalds cmd[0] = SPACE; 25931da177e4SLinus Torvalds cmd[1] = 0x04; /* Space Setmarks */ 25941da177e4SLinus Torvalds ltmp = (-arg); 25951da177e4SLinus Torvalds cmd[2] = (ltmp >> 16); 25961da177e4SLinus Torvalds cmd[3] = (ltmp >> 8); 25971da177e4SLinus Torvalds cmd[4] = ltmp; 25981da177e4SLinus Torvalds DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);) 25991da177e4SLinus Torvalds if (arg != 0) { 26001da177e4SLinus Torvalds blkno = fileno = (-1); 26011da177e4SLinus Torvalds at_sm = 1; 26021da177e4SLinus Torvalds } 26031da177e4SLinus Torvalds break; 26041da177e4SLinus Torvalds case MTWEOF: 26051da177e4SLinus Torvalds case MTWSM: 26061da177e4SLinus Torvalds if (STp->write_prot) 26071da177e4SLinus Torvalds return (-EACCES); 26081da177e4SLinus Torvalds cmd[0] = WRITE_FILEMARKS; 26091da177e4SLinus Torvalds if (cmd_in == MTWSM) 26101da177e4SLinus Torvalds cmd[1] = 2; 26111da177e4SLinus Torvalds cmd[2] = (arg >> 16); 26121da177e4SLinus Torvalds cmd[3] = (arg >> 8); 26131da177e4SLinus Torvalds cmd[4] = arg; 26141da177e4SLinus Torvalds timeout = STp->device->timeout; 26151da177e4SLinus Torvalds DEBC( 26161da177e4SLinus Torvalds if (cmd_in == MTWEOF) 26171da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name, 26181da177e4SLinus Torvalds cmd[2] * 65536 + cmd[3] * 256 + cmd[4]); 26191da177e4SLinus Torvalds else 26201da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name, 26211da177e4SLinus Torvalds cmd[2] * 65536 + cmd[3] * 256 + cmd[4]); 26221da177e4SLinus Torvalds ) 26231da177e4SLinus Torvalds if (fileno >= 0) 26241da177e4SLinus Torvalds fileno += arg; 26251da177e4SLinus Torvalds blkno = 0; 26261da177e4SLinus Torvalds at_sm = (cmd_in == MTWSM); 26271da177e4SLinus Torvalds break; 26281da177e4SLinus Torvalds case MTREW: 26291da177e4SLinus Torvalds cmd[0] = REZERO_UNIT; 26301da177e4SLinus Torvalds if (STp->immediate) { 26311da177e4SLinus Torvalds cmd[1] = 1; /* Don't wait for completion */ 26321da177e4SLinus Torvalds timeout = STp->device->timeout; 26331da177e4SLinus Torvalds } 26341da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name)); 26351da177e4SLinus Torvalds fileno = blkno = at_sm = 0; 26361da177e4SLinus Torvalds break; 26371da177e4SLinus Torvalds case MTNOP: 26381da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name)); 26391da177e4SLinus Torvalds return 0; /* Should do something ? */ 26401da177e4SLinus Torvalds break; 26411da177e4SLinus Torvalds case MTRETEN: 26421da177e4SLinus Torvalds cmd[0] = START_STOP; 26431da177e4SLinus Torvalds if (STp->immediate) { 26441da177e4SLinus Torvalds cmd[1] = 1; /* Don't wait for completion */ 26451da177e4SLinus Torvalds timeout = STp->device->timeout; 26461da177e4SLinus Torvalds } 26471da177e4SLinus Torvalds cmd[4] = 3; 26481da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name)); 26491da177e4SLinus Torvalds fileno = blkno = at_sm = 0; 26501da177e4SLinus Torvalds break; 26511da177e4SLinus Torvalds case MTEOM: 26521da177e4SLinus Torvalds if (!STp->fast_mteom) { 26531da177e4SLinus Torvalds /* space to the end of tape */ 26541da177e4SLinus Torvalds ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff); 26551da177e4SLinus Torvalds fileno = STps->drv_file; 26561da177e4SLinus Torvalds if (STps->eof >= ST_EOD_1) 26571da177e4SLinus Torvalds return 0; 26581da177e4SLinus Torvalds /* The next lines would hide the number of spaced FileMarks 26591da177e4SLinus Torvalds That's why I inserted the previous lines. I had no luck 26601da177e4SLinus Torvalds with detecting EOM with FSF, so we go now to EOM. 26611da177e4SLinus Torvalds Joerg Weule */ 26621da177e4SLinus Torvalds } else 26631da177e4SLinus Torvalds fileno = (-1); 26641da177e4SLinus Torvalds cmd[0] = SPACE; 26651da177e4SLinus Torvalds cmd[1] = 3; 26661da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n", 26671da177e4SLinus Torvalds name)); 26681da177e4SLinus Torvalds blkno = -1; 26691da177e4SLinus Torvalds at_sm = 0; 26701da177e4SLinus Torvalds break; 26711da177e4SLinus Torvalds case MTERASE: 26721da177e4SLinus Torvalds if (STp->write_prot) 26731da177e4SLinus Torvalds return (-EACCES); 26741da177e4SLinus Torvalds cmd[0] = ERASE; 26751da177e4SLinus Torvalds cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */ 26761da177e4SLinus Torvalds if (STp->immediate) { 26771da177e4SLinus Torvalds cmd[1] |= 2; /* Don't wait for completion */ 26781da177e4SLinus Torvalds timeout = STp->device->timeout; 26791da177e4SLinus Torvalds } 26801da177e4SLinus Torvalds else 26811da177e4SLinus Torvalds timeout = STp->long_timeout * 8; 26821da177e4SLinus Torvalds 26831da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name)); 26841da177e4SLinus Torvalds fileno = blkno = at_sm = 0; 26851da177e4SLinus Torvalds break; 26861da177e4SLinus Torvalds case MTSETBLK: /* Set block length */ 26871da177e4SLinus Torvalds case MTSETDENSITY: /* Set tape density */ 26881da177e4SLinus Torvalds case MTSETDRVBUFFER: /* Set drive buffering */ 26891da177e4SLinus Torvalds case SET_DENS_AND_BLK: /* Set density and block size */ 26901da177e4SLinus Torvalds chg_eof = 0; 26911da177e4SLinus Torvalds if (STp->dirty || (STp->buffer)->buffer_bytes != 0) 26921da177e4SLinus Torvalds return (-EIO); /* Not allowed if data in buffer */ 26931da177e4SLinus Torvalds if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) && 26941da177e4SLinus Torvalds (arg & MT_ST_BLKSIZE_MASK) != 0 && 26951da177e4SLinus Torvalds STp->max_block > 0 && 26961da177e4SLinus Torvalds ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block || 26971da177e4SLinus Torvalds (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) { 26981da177e4SLinus Torvalds printk(KERN_WARNING "%s: Illegal block size.\n", name); 26991da177e4SLinus Torvalds return (-EINVAL); 27001da177e4SLinus Torvalds } 27011da177e4SLinus Torvalds cmd[0] = MODE_SELECT; 27021da177e4SLinus Torvalds if ((STp->use_pf & USE_PF)) 27031da177e4SLinus Torvalds cmd[1] = MODE_SELECT_PAGE_FORMAT; 27041da177e4SLinus Torvalds cmd[4] = datalen = 12; 27051da177e4SLinus Torvalds direction = DMA_TO_DEVICE; 27061da177e4SLinus Torvalds 27071da177e4SLinus Torvalds memset((STp->buffer)->b_data, 0, 12); 27081da177e4SLinus Torvalds if (cmd_in == MTSETDRVBUFFER) 27091da177e4SLinus Torvalds (STp->buffer)->b_data[2] = (arg & 7) << 4; 27101da177e4SLinus Torvalds else 27111da177e4SLinus Torvalds (STp->buffer)->b_data[2] = 27121da177e4SLinus Torvalds STp->drv_buffer << 4; 27131da177e4SLinus Torvalds (STp->buffer)->b_data[3] = 8; /* block descriptor length */ 27141da177e4SLinus Torvalds if (cmd_in == MTSETDENSITY) { 27151da177e4SLinus Torvalds (STp->buffer)->b_data[4] = arg; 27161da177e4SLinus Torvalds STp->density_changed = 1; /* At least we tried ;-) */ 27171da177e4SLinus Torvalds } else if (cmd_in == SET_DENS_AND_BLK) 27181da177e4SLinus Torvalds (STp->buffer)->b_data[4] = arg >> 24; 27191da177e4SLinus Torvalds else 27201da177e4SLinus Torvalds (STp->buffer)->b_data[4] = STp->density; 27211da177e4SLinus Torvalds if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) { 27221da177e4SLinus Torvalds ltmp = arg & MT_ST_BLKSIZE_MASK; 27231da177e4SLinus Torvalds if (cmd_in == MTSETBLK) 27241da177e4SLinus Torvalds STp->blksize_changed = 1; /* At least we tried ;-) */ 27251da177e4SLinus Torvalds } else 27261da177e4SLinus Torvalds ltmp = STp->block_size; 27271da177e4SLinus Torvalds (STp->buffer)->b_data[9] = (ltmp >> 16); 27281da177e4SLinus Torvalds (STp->buffer)->b_data[10] = (ltmp >> 8); 27291da177e4SLinus Torvalds (STp->buffer)->b_data[11] = ltmp; 27301da177e4SLinus Torvalds timeout = STp->device->timeout; 27311da177e4SLinus Torvalds DEBC( 27321da177e4SLinus Torvalds if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) 27331da177e4SLinus Torvalds printk(ST_DEB_MSG 27341da177e4SLinus Torvalds "%s: Setting block size to %d bytes.\n", name, 27351da177e4SLinus Torvalds (STp->buffer)->b_data[9] * 65536 + 27361da177e4SLinus Torvalds (STp->buffer)->b_data[10] * 256 + 27371da177e4SLinus Torvalds (STp->buffer)->b_data[11]); 27381da177e4SLinus Torvalds if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK) 27391da177e4SLinus Torvalds printk(ST_DEB_MSG 27401da177e4SLinus Torvalds "%s: Setting density code to %x.\n", name, 27411da177e4SLinus Torvalds (STp->buffer)->b_data[4]); 27421da177e4SLinus Torvalds if (cmd_in == MTSETDRVBUFFER) 27431da177e4SLinus Torvalds printk(ST_DEB_MSG 27441da177e4SLinus Torvalds "%s: Setting drive buffer code to %d.\n", name, 27451da177e4SLinus Torvalds ((STp->buffer)->b_data[2] >> 4) & 7); 27461da177e4SLinus Torvalds ) 27471da177e4SLinus Torvalds break; 27481da177e4SLinus Torvalds default: 27491da177e4SLinus Torvalds return (-ENOSYS); 27501da177e4SLinus Torvalds } 27511da177e4SLinus Torvalds 27521da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction, 27531da177e4SLinus Torvalds timeout, MAX_RETRIES, 1); 27541da177e4SLinus Torvalds if (!SRpnt) 27551da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 27561da177e4SLinus Torvalds 27571da177e4SLinus Torvalds ioctl_result = (STp->buffer)->syscall_result; 27581da177e4SLinus Torvalds 27591da177e4SLinus Torvalds if (!ioctl_result) { /* SCSI command successful */ 27601da177e4SLinus Torvalds scsi_release_request(SRpnt); 27611da177e4SLinus Torvalds SRpnt = NULL; 27621da177e4SLinus Torvalds STps->drv_block = blkno; 27631da177e4SLinus Torvalds STps->drv_file = fileno; 27641da177e4SLinus Torvalds STps->at_sm = at_sm; 27651da177e4SLinus Torvalds 27661da177e4SLinus Torvalds if (cmd_in == MTBSFM) 27671da177e4SLinus Torvalds ioctl_result = st_int_ioctl(STp, MTFSF, 1); 27681da177e4SLinus Torvalds else if (cmd_in == MTFSFM) 27691da177e4SLinus Torvalds ioctl_result = st_int_ioctl(STp, MTBSF, 1); 27701da177e4SLinus Torvalds 27711da177e4SLinus Torvalds if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) { 27721da177e4SLinus Torvalds int old_block_size = STp->block_size; 27731da177e4SLinus Torvalds STp->block_size = arg & MT_ST_BLKSIZE_MASK; 27741da177e4SLinus Torvalds if (STp->block_size != 0) { 27751da177e4SLinus Torvalds if (old_block_size == 0) 27761da177e4SLinus Torvalds normalize_buffer(STp->buffer); 27771da177e4SLinus Torvalds (STp->buffer)->buffer_blocks = 27781da177e4SLinus Torvalds (STp->buffer)->buffer_size / STp->block_size; 27791da177e4SLinus Torvalds } 27801da177e4SLinus Torvalds (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0; 27811da177e4SLinus Torvalds if (cmd_in == SET_DENS_AND_BLK) 27821da177e4SLinus Torvalds STp->density = arg >> MT_ST_DENSITY_SHIFT; 27831da177e4SLinus Torvalds } else if (cmd_in == MTSETDRVBUFFER) 27841da177e4SLinus Torvalds STp->drv_buffer = (arg & 7); 27851da177e4SLinus Torvalds else if (cmd_in == MTSETDENSITY) 27861da177e4SLinus Torvalds STp->density = arg; 27871da177e4SLinus Torvalds 27881da177e4SLinus Torvalds if (cmd_in == MTEOM) 27891da177e4SLinus Torvalds STps->eof = ST_EOD; 27901da177e4SLinus Torvalds else if (cmd_in == MTFSF) 27911da177e4SLinus Torvalds STps->eof = ST_FM; 27921da177e4SLinus Torvalds else if (chg_eof) 27931da177e4SLinus Torvalds STps->eof = ST_NOEOF; 27941da177e4SLinus Torvalds 27951da177e4SLinus Torvalds if (cmd_in == MTWEOF) 27961da177e4SLinus Torvalds STps->rw = ST_IDLE; 27971da177e4SLinus Torvalds } else { /* SCSI command was not completely successful. Don't return 27981da177e4SLinus Torvalds from this block without releasing the SCSI command block! */ 27991da177e4SLinus Torvalds struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 28001da177e4SLinus Torvalds 28011da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_EOM) { 28021da177e4SLinus Torvalds if (cmd_in != MTBSF && cmd_in != MTBSFM && 28031da177e4SLinus Torvalds cmd_in != MTBSR && cmd_in != MTBSS) 28041da177e4SLinus Torvalds STps->eof = ST_EOM_OK; 28051da177e4SLinus Torvalds STps->drv_block = 0; 28061da177e4SLinus Torvalds } 28071da177e4SLinus Torvalds 28081da177e4SLinus Torvalds if (cmdstatp->remainder_valid) 28091da177e4SLinus Torvalds undone = (int)cmdstatp->uremainder64; 28101da177e4SLinus Torvalds else 28111da177e4SLinus Torvalds undone = 0; 28121da177e4SLinus Torvalds 28131da177e4SLinus Torvalds if (cmd_in == MTWEOF && 28141da177e4SLinus Torvalds cmdstatp->have_sense && 28151da177e4SLinus Torvalds (cmdstatp->flags & SENSE_EOM) && 28161da177e4SLinus Torvalds (cmdstatp->sense_hdr.sense_key == NO_SENSE || 28171da177e4SLinus Torvalds cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) && 28181da177e4SLinus Torvalds undone == 0) { 28191da177e4SLinus Torvalds ioctl_result = 0; /* EOF written succesfully at EOM */ 28201da177e4SLinus Torvalds if (fileno >= 0) 28211da177e4SLinus Torvalds fileno++; 28221da177e4SLinus Torvalds STps->drv_file = fileno; 28231da177e4SLinus Torvalds STps->eof = ST_NOEOF; 28241da177e4SLinus Torvalds } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) { 28251da177e4SLinus Torvalds if (fileno >= 0) 28261da177e4SLinus Torvalds STps->drv_file = fileno - undone; 28271da177e4SLinus Torvalds else 28281da177e4SLinus Torvalds STps->drv_file = fileno; 28291da177e4SLinus Torvalds STps->drv_block = -1; 28301da177e4SLinus Torvalds STps->eof = ST_NOEOF; 28311da177e4SLinus Torvalds } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) { 28321da177e4SLinus Torvalds if (arg > 0 && undone < 0) /* Some drives get this wrong */ 28331da177e4SLinus Torvalds undone = (-undone); 28341da177e4SLinus Torvalds if (STps->drv_file >= 0) 28351da177e4SLinus Torvalds STps->drv_file = fileno + undone; 28361da177e4SLinus Torvalds STps->drv_block = 0; 28371da177e4SLinus Torvalds STps->eof = ST_NOEOF; 28381da177e4SLinus Torvalds } else if (cmd_in == MTFSR) { 28391da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */ 28401da177e4SLinus Torvalds if (STps->drv_file >= 0) 28411da177e4SLinus Torvalds STps->drv_file++; 28421da177e4SLinus Torvalds STps->drv_block = 0; 28431da177e4SLinus Torvalds STps->eof = ST_FM; 28441da177e4SLinus Torvalds } else { 28451da177e4SLinus Torvalds if (blkno >= undone) 28461da177e4SLinus Torvalds STps->drv_block = blkno - undone; 28471da177e4SLinus Torvalds else 28481da177e4SLinus Torvalds STps->drv_block = (-1); 28491da177e4SLinus Torvalds STps->eof = ST_NOEOF; 28501da177e4SLinus Torvalds } 28511da177e4SLinus Torvalds } else if (cmd_in == MTBSR) { 28521da177e4SLinus Torvalds if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */ 28531da177e4SLinus Torvalds STps->drv_file--; 28541da177e4SLinus Torvalds STps->drv_block = (-1); 28551da177e4SLinus Torvalds } else { 28561da177e4SLinus Torvalds if (arg > 0 && undone < 0) /* Some drives get this wrong */ 28571da177e4SLinus Torvalds undone = (-undone); 28581da177e4SLinus Torvalds if (STps->drv_block >= 0) 28591da177e4SLinus Torvalds STps->drv_block = blkno + undone; 28601da177e4SLinus Torvalds } 28611da177e4SLinus Torvalds STps->eof = ST_NOEOF; 28621da177e4SLinus Torvalds } else if (cmd_in == MTEOM) { 28631da177e4SLinus Torvalds STps->drv_file = (-1); 28641da177e4SLinus Torvalds STps->drv_block = (-1); 28651da177e4SLinus Torvalds STps->eof = ST_EOD; 28661da177e4SLinus Torvalds } else if (cmd_in == MTSETBLK || 28671da177e4SLinus Torvalds cmd_in == MTSETDENSITY || 28681da177e4SLinus Torvalds cmd_in == MTSETDRVBUFFER || 28691da177e4SLinus Torvalds cmd_in == SET_DENS_AND_BLK) { 28701da177e4SLinus Torvalds if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST && 28711da177e4SLinus Torvalds !(STp->use_pf & PF_TESTED)) { 28721da177e4SLinus Torvalds /* Try the other possible state of Page Format if not 28731da177e4SLinus Torvalds already tried */ 28741da177e4SLinus Torvalds STp->use_pf = !STp->use_pf | PF_TESTED; 28751da177e4SLinus Torvalds scsi_release_request(SRpnt); 28761da177e4SLinus Torvalds SRpnt = NULL; 28771da177e4SLinus Torvalds return st_int_ioctl(STp, cmd_in, arg); 28781da177e4SLinus Torvalds } 28791da177e4SLinus Torvalds } else if (chg_eof) 28801da177e4SLinus Torvalds STps->eof = ST_NOEOF; 28811da177e4SLinus Torvalds 28821da177e4SLinus Torvalds if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK) 28831da177e4SLinus Torvalds STps->eof = ST_EOD; 28841da177e4SLinus Torvalds 28851da177e4SLinus Torvalds scsi_release_request(SRpnt); 28861da177e4SLinus Torvalds SRpnt = NULL; 28871da177e4SLinus Torvalds } 28881da177e4SLinus Torvalds 28891da177e4SLinus Torvalds return ioctl_result; 28901da177e4SLinus Torvalds } 28911da177e4SLinus Torvalds 28921da177e4SLinus Torvalds 28931da177e4SLinus Torvalds /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc 28941da177e4SLinus Torvalds structure. */ 28951da177e4SLinus Torvalds 28961da177e4SLinus Torvalds static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition, 28971da177e4SLinus Torvalds int logical) 28981da177e4SLinus Torvalds { 28991da177e4SLinus Torvalds int result; 29001da177e4SLinus Torvalds unsigned char scmd[MAX_COMMAND_SIZE]; 29011da177e4SLinus Torvalds struct scsi_request *SRpnt; 29021da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 29031da177e4SLinus Torvalds 29041da177e4SLinus Torvalds if (STp->ready != ST_READY) 29051da177e4SLinus Torvalds return (-EIO); 29061da177e4SLinus Torvalds 29071da177e4SLinus Torvalds memset(scmd, 0, MAX_COMMAND_SIZE); 29081da177e4SLinus Torvalds if ((STp->device)->scsi_level < SCSI_2) { 29091da177e4SLinus Torvalds scmd[0] = QFA_REQUEST_BLOCK; 29101da177e4SLinus Torvalds scmd[4] = 3; 29111da177e4SLinus Torvalds } else { 29121da177e4SLinus Torvalds scmd[0] = READ_POSITION; 29131da177e4SLinus Torvalds if (!logical && !STp->scsi2_logical) 29141da177e4SLinus Torvalds scmd[1] = 1; 29151da177e4SLinus Torvalds } 29161da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE, 29171da177e4SLinus Torvalds STp->device->timeout, MAX_READY_RETRIES, 1); 29181da177e4SLinus Torvalds if (!SRpnt) 29191da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 29201da177e4SLinus Torvalds 29211da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0 || 29221da177e4SLinus Torvalds (STp->device->scsi_level >= SCSI_2 && 29231da177e4SLinus Torvalds ((STp->buffer)->b_data[0] & 4) != 0)) { 29241da177e4SLinus Torvalds *block = *partition = 0; 29251da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name)); 29261da177e4SLinus Torvalds result = (-EIO); 29271da177e4SLinus Torvalds } else { 29281da177e4SLinus Torvalds result = 0; 29291da177e4SLinus Torvalds if ((STp->device)->scsi_level < SCSI_2) { 29301da177e4SLinus Torvalds *block = ((STp->buffer)->b_data[0] << 16) 29311da177e4SLinus Torvalds + ((STp->buffer)->b_data[1] << 8) 29321da177e4SLinus Torvalds + (STp->buffer)->b_data[2]; 29331da177e4SLinus Torvalds *partition = 0; 29341da177e4SLinus Torvalds } else { 29351da177e4SLinus Torvalds *block = ((STp->buffer)->b_data[4] << 24) 29361da177e4SLinus Torvalds + ((STp->buffer)->b_data[5] << 16) 29371da177e4SLinus Torvalds + ((STp->buffer)->b_data[6] << 8) 29381da177e4SLinus Torvalds + (STp->buffer)->b_data[7]; 29391da177e4SLinus Torvalds *partition = (STp->buffer)->b_data[1]; 29401da177e4SLinus Torvalds if (((STp->buffer)->b_data[0] & 0x80) && 29411da177e4SLinus Torvalds (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */ 29421da177e4SLinus Torvalds STp->ps[0].drv_block = STp->ps[0].drv_file = 0; 29431da177e4SLinus Torvalds } 29441da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name, 29451da177e4SLinus Torvalds *block, *partition)); 29461da177e4SLinus Torvalds } 29471da177e4SLinus Torvalds scsi_release_request(SRpnt); 29481da177e4SLinus Torvalds SRpnt = NULL; 29491da177e4SLinus Torvalds 29501da177e4SLinus Torvalds return result; 29511da177e4SLinus Torvalds } 29521da177e4SLinus Torvalds 29531da177e4SLinus Torvalds 29541da177e4SLinus Torvalds /* Set the tape block and partition. Negative partition means that only the 29551da177e4SLinus Torvalds block should be set in vendor specific way. */ 29561da177e4SLinus Torvalds static int set_location(struct scsi_tape *STp, unsigned int block, int partition, 29571da177e4SLinus Torvalds int logical) 29581da177e4SLinus Torvalds { 29591da177e4SLinus Torvalds struct st_partstat *STps; 29601da177e4SLinus Torvalds int result, p; 29611da177e4SLinus Torvalds unsigned int blk; 29621da177e4SLinus Torvalds int timeout; 29631da177e4SLinus Torvalds unsigned char scmd[MAX_COMMAND_SIZE]; 29641da177e4SLinus Torvalds struct scsi_request *SRpnt; 29651da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 29661da177e4SLinus Torvalds 29671da177e4SLinus Torvalds if (STp->ready != ST_READY) 29681da177e4SLinus Torvalds return (-EIO); 29691da177e4SLinus Torvalds timeout = STp->long_timeout; 29701da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 29711da177e4SLinus Torvalds 29721da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n", 29731da177e4SLinus Torvalds name, block, partition)); 29741da177e4SLinus Torvalds DEB(if (partition < 0) 29751da177e4SLinus Torvalds return (-EIO); ) 29761da177e4SLinus Torvalds 29771da177e4SLinus Torvalds /* Update the location at the partition we are leaving */ 29781da177e4SLinus Torvalds if ((!STp->can_partitions && partition != 0) || 29791da177e4SLinus Torvalds partition >= ST_NBR_PARTITIONS) 29801da177e4SLinus Torvalds return (-EINVAL); 29811da177e4SLinus Torvalds if (partition != STp->partition) { 29821da177e4SLinus Torvalds if (get_location(STp, &blk, &p, 1)) 29831da177e4SLinus Torvalds STps->last_block_valid = 0; 29841da177e4SLinus Torvalds else { 29851da177e4SLinus Torvalds STps->last_block_valid = 1; 29861da177e4SLinus Torvalds STps->last_block_visited = blk; 29871da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 29881da177e4SLinus Torvalds "%s: Visited block %d for partition %d saved.\n", 29891da177e4SLinus Torvalds name, blk, STp->partition)); 29901da177e4SLinus Torvalds } 29911da177e4SLinus Torvalds } 29921da177e4SLinus Torvalds 29931da177e4SLinus Torvalds memset(scmd, 0, MAX_COMMAND_SIZE); 29941da177e4SLinus Torvalds if ((STp->device)->scsi_level < SCSI_2) { 29951da177e4SLinus Torvalds scmd[0] = QFA_SEEK_BLOCK; 29961da177e4SLinus Torvalds scmd[2] = (block >> 16); 29971da177e4SLinus Torvalds scmd[3] = (block >> 8); 29981da177e4SLinus Torvalds scmd[4] = block; 29991da177e4SLinus Torvalds scmd[5] = 0; 30001da177e4SLinus Torvalds } else { 30011da177e4SLinus Torvalds scmd[0] = SEEK_10; 30021da177e4SLinus Torvalds scmd[3] = (block >> 24); 30031da177e4SLinus Torvalds scmd[4] = (block >> 16); 30041da177e4SLinus Torvalds scmd[5] = (block >> 8); 30051da177e4SLinus Torvalds scmd[6] = block; 30061da177e4SLinus Torvalds if (!logical && !STp->scsi2_logical) 30071da177e4SLinus Torvalds scmd[1] = 4; 30081da177e4SLinus Torvalds if (STp->partition != partition) { 30091da177e4SLinus Torvalds scmd[1] |= 2; 30101da177e4SLinus Torvalds scmd[8] = partition; 30111da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 30121da177e4SLinus Torvalds "%s: Trying to change partition from %d to %d\n", 30131da177e4SLinus Torvalds name, STp->partition, partition)); 30141da177e4SLinus Torvalds } 30151da177e4SLinus Torvalds } 30161da177e4SLinus Torvalds if (STp->immediate) { 30171da177e4SLinus Torvalds scmd[1] |= 1; /* Don't wait for completion */ 30181da177e4SLinus Torvalds timeout = STp->device->timeout; 30191da177e4SLinus Torvalds } 30201da177e4SLinus Torvalds 30211da177e4SLinus Torvalds SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE, 30221da177e4SLinus Torvalds timeout, MAX_READY_RETRIES, 1); 30231da177e4SLinus Torvalds if (!SRpnt) 30241da177e4SLinus Torvalds return (STp->buffer)->syscall_result; 30251da177e4SLinus Torvalds 30261da177e4SLinus Torvalds STps->drv_block = STps->drv_file = (-1); 30271da177e4SLinus Torvalds STps->eof = ST_NOEOF; 30281da177e4SLinus Torvalds if ((STp->buffer)->syscall_result != 0) { 30291da177e4SLinus Torvalds result = (-EIO); 30301da177e4SLinus Torvalds if (STp->can_partitions && 30311da177e4SLinus Torvalds (STp->device)->scsi_level >= SCSI_2 && 30321da177e4SLinus Torvalds (p = find_partition(STp)) >= 0) 30331da177e4SLinus Torvalds STp->partition = p; 30341da177e4SLinus Torvalds } else { 30351da177e4SLinus Torvalds if (STp->can_partitions) { 30361da177e4SLinus Torvalds STp->partition = partition; 30371da177e4SLinus Torvalds STps = &(STp->ps[partition]); 30381da177e4SLinus Torvalds if (!STps->last_block_valid || 30391da177e4SLinus Torvalds STps->last_block_visited != block) { 30401da177e4SLinus Torvalds STps->at_sm = 0; 30411da177e4SLinus Torvalds STps->rw = ST_IDLE; 30421da177e4SLinus Torvalds } 30431da177e4SLinus Torvalds } else 30441da177e4SLinus Torvalds STps->at_sm = 0; 30451da177e4SLinus Torvalds if (block == 0) 30461da177e4SLinus Torvalds STps->drv_block = STps->drv_file = 0; 30471da177e4SLinus Torvalds result = 0; 30481da177e4SLinus Torvalds } 30491da177e4SLinus Torvalds 30501da177e4SLinus Torvalds scsi_release_request(SRpnt); 30511da177e4SLinus Torvalds SRpnt = NULL; 30521da177e4SLinus Torvalds 30531da177e4SLinus Torvalds return result; 30541da177e4SLinus Torvalds } 30551da177e4SLinus Torvalds 30561da177e4SLinus Torvalds 30571da177e4SLinus Torvalds /* Find the current partition number for the drive status. Called from open and 30581da177e4SLinus Torvalds returns either partition number of negative error code. */ 30591da177e4SLinus Torvalds static int find_partition(struct scsi_tape *STp) 30601da177e4SLinus Torvalds { 30611da177e4SLinus Torvalds int i, partition; 30621da177e4SLinus Torvalds unsigned int block; 30631da177e4SLinus Torvalds 30641da177e4SLinus Torvalds if ((i = get_location(STp, &block, &partition, 1)) < 0) 30651da177e4SLinus Torvalds return i; 30661da177e4SLinus Torvalds if (partition >= ST_NBR_PARTITIONS) 30671da177e4SLinus Torvalds return (-EIO); 30681da177e4SLinus Torvalds return partition; 30691da177e4SLinus Torvalds } 30701da177e4SLinus Torvalds 30711da177e4SLinus Torvalds 30721da177e4SLinus Torvalds /* Change the partition if necessary */ 30731da177e4SLinus Torvalds static int switch_partition(struct scsi_tape *STp) 30741da177e4SLinus Torvalds { 30751da177e4SLinus Torvalds struct st_partstat *STps; 30761da177e4SLinus Torvalds 30771da177e4SLinus Torvalds if (STp->partition == STp->new_partition) 30781da177e4SLinus Torvalds return 0; 30791da177e4SLinus Torvalds STps = &(STp->ps[STp->new_partition]); 30801da177e4SLinus Torvalds if (!STps->last_block_valid) 30811da177e4SLinus Torvalds STps->last_block_visited = 0; 30821da177e4SLinus Torvalds return set_location(STp, STps->last_block_visited, STp->new_partition, 1); 30831da177e4SLinus Torvalds } 30841da177e4SLinus Torvalds 30851da177e4SLinus Torvalds /* Functions for reading and writing the medium partition mode page. */ 30861da177e4SLinus Torvalds 30871da177e4SLinus Torvalds #define PART_PAGE 0x11 30881da177e4SLinus Torvalds #define PART_PAGE_FIXED_LENGTH 8 30891da177e4SLinus Torvalds 30901da177e4SLinus Torvalds #define PP_OFF_MAX_ADD_PARTS 2 30911da177e4SLinus Torvalds #define PP_OFF_NBR_ADD_PARTS 3 30921da177e4SLinus Torvalds #define PP_OFF_FLAGS 4 30931da177e4SLinus Torvalds #define PP_OFF_PART_UNITS 6 30941da177e4SLinus Torvalds #define PP_OFF_RESERVED 7 30951da177e4SLinus Torvalds 30961da177e4SLinus Torvalds #define PP_BIT_IDP 0x20 30971da177e4SLinus Torvalds #define PP_MSK_PSUM_MB 0x10 30981da177e4SLinus Torvalds 30991da177e4SLinus Torvalds /* Get the number of partitions on the tape. As a side effect reads the 31001da177e4SLinus Torvalds mode page into the tape buffer. */ 31011da177e4SLinus Torvalds static int nbr_partitions(struct scsi_tape *STp) 31021da177e4SLinus Torvalds { 31031da177e4SLinus Torvalds int result; 31041da177e4SLinus Torvalds DEB( char *name = tape_name(STp); ) 31051da177e4SLinus Torvalds 31061da177e4SLinus Torvalds if (STp->ready != ST_READY) 31071da177e4SLinus Torvalds return (-EIO); 31081da177e4SLinus Torvalds 31091da177e4SLinus Torvalds result = read_mode_page(STp, PART_PAGE, 1); 31101da177e4SLinus Torvalds 31111da177e4SLinus Torvalds if (result) { 31121da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n", 31131da177e4SLinus Torvalds name)); 31141da177e4SLinus Torvalds result = (-EIO); 31151da177e4SLinus Torvalds } else { 31161da177e4SLinus Torvalds result = (STp->buffer)->b_data[MODE_HEADER_LENGTH + 31171da177e4SLinus Torvalds PP_OFF_NBR_ADD_PARTS] + 1; 31181da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result)); 31191da177e4SLinus Torvalds } 31201da177e4SLinus Torvalds 31211da177e4SLinus Torvalds return result; 31221da177e4SLinus Torvalds } 31231da177e4SLinus Torvalds 31241da177e4SLinus Torvalds 31251da177e4SLinus Torvalds /* Partition the tape into two partitions if size > 0 or one partition if 31261da177e4SLinus Torvalds size == 0. 31271da177e4SLinus Torvalds 31281da177e4SLinus Torvalds The block descriptors are read and written because Sony SDT-7000 does not 31291da177e4SLinus Torvalds work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>). 31301da177e4SLinus Torvalds 31311da177e4SLinus Torvalds My HP C1533A drive returns only one partition size field. This is used to 31321da177e4SLinus Torvalds set the size of partition 1. There is no size field for the default partition. 31331da177e4SLinus Torvalds Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is 31341da177e4SLinus Torvalds used to set the size of partition 1 (this is what the SCSI-3 standard specifies). 31351da177e4SLinus Torvalds The following algorithm is used to accommodate both drives: if the number of 31361da177e4SLinus Torvalds partition size fields is greater than the maximum number of additional partitions 31371da177e4SLinus Torvalds in the mode page, the second field is used. Otherwise the first field is used. 31381da177e4SLinus Torvalds 31391da177e4SLinus Torvalds For Seagate DDS drives the page length must be 8 when no partitions is defined 31401da177e4SLinus Torvalds and 10 when 1 partition is defined (information from Eric Lee Green). This is 31411da177e4SLinus Torvalds is acceptable also to some other old drives and enforced if the first partition 31421da177e4SLinus Torvalds size field is used for the first additional partition size. 31431da177e4SLinus Torvalds */ 31441da177e4SLinus Torvalds static int partition_tape(struct scsi_tape *STp, int size) 31451da177e4SLinus Torvalds { 31461da177e4SLinus Torvalds char *name = tape_name(STp); 31471da177e4SLinus Torvalds int result; 31481da177e4SLinus Torvalds int pgo, psd_cnt, psdo; 31491da177e4SLinus Torvalds unsigned char *bp; 31501da177e4SLinus Torvalds 31511da177e4SLinus Torvalds result = read_mode_page(STp, PART_PAGE, 0); 31521da177e4SLinus Torvalds if (result) { 31531da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name)); 31541da177e4SLinus Torvalds return result; 31551da177e4SLinus Torvalds } 31561da177e4SLinus Torvalds /* The mode page is in the buffer. Let's modify it and write it. */ 31571da177e4SLinus Torvalds bp = (STp->buffer)->b_data; 31581da177e4SLinus Torvalds pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH]; 31591da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n", 31601da177e4SLinus Torvalds name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2)); 31611da177e4SLinus Torvalds 31621da177e4SLinus Torvalds psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2; 31631da177e4SLinus Torvalds psdo = pgo + PART_PAGE_FIXED_LENGTH; 31641da177e4SLinus Torvalds if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) { 31651da177e4SLinus Torvalds bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */ 31661da177e4SLinus Torvalds psdo += 2; 31671da177e4SLinus Torvalds } 31681da177e4SLinus Torvalds memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2); 31691da177e4SLinus Torvalds 31701da177e4SLinus Torvalds DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name, 31711da177e4SLinus Torvalds psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS], 31721da177e4SLinus Torvalds bp[pgo + PP_OFF_NBR_ADD_PARTS])); 31731da177e4SLinus Torvalds 31741da177e4SLinus Torvalds if (size <= 0) { 31751da177e4SLinus Torvalds bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0; 31761da177e4SLinus Torvalds if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS]) 31771da177e4SLinus Torvalds bp[pgo + MP_OFF_PAGE_LENGTH] = 6; 31781da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n", 31791da177e4SLinus Torvalds name)); 31801da177e4SLinus Torvalds } else { 31811da177e4SLinus Torvalds bp[psdo] = (size >> 8) & 0xff; 31821da177e4SLinus Torvalds bp[psdo + 1] = size & 0xff; 31831da177e4SLinus Torvalds bp[pgo + 3] = 1; 31841da177e4SLinus Torvalds if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8) 31851da177e4SLinus Torvalds bp[pgo + MP_OFF_PAGE_LENGTH] = 8; 31861da177e4SLinus Torvalds DEBC(printk(ST_DEB_MSG 31871da177e4SLinus Torvalds "%s: Formatting tape with two partitions (1 = %d MB).\n", 31881da177e4SLinus Torvalds name, size)); 31891da177e4SLinus Torvalds } 31901da177e4SLinus Torvalds bp[pgo + PP_OFF_PART_UNITS] = 0; 31911da177e4SLinus Torvalds bp[pgo + PP_OFF_RESERVED] = 0; 31921da177e4SLinus Torvalds bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB; 31931da177e4SLinus Torvalds 31941da177e4SLinus Torvalds result = write_mode_page(STp, PART_PAGE, 1); 31951da177e4SLinus Torvalds if (result) { 31961da177e4SLinus Torvalds printk(KERN_INFO "%s: Partitioning of tape failed.\n", name); 31971da177e4SLinus Torvalds result = (-EIO); 31981da177e4SLinus Torvalds } 31991da177e4SLinus Torvalds 32001da177e4SLinus Torvalds return result; 32011da177e4SLinus Torvalds } 32021da177e4SLinus Torvalds 32031da177e4SLinus Torvalds 32041da177e4SLinus Torvalds 32051da177e4SLinus Torvalds /* The ioctl command */ 32061da177e4SLinus Torvalds static int st_ioctl(struct inode *inode, struct file *file, 32071da177e4SLinus Torvalds unsigned int cmd_in, unsigned long arg) 32081da177e4SLinus Torvalds { 32091da177e4SLinus Torvalds int i, cmd_nr, cmd_type, bt; 32101da177e4SLinus Torvalds int retval = 0; 32111da177e4SLinus Torvalds unsigned int blk; 32121da177e4SLinus Torvalds struct scsi_tape *STp = file->private_data; 32131da177e4SLinus Torvalds struct st_modedef *STm; 32141da177e4SLinus Torvalds struct st_partstat *STps; 32151da177e4SLinus Torvalds char *name = tape_name(STp); 32161da177e4SLinus Torvalds void __user *p = (void __user *)arg; 32171da177e4SLinus Torvalds 32181da177e4SLinus Torvalds if (down_interruptible(&STp->lock)) 32191da177e4SLinus Torvalds return -ERESTARTSYS; 32201da177e4SLinus Torvalds 32211da177e4SLinus Torvalds DEB( 32221da177e4SLinus Torvalds if (debugging && !STp->in_use) { 32231da177e4SLinus Torvalds printk(ST_DEB_MSG "%s: Incorrect device.\n", name); 32241da177e4SLinus Torvalds retval = (-EIO); 32251da177e4SLinus Torvalds goto out; 32261da177e4SLinus Torvalds } ) /* end DEB */ 32271da177e4SLinus Torvalds 32281da177e4SLinus Torvalds STm = &(STp->modes[STp->current_mode]); 32291da177e4SLinus Torvalds STps = &(STp->ps[STp->partition]); 32301da177e4SLinus Torvalds 32311da177e4SLinus Torvalds /* 32321da177e4SLinus Torvalds * If we are in the middle of error recovery, don't let anyone 32331da177e4SLinus Torvalds * else try and use this device. Also, if error recovery fails, it 32341da177e4SLinus Torvalds * may try and take the device offline, in which case all further 32351da177e4SLinus Torvalds * access to the device is prohibited. 32361da177e4SLinus Torvalds */ 32371da177e4SLinus Torvalds retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p, file); 32381da177e4SLinus Torvalds if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV) 32391da177e4SLinus Torvalds goto out; 32401da177e4SLinus Torvalds retval = 0; 32411da177e4SLinus Torvalds 32421da177e4SLinus Torvalds cmd_type = _IOC_TYPE(cmd_in); 32431da177e4SLinus Torvalds cmd_nr = _IOC_NR(cmd_in); 32441da177e4SLinus Torvalds 32451da177e4SLinus Torvalds if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) { 32461da177e4SLinus Torvalds struct mtop mtc; 32471da177e4SLinus Torvalds 32481da177e4SLinus Torvalds if (_IOC_SIZE(cmd_in) != sizeof(mtc)) { 32491da177e4SLinus Torvalds retval = (-EINVAL); 32501da177e4SLinus Torvalds goto out; 32511da177e4SLinus Torvalds } 32521da177e4SLinus Torvalds 32531da177e4SLinus Torvalds i = copy_from_user(&mtc, p, sizeof(struct mtop)); 32541da177e4SLinus Torvalds if (i) { 32551da177e4SLinus Torvalds retval = (-EFAULT); 32561da177e4SLinus Torvalds goto out; 32571da177e4SLinus Torvalds } 32581da177e4SLinus Torvalds 32591da177e4SLinus Torvalds if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) { 32601da177e4SLinus Torvalds printk(KERN_WARNING 32611da177e4SLinus Torvalds "%s: MTSETDRVBUFFER only allowed for root.\n", name); 32621da177e4SLinus Torvalds retval = (-EPERM); 32631da177e4SLinus Torvalds goto out; 32641da177e4SLinus Torvalds } 32651da177e4SLinus Torvalds if (!STm->defined && 32661da177e4SLinus Torvalds (mtc.mt_op != MTSETDRVBUFFER && 32671da177e4SLinus Torvalds (mtc.mt_count & MT_ST_OPTIONS) == 0)) { 32681da177e4SLinus Torvalds retval = (-ENXIO); 32691da177e4SLinus Torvalds goto out; 32701da177e4SLinus Torvalds } 32711da177e4SLinus Torvalds 32721da177e4SLinus Torvalds if (!STp->pos_unknown) { 32731da177e4SLinus Torvalds 32741da177e4SLinus Torvalds if (STps->eof == ST_FM_HIT) { 32751da177e4SLinus Torvalds if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 32761da177e4SLinus Torvalds mtc.mt_op == MTEOM) { 32771da177e4SLinus Torvalds mtc.mt_count -= 1; 32781da177e4SLinus Torvalds if (STps->drv_file >= 0) 32791da177e4SLinus Torvalds STps->drv_file += 1; 32801da177e4SLinus Torvalds } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) { 32811da177e4SLinus Torvalds mtc.mt_count += 1; 32821da177e4SLinus Torvalds if (STps->drv_file >= 0) 32831da177e4SLinus Torvalds STps->drv_file += 1; 32841da177e4SLinus Torvalds } 32851da177e4SLinus Torvalds } 32861da177e4SLinus Torvalds 32871da177e4SLinus Torvalds if (mtc.mt_op == MTSEEK) { 32881da177e4SLinus Torvalds /* Old position must be restored if partition will be 32891da177e4SLinus Torvalds changed */ 32901da177e4SLinus Torvalds i = !STp->can_partitions || 32911da177e4SLinus Torvalds (STp->new_partition != STp->partition); 32921da177e4SLinus Torvalds } else { 32931da177e4SLinus Torvalds i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 32941da177e4SLinus Torvalds mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM || 32951da177e4SLinus Torvalds mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD || 32961da177e4SLinus Torvalds mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 32971da177e4SLinus Torvalds mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM || 32981da177e4SLinus Torvalds mtc.mt_op == MTCOMPRESSION; 32991da177e4SLinus Torvalds } 33001da177e4SLinus Torvalds i = flush_buffer(STp, i); 33011da177e4SLinus Torvalds if (i < 0) { 33021da177e4SLinus Torvalds retval = i; 33031da177e4SLinus Torvalds goto out; 33041da177e4SLinus Torvalds } 33051da177e4SLinus Torvalds if (STps->rw == ST_WRITING && 33061da177e4SLinus Torvalds (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 33071da177e4SLinus Torvalds mtc.mt_op == MTSEEK || 33081da177e4SLinus Torvalds mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) { 33091da177e4SLinus Torvalds i = st_int_ioctl(STp, MTWEOF, 1); 33101da177e4SLinus Torvalds if (i < 0) { 33111da177e4SLinus Torvalds retval = i; 33121da177e4SLinus Torvalds goto out; 33131da177e4SLinus Torvalds } 33141da177e4SLinus Torvalds if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) 33151da177e4SLinus Torvalds mtc.mt_count++; 33161da177e4SLinus Torvalds STps->rw = ST_IDLE; 33171da177e4SLinus Torvalds } 33181da177e4SLinus Torvalds 33191da177e4SLinus Torvalds } else { 33201da177e4SLinus Torvalds /* 33211da177e4SLinus Torvalds * If there was a bus reset, block further access 33221da177e4SLinus Torvalds * to this device. If the user wants to rewind the tape, 33231da177e4SLinus Torvalds * then reset the flag and allow access again. 33241da177e4SLinus Torvalds */ 33251da177e4SLinus Torvalds if (mtc.mt_op != MTREW && 33261da177e4SLinus Torvalds mtc.mt_op != MTOFFL && 33271da177e4SLinus Torvalds mtc.mt_op != MTRETEN && 33281da177e4SLinus Torvalds mtc.mt_op != MTERASE && 33291da177e4SLinus Torvalds mtc.mt_op != MTSEEK && 33301da177e4SLinus Torvalds mtc.mt_op != MTEOM) { 33311da177e4SLinus Torvalds retval = (-EIO); 33321da177e4SLinus Torvalds goto out; 33331da177e4SLinus Torvalds } 33341da177e4SLinus Torvalds reset_state(STp); 33351da177e4SLinus Torvalds /* remove this when the midlevel properly clears was_reset */ 33361da177e4SLinus Torvalds STp->device->was_reset = 0; 33371da177e4SLinus Torvalds } 33381da177e4SLinus Torvalds 33391da177e4SLinus Torvalds if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK && 33401da177e4SLinus Torvalds mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM && 33411da177e4SLinus Torvalds mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART) 33421da177e4SLinus Torvalds STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */ 33431da177e4SLinus Torvalds 33441da177e4SLinus Torvalds if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED) 33451da177e4SLinus Torvalds do_door_lock(STp, 0); /* Ignore result! */ 33461da177e4SLinus Torvalds 33471da177e4SLinus Torvalds if (mtc.mt_op == MTSETDRVBUFFER && 33481da177e4SLinus Torvalds (mtc.mt_count & MT_ST_OPTIONS) != 0) { 33491da177e4SLinus Torvalds retval = st_set_options(STp, mtc.mt_count); 33501da177e4SLinus Torvalds goto out; 33511da177e4SLinus Torvalds } 33521da177e4SLinus Torvalds 33531da177e4SLinus Torvalds if (mtc.mt_op == MTSETPART) { 33541da177e4SLinus Torvalds if (!STp->can_partitions || 33551da177e4SLinus Torvalds mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) { 33561da177e4SLinus Torvalds retval = (-EINVAL); 33571da177e4SLinus Torvalds goto out; 33581da177e4SLinus Torvalds } 33591da177e4SLinus Torvalds if (mtc.mt_count >= STp->nbr_partitions && 33601da177e4SLinus Torvalds (STp->nbr_partitions = nbr_partitions(STp)) < 0) { 33611da177e4SLinus Torvalds retval = (-EIO); 33621da177e4SLinus Torvalds goto out; 33631da177e4SLinus Torvalds } 33641da177e4SLinus Torvalds if (mtc.mt_count >= STp->nbr_partitions) { 33651da177e4SLinus Torvalds retval = (-EINVAL); 33661da177e4SLinus Torvalds goto out; 33671da177e4SLinus Torvalds } 33681da177e4SLinus Torvalds STp->new_partition = mtc.mt_count; 33691da177e4SLinus Torvalds retval = 0; 33701da177e4SLinus Torvalds goto out; 33711da177e4SLinus Torvalds } 33721da177e4SLinus Torvalds 33731da177e4SLinus Torvalds if (mtc.mt_op == MTMKPART) { 33741da177e4SLinus Torvalds if (!STp->can_partitions) { 33751da177e4SLinus Torvalds retval = (-EINVAL); 33761da177e4SLinus Torvalds goto out; 33771da177e4SLinus Torvalds } 33781da177e4SLinus Torvalds if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 || 33791da177e4SLinus Torvalds (i = partition_tape(STp, mtc.mt_count)) < 0) { 33801da177e4SLinus Torvalds retval = i; 33811da177e4SLinus Torvalds goto out; 33821da177e4SLinus Torvalds } 33831da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 33841da177e4SLinus Torvalds STp->ps[i].rw = ST_IDLE; 33851da177e4SLinus Torvalds STp->ps[i].at_sm = 0; 33861da177e4SLinus Torvalds STp->ps[i].last_block_valid = 0; 33871da177e4SLinus Torvalds } 33881da177e4SLinus Torvalds STp->partition = STp->new_partition = 0; 33891da177e4SLinus Torvalds STp->nbr_partitions = 1; /* Bad guess ?-) */ 33901da177e4SLinus Torvalds STps->drv_block = STps->drv_file = 0; 33911da177e4SLinus Torvalds retval = 0; 33921da177e4SLinus Torvalds goto out; 33931da177e4SLinus Torvalds } 33941da177e4SLinus Torvalds 33951da177e4SLinus Torvalds if (mtc.mt_op == MTSEEK) { 33961da177e4SLinus Torvalds i = set_location(STp, mtc.mt_count, STp->new_partition, 0); 33971da177e4SLinus Torvalds if (!STp->can_partitions) 33981da177e4SLinus Torvalds STp->ps[0].rw = ST_IDLE; 33991da177e4SLinus Torvalds retval = i; 34001da177e4SLinus Torvalds goto out; 34011da177e4SLinus Torvalds } 34021da177e4SLinus Torvalds 34031da177e4SLinus Torvalds if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) { 34041da177e4SLinus Torvalds retval = do_load_unload(STp, file, 0); 34051da177e4SLinus Torvalds goto out; 34061da177e4SLinus Torvalds } 34071da177e4SLinus Torvalds 34081da177e4SLinus Torvalds if (mtc.mt_op == MTLOAD) { 34091da177e4SLinus Torvalds retval = do_load_unload(STp, file, max(1, mtc.mt_count)); 34101da177e4SLinus Torvalds goto out; 34111da177e4SLinus Torvalds } 34121da177e4SLinus Torvalds 34131da177e4SLinus Torvalds if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) { 34141da177e4SLinus Torvalds retval = do_door_lock(STp, (mtc.mt_op == MTLOCK)); 34151da177e4SLinus Torvalds goto out; 34161da177e4SLinus Torvalds } 34171da177e4SLinus Torvalds 34181da177e4SLinus Torvalds if (STp->can_partitions && STp->ready == ST_READY && 34191da177e4SLinus Torvalds (i = switch_partition(STp)) < 0) { 34201da177e4SLinus Torvalds retval = i; 34211da177e4SLinus Torvalds goto out; 34221da177e4SLinus Torvalds } 34231da177e4SLinus Torvalds 34241da177e4SLinus Torvalds if (mtc.mt_op == MTCOMPRESSION) 34251da177e4SLinus Torvalds retval = st_compression(STp, (mtc.mt_count & 1)); 34261da177e4SLinus Torvalds else 34271da177e4SLinus Torvalds retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count); 34281da177e4SLinus Torvalds goto out; 34291da177e4SLinus Torvalds } 34301da177e4SLinus Torvalds if (!STm->defined) { 34311da177e4SLinus Torvalds retval = (-ENXIO); 34321da177e4SLinus Torvalds goto out; 34331da177e4SLinus Torvalds } 34341da177e4SLinus Torvalds 34351da177e4SLinus Torvalds if ((i = flush_buffer(STp, 0)) < 0) { 34361da177e4SLinus Torvalds retval = i; 34371da177e4SLinus Torvalds goto out; 34381da177e4SLinus Torvalds } 34391da177e4SLinus Torvalds if (STp->can_partitions && 34401da177e4SLinus Torvalds (i = switch_partition(STp)) < 0) { 34411da177e4SLinus Torvalds retval = i; 34421da177e4SLinus Torvalds goto out; 34431da177e4SLinus Torvalds } 34441da177e4SLinus Torvalds 34451da177e4SLinus Torvalds if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) { 34461da177e4SLinus Torvalds struct mtget mt_status; 34471da177e4SLinus Torvalds 34481da177e4SLinus Torvalds if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) { 34491da177e4SLinus Torvalds retval = (-EINVAL); 34501da177e4SLinus Torvalds goto out; 34511da177e4SLinus Torvalds } 34521da177e4SLinus Torvalds 34531da177e4SLinus Torvalds mt_status.mt_type = STp->tape_type; 34541da177e4SLinus Torvalds mt_status.mt_dsreg = 34551da177e4SLinus Torvalds ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) | 34561da177e4SLinus Torvalds ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK); 34571da177e4SLinus Torvalds mt_status.mt_blkno = STps->drv_block; 34581da177e4SLinus Torvalds mt_status.mt_fileno = STps->drv_file; 34591da177e4SLinus Torvalds if (STp->block_size != 0) { 34601da177e4SLinus Torvalds if (STps->rw == ST_WRITING) 34611da177e4SLinus Torvalds mt_status.mt_blkno += 34621da177e4SLinus Torvalds (STp->buffer)->buffer_bytes / STp->block_size; 34631da177e4SLinus Torvalds else if (STps->rw == ST_READING) 34641da177e4SLinus Torvalds mt_status.mt_blkno -= 34651da177e4SLinus Torvalds ((STp->buffer)->buffer_bytes + 34661da177e4SLinus Torvalds STp->block_size - 1) / STp->block_size; 34671da177e4SLinus Torvalds } 34681da177e4SLinus Torvalds 34691da177e4SLinus Torvalds mt_status.mt_gstat = 0; 34701da177e4SLinus Torvalds if (STp->drv_write_prot) 34711da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff); 34721da177e4SLinus Torvalds if (mt_status.mt_blkno == 0) { 34731da177e4SLinus Torvalds if (mt_status.mt_fileno == 0) 34741da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_BOT(0xffffffff); 34751da177e4SLinus Torvalds else 34761da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_EOF(0xffffffff); 34771da177e4SLinus Torvalds } 34781da177e4SLinus Torvalds mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT); 34791da177e4SLinus Torvalds mt_status.mt_resid = STp->partition; 34801da177e4SLinus Torvalds if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR) 34811da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_EOT(0xffffffff); 34821da177e4SLinus Torvalds else if (STps->eof >= ST_EOM_OK) 34831da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_EOD(0xffffffff); 34841da177e4SLinus Torvalds if (STp->density == 1) 34851da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_D_800(0xffffffff); 34861da177e4SLinus Torvalds else if (STp->density == 2) 34871da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_D_1600(0xffffffff); 34881da177e4SLinus Torvalds else if (STp->density == 3) 34891da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_D_6250(0xffffffff); 34901da177e4SLinus Torvalds if (STp->ready == ST_READY) 34911da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_ONLINE(0xffffffff); 34921da177e4SLinus Torvalds if (STp->ready == ST_NO_TAPE) 34931da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff); 34941da177e4SLinus Torvalds if (STps->at_sm) 34951da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_SM(0xffffffff); 34961da177e4SLinus Torvalds if (STm->do_async_writes || 34971da177e4SLinus Torvalds (STm->do_buffer_writes && STp->block_size != 0) || 34981da177e4SLinus Torvalds STp->drv_buffer != 0) 34991da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff); 35001da177e4SLinus Torvalds if (STp->cleaning_req) 35011da177e4SLinus Torvalds mt_status.mt_gstat |= GMT_CLN(0xffffffff); 35021da177e4SLinus Torvalds 35031da177e4SLinus Torvalds i = copy_to_user(p, &mt_status, sizeof(struct mtget)); 35041da177e4SLinus Torvalds if (i) { 35051da177e4SLinus Torvalds retval = (-EFAULT); 35061da177e4SLinus Torvalds goto out; 35071da177e4SLinus Torvalds } 35081da177e4SLinus Torvalds 35091da177e4SLinus Torvalds STp->recover_reg = 0; /* Clear after read */ 35101da177e4SLinus Torvalds retval = 0; 35111da177e4SLinus Torvalds goto out; 35121da177e4SLinus Torvalds } /* End of MTIOCGET */ 35131da177e4SLinus Torvalds if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) { 35141da177e4SLinus Torvalds struct mtpos mt_pos; 35151da177e4SLinus Torvalds if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) { 35161da177e4SLinus Torvalds retval = (-EINVAL); 35171da177e4SLinus Torvalds goto out; 35181da177e4SLinus Torvalds } 35191da177e4SLinus Torvalds if ((i = get_location(STp, &blk, &bt, 0)) < 0) { 35201da177e4SLinus Torvalds retval = i; 35211da177e4SLinus Torvalds goto out; 35221da177e4SLinus Torvalds } 35231da177e4SLinus Torvalds mt_pos.mt_blkno = blk; 35241da177e4SLinus Torvalds i = copy_to_user(p, &mt_pos, sizeof(struct mtpos)); 35251da177e4SLinus Torvalds if (i) 35261da177e4SLinus Torvalds retval = (-EFAULT); 35271da177e4SLinus Torvalds goto out; 35281da177e4SLinus Torvalds } 35291da177e4SLinus Torvalds up(&STp->lock); 35301da177e4SLinus Torvalds switch (cmd_in) { 35311da177e4SLinus Torvalds case SCSI_IOCTL_GET_IDLUN: 35321da177e4SLinus Torvalds case SCSI_IOCTL_GET_BUS_NUMBER: 35331da177e4SLinus Torvalds break; 35341da177e4SLinus Torvalds default: 353516c4b3e2SKai Makisara if ((cmd_in == SG_IO || 353616c4b3e2SKai Makisara cmd_in == SCSI_IOCTL_SEND_COMMAND || 353716c4b3e2SKai Makisara cmd_in == CDROM_SEND_PACKET) && 353816c4b3e2SKai Makisara !capable(CAP_SYS_RAWIO)) 35391da177e4SLinus Torvalds i = -EPERM; 35401da177e4SLinus Torvalds else 35411da177e4SLinus Torvalds i = scsi_cmd_ioctl(file, STp->disk, cmd_in, p); 35421da177e4SLinus Torvalds if (i != -ENOTTY) 35431da177e4SLinus Torvalds return i; 35441da177e4SLinus Torvalds break; 35451da177e4SLinus Torvalds } 354616c4b3e2SKai Makisara retval = scsi_ioctl(STp->device, cmd_in, p); 354716c4b3e2SKai Makisara if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */ 354816c4b3e2SKai Makisara STp->rew_at_close = 0; 354916c4b3e2SKai Makisara STp->ready = ST_NO_TAPE; 355016c4b3e2SKai Makisara } 355116c4b3e2SKai Makisara return retval; 35521da177e4SLinus Torvalds 35531da177e4SLinus Torvalds out: 35541da177e4SLinus Torvalds up(&STp->lock); 35551da177e4SLinus Torvalds return retval; 35561da177e4SLinus Torvalds } 35571da177e4SLinus Torvalds 35581da177e4SLinus Torvalds #ifdef CONFIG_COMPAT 35591da177e4SLinus Torvalds static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 35601da177e4SLinus Torvalds { 35611da177e4SLinus Torvalds struct scsi_tape *STp = file->private_data; 35621da177e4SLinus Torvalds struct scsi_device *sdev = STp->device; 35631da177e4SLinus Torvalds int ret = -ENOIOCTLCMD; 35641da177e4SLinus Torvalds if (sdev->host->hostt->compat_ioctl) { 35651da177e4SLinus Torvalds 35661da177e4SLinus Torvalds ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg); 35671da177e4SLinus Torvalds 35681da177e4SLinus Torvalds } 35691da177e4SLinus Torvalds return ret; 35701da177e4SLinus Torvalds } 35711da177e4SLinus Torvalds #endif 35721da177e4SLinus Torvalds 35731da177e4SLinus Torvalds 35741da177e4SLinus Torvalds 35751da177e4SLinus Torvalds /* Try to allocate a new tape buffer. Calling function must not hold 35761da177e4SLinus Torvalds dev_arr_lock. */ 35771da177e4SLinus Torvalds static struct st_buffer * 35781da177e4SLinus Torvalds new_tape_buffer(int from_initialization, int need_dma, int max_sg) 35791da177e4SLinus Torvalds { 35801da177e4SLinus Torvalds int i, priority, got = 0, segs = 0; 35811da177e4SLinus Torvalds struct st_buffer *tb; 35821da177e4SLinus Torvalds 35831da177e4SLinus Torvalds if (from_initialization) 35841da177e4SLinus Torvalds priority = GFP_ATOMIC; 35851da177e4SLinus Torvalds else 35861da177e4SLinus Torvalds priority = GFP_KERNEL; 35871da177e4SLinus Torvalds 35881da177e4SLinus Torvalds i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) + 35891da177e4SLinus Torvalds max_sg * sizeof(struct st_buf_fragment); 35901da177e4SLinus Torvalds tb = kmalloc(i, priority); 35911da177e4SLinus Torvalds if (!tb) { 35921da177e4SLinus Torvalds printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n"); 35931da177e4SLinus Torvalds return NULL; 35941da177e4SLinus Torvalds } 35951da177e4SLinus Torvalds memset(tb, 0, i); 35961da177e4SLinus Torvalds tb->frp_segs = tb->orig_frp_segs = segs; 35971da177e4SLinus Torvalds tb->use_sg = max_sg; 35981da177e4SLinus Torvalds if (segs > 0) 35991da177e4SLinus Torvalds tb->b_data = page_address(tb->sg[0].page); 36001da177e4SLinus Torvalds tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg); 36011da177e4SLinus Torvalds 36021da177e4SLinus Torvalds tb->in_use = 1; 36031da177e4SLinus Torvalds tb->dma = need_dma; 36041da177e4SLinus Torvalds tb->buffer_size = got; 36051da177e4SLinus Torvalds 36061da177e4SLinus Torvalds return tb; 36071da177e4SLinus Torvalds } 36081da177e4SLinus Torvalds 36091da177e4SLinus Torvalds 36101da177e4SLinus Torvalds /* Try to allocate enough space in the tape buffer */ 36111da177e4SLinus Torvalds static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma) 36121da177e4SLinus Torvalds { 36131da177e4SLinus Torvalds int segs, nbr, max_segs, b_size, priority, order, got; 36141da177e4SLinus Torvalds 36151da177e4SLinus Torvalds if (new_size <= STbuffer->buffer_size) 36161da177e4SLinus Torvalds return 1; 36171da177e4SLinus Torvalds 36181da177e4SLinus Torvalds if (STbuffer->buffer_size <= PAGE_SIZE) 36191da177e4SLinus Torvalds normalize_buffer(STbuffer); /* Avoid extra segment */ 36201da177e4SLinus Torvalds 36211da177e4SLinus Torvalds max_segs = STbuffer->use_sg; 36221da177e4SLinus Torvalds nbr = max_segs - STbuffer->frp_segs; 36231da177e4SLinus Torvalds if (nbr <= 0) 36241da177e4SLinus Torvalds return 0; 36251da177e4SLinus Torvalds 36261da177e4SLinus Torvalds priority = GFP_KERNEL | __GFP_NOWARN; 36271da177e4SLinus Torvalds if (need_dma) 36281da177e4SLinus Torvalds priority |= GFP_DMA; 36291da177e4SLinus Torvalds for (b_size = PAGE_SIZE, order=0; 36301da177e4SLinus Torvalds b_size < new_size - STbuffer->buffer_size; 36311da177e4SLinus Torvalds order++, b_size *= 2) 36321da177e4SLinus Torvalds ; /* empty */ 36331da177e4SLinus Torvalds 36341da177e4SLinus Torvalds for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size; 36351da177e4SLinus Torvalds segs < max_segs && got < new_size;) { 36361da177e4SLinus Torvalds STbuffer->frp[segs].page = alloc_pages(priority, order); 36371da177e4SLinus Torvalds if (STbuffer->frp[segs].page == NULL) { 36381da177e4SLinus Torvalds if (new_size - got <= (max_segs - segs) * b_size / 2) { 36391da177e4SLinus Torvalds b_size /= 2; /* Large enough for the rest of the buffers */ 36401da177e4SLinus Torvalds order--; 36411da177e4SLinus Torvalds continue; 36421da177e4SLinus Torvalds } 36431da177e4SLinus Torvalds DEB(STbuffer->buffer_size = got); 36441da177e4SLinus Torvalds normalize_buffer(STbuffer); 36451da177e4SLinus Torvalds return 0; 36461da177e4SLinus Torvalds } 36471da177e4SLinus Torvalds STbuffer->frp[segs].length = b_size; 36481da177e4SLinus Torvalds STbuffer->frp_segs += 1; 36491da177e4SLinus Torvalds got += b_size; 36501da177e4SLinus Torvalds STbuffer->buffer_size = got; 36511da177e4SLinus Torvalds segs++; 36521da177e4SLinus Torvalds } 36531da177e4SLinus Torvalds STbuffer->b_data = page_address(STbuffer->frp[0].page); 36541da177e4SLinus Torvalds 36551da177e4SLinus Torvalds return 1; 36561da177e4SLinus Torvalds } 36571da177e4SLinus Torvalds 36581da177e4SLinus Torvalds 36591da177e4SLinus Torvalds /* Release the extra buffer */ 36601da177e4SLinus Torvalds static void normalize_buffer(struct st_buffer * STbuffer) 36611da177e4SLinus Torvalds { 36621da177e4SLinus Torvalds int i, order; 36631da177e4SLinus Torvalds 36641da177e4SLinus Torvalds for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) { 36651da177e4SLinus Torvalds order = get_order(STbuffer->frp[i].length); 36661da177e4SLinus Torvalds __free_pages(STbuffer->frp[i].page, order); 36671da177e4SLinus Torvalds STbuffer->buffer_size -= STbuffer->frp[i].length; 36681da177e4SLinus Torvalds } 36691da177e4SLinus Torvalds STbuffer->frp_segs = STbuffer->orig_frp_segs; 36701da177e4SLinus Torvalds STbuffer->frp_sg_current = 0; 36711da177e4SLinus Torvalds } 36721da177e4SLinus Torvalds 36731da177e4SLinus Torvalds 36741da177e4SLinus Torvalds /* Move data from the user buffer to the tape buffer. Returns zero (success) or 36751da177e4SLinus Torvalds negative error code. */ 36761da177e4SLinus Torvalds static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count) 36771da177e4SLinus Torvalds { 36781da177e4SLinus Torvalds int i, cnt, res, offset; 36791da177e4SLinus Torvalds 36801da177e4SLinus Torvalds for (i = 0, offset = st_bp->buffer_bytes; 36811da177e4SLinus Torvalds i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++) 36821da177e4SLinus Torvalds offset -= st_bp->frp[i].length; 36831da177e4SLinus Torvalds if (i == st_bp->frp_segs) { /* Should never happen */ 36841da177e4SLinus Torvalds printk(KERN_WARNING "st: append_to_buffer offset overflow.\n"); 36851da177e4SLinus Torvalds return (-EIO); 36861da177e4SLinus Torvalds } 36871da177e4SLinus Torvalds for (; i < st_bp->frp_segs && do_count > 0; i++) { 36881da177e4SLinus Torvalds cnt = st_bp->frp[i].length - offset < do_count ? 36891da177e4SLinus Torvalds st_bp->frp[i].length - offset : do_count; 36901da177e4SLinus Torvalds res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt); 36911da177e4SLinus Torvalds if (res) 36921da177e4SLinus Torvalds return (-EFAULT); 36931da177e4SLinus Torvalds do_count -= cnt; 36941da177e4SLinus Torvalds st_bp->buffer_bytes += cnt; 36951da177e4SLinus Torvalds ubp += cnt; 36961da177e4SLinus Torvalds offset = 0; 36971da177e4SLinus Torvalds } 36981da177e4SLinus Torvalds if (do_count) /* Should never happen */ 36991da177e4SLinus Torvalds return (-EIO); 37001da177e4SLinus Torvalds 37011da177e4SLinus Torvalds return 0; 37021da177e4SLinus Torvalds } 37031da177e4SLinus Torvalds 37041da177e4SLinus Torvalds 37051da177e4SLinus Torvalds /* Move data from the tape buffer to the user buffer. Returns zero (success) or 37061da177e4SLinus Torvalds negative error code. */ 37071da177e4SLinus Torvalds static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count) 37081da177e4SLinus Torvalds { 37091da177e4SLinus Torvalds int i, cnt, res, offset; 37101da177e4SLinus Torvalds 37111da177e4SLinus Torvalds for (i = 0, offset = st_bp->read_pointer; 37121da177e4SLinus Torvalds i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++) 37131da177e4SLinus Torvalds offset -= st_bp->frp[i].length; 37141da177e4SLinus Torvalds if (i == st_bp->frp_segs) { /* Should never happen */ 37151da177e4SLinus Torvalds printk(KERN_WARNING "st: from_buffer offset overflow.\n"); 37161da177e4SLinus Torvalds return (-EIO); 37171da177e4SLinus Torvalds } 37181da177e4SLinus Torvalds for (; i < st_bp->frp_segs && do_count > 0; i++) { 37191da177e4SLinus Torvalds cnt = st_bp->frp[i].length - offset < do_count ? 37201da177e4SLinus Torvalds st_bp->frp[i].length - offset : do_count; 37211da177e4SLinus Torvalds res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt); 37221da177e4SLinus Torvalds if (res) 37231da177e4SLinus Torvalds return (-EFAULT); 37241da177e4SLinus Torvalds do_count -= cnt; 37251da177e4SLinus Torvalds st_bp->buffer_bytes -= cnt; 37261da177e4SLinus Torvalds st_bp->read_pointer += cnt; 37271da177e4SLinus Torvalds ubp += cnt; 37281da177e4SLinus Torvalds offset = 0; 37291da177e4SLinus Torvalds } 37301da177e4SLinus Torvalds if (do_count) /* Should never happen */ 37311da177e4SLinus Torvalds return (-EIO); 37321da177e4SLinus Torvalds 37331da177e4SLinus Torvalds return 0; 37341da177e4SLinus Torvalds } 37351da177e4SLinus Torvalds 37361da177e4SLinus Torvalds 37371da177e4SLinus Torvalds /* Move data towards start of buffer */ 37381da177e4SLinus Torvalds static void move_buffer_data(struct st_buffer * st_bp, int offset) 37391da177e4SLinus Torvalds { 37401da177e4SLinus Torvalds int src_seg, dst_seg, src_offset = 0, dst_offset; 37411da177e4SLinus Torvalds int count, total; 37421da177e4SLinus Torvalds 37431da177e4SLinus Torvalds if (offset == 0) 37441da177e4SLinus Torvalds return; 37451da177e4SLinus Torvalds 37461da177e4SLinus Torvalds total=st_bp->buffer_bytes - offset; 37471da177e4SLinus Torvalds for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) { 37481da177e4SLinus Torvalds src_offset = offset; 37491da177e4SLinus Torvalds if (src_offset < st_bp->frp[src_seg].length) 37501da177e4SLinus Torvalds break; 37511da177e4SLinus Torvalds offset -= st_bp->frp[src_seg].length; 37521da177e4SLinus Torvalds } 37531da177e4SLinus Torvalds 37541da177e4SLinus Torvalds st_bp->buffer_bytes = st_bp->read_pointer = total; 37551da177e4SLinus Torvalds for (dst_seg=dst_offset=0; total > 0; ) { 37561da177e4SLinus Torvalds count = min(st_bp->frp[dst_seg].length - dst_offset, 37571da177e4SLinus Torvalds st_bp->frp[src_seg].length - src_offset); 37581da177e4SLinus Torvalds memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset, 37591da177e4SLinus Torvalds page_address(st_bp->frp[src_seg].page) + src_offset, count); 37601da177e4SLinus Torvalds src_offset += count; 37611da177e4SLinus Torvalds if (src_offset >= st_bp->frp[src_seg].length) { 37621da177e4SLinus Torvalds src_seg++; 37631da177e4SLinus Torvalds src_offset = 0; 37641da177e4SLinus Torvalds } 37651da177e4SLinus Torvalds dst_offset += count; 37661da177e4SLinus Torvalds if (dst_offset >= st_bp->frp[dst_seg].length) { 37671da177e4SLinus Torvalds dst_seg++; 37681da177e4SLinus Torvalds dst_offset = 0; 37691da177e4SLinus Torvalds } 37701da177e4SLinus Torvalds total -= count; 37711da177e4SLinus Torvalds } 37721da177e4SLinus Torvalds } 37731da177e4SLinus Torvalds 37741da177e4SLinus Torvalds 37751da177e4SLinus Torvalds /* Fill the s/g list up to the length required for this transfer */ 37761da177e4SLinus Torvalds static void buf_to_sg(struct st_buffer *STbp, unsigned int length) 37771da177e4SLinus Torvalds { 37781da177e4SLinus Torvalds int i; 37791da177e4SLinus Torvalds unsigned int count; 37801da177e4SLinus Torvalds struct scatterlist *sg; 37811da177e4SLinus Torvalds struct st_buf_fragment *frp; 37821da177e4SLinus Torvalds 37831da177e4SLinus Torvalds if (length == STbp->frp_sg_current) 37841da177e4SLinus Torvalds return; /* work already done */ 37851da177e4SLinus Torvalds 37861da177e4SLinus Torvalds sg = &(STbp->sg[0]); 37871da177e4SLinus Torvalds frp = STbp->frp; 37881da177e4SLinus Torvalds for (i=count=0; count < length; i++) { 37891da177e4SLinus Torvalds sg[i].page = frp[i].page; 37901da177e4SLinus Torvalds if (length - count > frp[i].length) 37911da177e4SLinus Torvalds sg[i].length = frp[i].length; 37921da177e4SLinus Torvalds else 37931da177e4SLinus Torvalds sg[i].length = length - count; 37941da177e4SLinus Torvalds count += sg[i].length; 37951da177e4SLinus Torvalds sg[i].offset = 0; 37961da177e4SLinus Torvalds } 37971da177e4SLinus Torvalds STbp->sg_segs = i; 37981da177e4SLinus Torvalds STbp->frp_sg_current = length; 37991da177e4SLinus Torvalds } 38001da177e4SLinus Torvalds 38011da177e4SLinus Torvalds 38021da177e4SLinus Torvalds /* Validate the options from command line or module parameters */ 38031da177e4SLinus Torvalds static void validate_options(void) 38041da177e4SLinus Torvalds { 38051da177e4SLinus Torvalds if (buffer_kbs > 0) 38061da177e4SLinus Torvalds st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE; 38071da177e4SLinus Torvalds if (max_sg_segs >= ST_FIRST_SG) 38081da177e4SLinus Torvalds st_max_sg_segs = max_sg_segs; 38091da177e4SLinus Torvalds } 38101da177e4SLinus Torvalds 38111da177e4SLinus Torvalds #ifndef MODULE 38121da177e4SLinus Torvalds /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt. 38131da177e4SLinus Torvalds */ 38141da177e4SLinus Torvalds static int __init st_setup(char *str) 38151da177e4SLinus Torvalds { 38161da177e4SLinus Torvalds int i, len, ints[5]; 38171da177e4SLinus Torvalds char *stp; 38181da177e4SLinus Torvalds 38191da177e4SLinus Torvalds stp = get_options(str, ARRAY_SIZE(ints), ints); 38201da177e4SLinus Torvalds 38211da177e4SLinus Torvalds if (ints[0] > 0) { 38221da177e4SLinus Torvalds for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++) 38231da177e4SLinus Torvalds if (parms[i].val) 38241da177e4SLinus Torvalds *parms[i].val = ints[i + 1]; 38251da177e4SLinus Torvalds } else { 38261da177e4SLinus Torvalds while (stp != NULL) { 38271da177e4SLinus Torvalds for (i = 0; i < ARRAY_SIZE(parms); i++) { 38281da177e4SLinus Torvalds len = strlen(parms[i].name); 38291da177e4SLinus Torvalds if (!strncmp(stp, parms[i].name, len) && 38301da177e4SLinus Torvalds (*(stp + len) == ':' || *(stp + len) == '=')) { 38311da177e4SLinus Torvalds if (parms[i].val) 38321da177e4SLinus Torvalds *parms[i].val = 38331da177e4SLinus Torvalds simple_strtoul(stp + len + 1, NULL, 0); 38341da177e4SLinus Torvalds else 38351da177e4SLinus Torvalds printk(KERN_WARNING "st: Obsolete parameter %s\n", 38361da177e4SLinus Torvalds parms[i].name); 38371da177e4SLinus Torvalds break; 38381da177e4SLinus Torvalds } 38391da177e4SLinus Torvalds } 38401da177e4SLinus Torvalds if (i >= sizeof(parms) / sizeof(struct st_dev_parm)) 38411da177e4SLinus Torvalds printk(KERN_WARNING "st: invalid parameter in '%s'\n", 38421da177e4SLinus Torvalds stp); 38431da177e4SLinus Torvalds stp = strchr(stp, ','); 38441da177e4SLinus Torvalds if (stp) 38451da177e4SLinus Torvalds stp++; 38461da177e4SLinus Torvalds } 38471da177e4SLinus Torvalds } 38481da177e4SLinus Torvalds 38491da177e4SLinus Torvalds validate_options(); 38501da177e4SLinus Torvalds 38511da177e4SLinus Torvalds return 1; 38521da177e4SLinus Torvalds } 38531da177e4SLinus Torvalds 38541da177e4SLinus Torvalds __setup("st=", st_setup); 38551da177e4SLinus Torvalds 38561da177e4SLinus Torvalds #endif 38571da177e4SLinus Torvalds 38581da177e4SLinus Torvalds static struct file_operations st_fops = 38591da177e4SLinus Torvalds { 38601da177e4SLinus Torvalds .owner = THIS_MODULE, 38611da177e4SLinus Torvalds .read = st_read, 38621da177e4SLinus Torvalds .write = st_write, 38631da177e4SLinus Torvalds .ioctl = st_ioctl, 38641da177e4SLinus Torvalds #ifdef CONFIG_COMPAT 38651da177e4SLinus Torvalds .compat_ioctl = st_compat_ioctl, 38661da177e4SLinus Torvalds #endif 38671da177e4SLinus Torvalds .open = st_open, 38681da177e4SLinus Torvalds .flush = st_flush, 38691da177e4SLinus Torvalds .release = st_release, 38701da177e4SLinus Torvalds }; 38711da177e4SLinus Torvalds 38721da177e4SLinus Torvalds static int st_probe(struct device *dev) 38731da177e4SLinus Torvalds { 38741da177e4SLinus Torvalds struct scsi_device *SDp = to_scsi_device(dev); 38751da177e4SLinus Torvalds struct gendisk *disk = NULL; 38761da177e4SLinus Torvalds struct cdev *cdev = NULL; 38771da177e4SLinus Torvalds struct scsi_tape *tpnt = NULL; 38781da177e4SLinus Torvalds struct st_modedef *STm; 38791da177e4SLinus Torvalds struct st_partstat *STps; 38801da177e4SLinus Torvalds struct st_buffer *buffer; 38811da177e4SLinus Torvalds int i, j, mode, dev_num, error; 38821da177e4SLinus Torvalds char *stp; 38831da177e4SLinus Torvalds u64 bounce_limit; 38841da177e4SLinus Torvalds 38851da177e4SLinus Torvalds if (SDp->type != TYPE_TAPE) 38861da177e4SLinus Torvalds return -ENODEV; 38871da177e4SLinus Torvalds if ((stp = st_incompatible(SDp))) { 38881da177e4SLinus Torvalds printk(KERN_INFO 38891da177e4SLinus Torvalds "st: Found incompatible tape at scsi%d, channel %d, id %d, lun %d\n", 38901da177e4SLinus Torvalds SDp->host->host_no, SDp->channel, SDp->id, SDp->lun); 38911da177e4SLinus Torvalds printk(KERN_INFO "st: The suggested driver is %s.\n", stp); 38921da177e4SLinus Torvalds return -ENODEV; 38931da177e4SLinus Torvalds } 38941da177e4SLinus Torvalds 38951da177e4SLinus Torvalds i = SDp->host->sg_tablesize; 38961da177e4SLinus Torvalds if (st_max_sg_segs < i) 38971da177e4SLinus Torvalds i = st_max_sg_segs; 38981da177e4SLinus Torvalds buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i); 38991da177e4SLinus Torvalds if (buffer == NULL) { 39001da177e4SLinus Torvalds printk(KERN_ERR 39011da177e4SLinus Torvalds "st: Can't allocate new tape buffer. Device not attached.\n"); 39021da177e4SLinus Torvalds goto out; 39031da177e4SLinus Torvalds } 39041da177e4SLinus Torvalds 39051da177e4SLinus Torvalds disk = alloc_disk(1); 39061da177e4SLinus Torvalds if (!disk) { 39071da177e4SLinus Torvalds printk(KERN_ERR "st: out of memory. Device not attached.\n"); 39081da177e4SLinus Torvalds goto out_buffer_free; 39091da177e4SLinus Torvalds } 39101da177e4SLinus Torvalds 39111da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 39121da177e4SLinus Torvalds if (st_nr_dev >= st_dev_max) { 39131da177e4SLinus Torvalds struct scsi_tape **tmp_da; 39141da177e4SLinus Torvalds int tmp_dev_max; 39151da177e4SLinus Torvalds 39161da177e4SLinus Torvalds tmp_dev_max = max(st_nr_dev * 2, 8); 39171da177e4SLinus Torvalds if (tmp_dev_max > ST_MAX_TAPES) 39181da177e4SLinus Torvalds tmp_dev_max = ST_MAX_TAPES; 39191da177e4SLinus Torvalds if (tmp_dev_max <= st_nr_dev) { 39201da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 39211da177e4SLinus Torvalds printk(KERN_ERR "st: Too many tape devices (max. %d).\n", 39221da177e4SLinus Torvalds ST_MAX_TAPES); 39231da177e4SLinus Torvalds goto out_put_disk; 39241da177e4SLinus Torvalds } 39251da177e4SLinus Torvalds 39261da177e4SLinus Torvalds tmp_da = kmalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC); 39271da177e4SLinus Torvalds if (tmp_da == NULL) { 39281da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 39291da177e4SLinus Torvalds printk(KERN_ERR "st: Can't extend device array.\n"); 39301da177e4SLinus Torvalds goto out_put_disk; 39311da177e4SLinus Torvalds } 39321da177e4SLinus Torvalds 39331da177e4SLinus Torvalds memset(tmp_da, 0, tmp_dev_max * sizeof(struct scsi_tape *)); 39341da177e4SLinus Torvalds if (scsi_tapes != NULL) { 39351da177e4SLinus Torvalds memcpy(tmp_da, scsi_tapes, 39361da177e4SLinus Torvalds st_dev_max * sizeof(struct scsi_tape *)); 39371da177e4SLinus Torvalds kfree(scsi_tapes); 39381da177e4SLinus Torvalds } 39391da177e4SLinus Torvalds scsi_tapes = tmp_da; 39401da177e4SLinus Torvalds 39411da177e4SLinus Torvalds st_dev_max = tmp_dev_max; 39421da177e4SLinus Torvalds } 39431da177e4SLinus Torvalds 39441da177e4SLinus Torvalds for (i = 0; i < st_dev_max; i++) 39451da177e4SLinus Torvalds if (scsi_tapes[i] == NULL) 39461da177e4SLinus Torvalds break; 39471da177e4SLinus Torvalds if (i >= st_dev_max) 39481da177e4SLinus Torvalds panic("scsi_devices corrupt (st)"); 39491da177e4SLinus Torvalds 39501da177e4SLinus Torvalds tpnt = kmalloc(sizeof(struct scsi_tape), GFP_ATOMIC); 39511da177e4SLinus Torvalds if (tpnt == NULL) { 39521da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 39531da177e4SLinus Torvalds printk(KERN_ERR "st: Can't allocate device descriptor.\n"); 39541da177e4SLinus Torvalds goto out_put_disk; 39551da177e4SLinus Torvalds } 39561da177e4SLinus Torvalds memset(tpnt, 0, sizeof(struct scsi_tape)); 3957f03a5670SKai Makisara kref_init(&tpnt->kref); 39581da177e4SLinus Torvalds tpnt->disk = disk; 39591da177e4SLinus Torvalds sprintf(disk->disk_name, "st%d", i); 39601da177e4SLinus Torvalds disk->private_data = &tpnt->driver; 39611da177e4SLinus Torvalds disk->queue = SDp->request_queue; 39621da177e4SLinus Torvalds tpnt->driver = &st_template; 39631da177e4SLinus Torvalds scsi_tapes[i] = tpnt; 39641da177e4SLinus Torvalds dev_num = i; 39651da177e4SLinus Torvalds 39661da177e4SLinus Torvalds tpnt->device = SDp; 39671da177e4SLinus Torvalds if (SDp->scsi_level <= 2) 39681da177e4SLinus Torvalds tpnt->tape_type = MT_ISSCSI1; 39691da177e4SLinus Torvalds else 39701da177e4SLinus Torvalds tpnt->tape_type = MT_ISSCSI2; 39711da177e4SLinus Torvalds 39721da177e4SLinus Torvalds tpnt->buffer = buffer; 3973f03a5670SKai Makisara tpnt->buffer->last_SRpnt = NULL; 39741da177e4SLinus Torvalds 39751da177e4SLinus Torvalds tpnt->inited = 0; 39761da177e4SLinus Torvalds tpnt->dirty = 0; 39771da177e4SLinus Torvalds tpnt->in_use = 0; 39781da177e4SLinus Torvalds tpnt->drv_buffer = 1; /* Try buffering if no mode sense */ 39791da177e4SLinus Torvalds tpnt->restr_dma = (SDp->host)->unchecked_isa_dma; 39801da177e4SLinus Torvalds tpnt->use_pf = (SDp->scsi_level >= SCSI_2); 39811da177e4SLinus Torvalds tpnt->density = 0; 39821da177e4SLinus Torvalds tpnt->do_auto_lock = ST_AUTO_LOCK; 39831da177e4SLinus Torvalds tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */ 39841da177e4SLinus Torvalds tpnt->can_partitions = 0; 39851da177e4SLinus Torvalds tpnt->two_fm = ST_TWO_FM; 39861da177e4SLinus Torvalds tpnt->fast_mteom = ST_FAST_MTEOM; 39871da177e4SLinus Torvalds tpnt->scsi2_logical = ST_SCSI2LOGICAL; 39881da177e4SLinus Torvalds tpnt->immediate = ST_NOWAIT; 39891da177e4SLinus Torvalds tpnt->default_drvbuffer = 0xff; /* No forced buffering */ 39901da177e4SLinus Torvalds tpnt->partition = 0; 39911da177e4SLinus Torvalds tpnt->new_partition = 0; 39921da177e4SLinus Torvalds tpnt->nbr_partitions = 0; 39931da177e4SLinus Torvalds tpnt->device->timeout = ST_TIMEOUT; 39941da177e4SLinus Torvalds tpnt->long_timeout = ST_LONG_TIMEOUT; 39951da177e4SLinus Torvalds tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma; 39961da177e4SLinus Torvalds 39971da177e4SLinus Torvalds bounce_limit = scsi_calculate_bounce_limit(SDp->host) >> PAGE_SHIFT; 39981da177e4SLinus Torvalds if (bounce_limit > ULONG_MAX) 39991da177e4SLinus Torvalds bounce_limit = ULONG_MAX; 40001da177e4SLinus Torvalds tpnt->max_pfn = bounce_limit; 40011da177e4SLinus Torvalds 40021da177e4SLinus Torvalds for (i = 0; i < ST_NBR_MODES; i++) { 40031da177e4SLinus Torvalds STm = &(tpnt->modes[i]); 40041da177e4SLinus Torvalds STm->defined = 0; 40051da177e4SLinus Torvalds STm->sysv = ST_SYSV; 40061da177e4SLinus Torvalds STm->defaults_for_writes = 0; 40071da177e4SLinus Torvalds STm->do_async_writes = ST_ASYNC_WRITES; 40081da177e4SLinus Torvalds STm->do_buffer_writes = ST_BUFFER_WRITES; 40091da177e4SLinus Torvalds STm->do_read_ahead = ST_READ_AHEAD; 40101da177e4SLinus Torvalds STm->default_compression = ST_DONT_TOUCH; 40111da177e4SLinus Torvalds STm->default_blksize = (-1); /* No forced size */ 40121da177e4SLinus Torvalds STm->default_density = (-1); /* No forced density */ 40131da177e4SLinus Torvalds } 40141da177e4SLinus Torvalds 40151da177e4SLinus Torvalds for (i = 0; i < ST_NBR_PARTITIONS; i++) { 40161da177e4SLinus Torvalds STps = &(tpnt->ps[i]); 40171da177e4SLinus Torvalds STps->rw = ST_IDLE; 40181da177e4SLinus Torvalds STps->eof = ST_NOEOF; 40191da177e4SLinus Torvalds STps->at_sm = 0; 40201da177e4SLinus Torvalds STps->last_block_valid = 0; 40211da177e4SLinus Torvalds STps->drv_block = (-1); 40221da177e4SLinus Torvalds STps->drv_file = (-1); 40231da177e4SLinus Torvalds } 40241da177e4SLinus Torvalds 40251da177e4SLinus Torvalds tpnt->current_mode = 0; 40261da177e4SLinus Torvalds tpnt->modes[0].defined = 1; 40271da177e4SLinus Torvalds 40281da177e4SLinus Torvalds tpnt->density_changed = tpnt->compression_changed = 40291da177e4SLinus Torvalds tpnt->blksize_changed = 0; 40301da177e4SLinus Torvalds init_MUTEX(&tpnt->lock); 40311da177e4SLinus Torvalds 40321da177e4SLinus Torvalds st_nr_dev++; 40331da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 40341da177e4SLinus Torvalds 40351da177e4SLinus Torvalds for (mode = 0; mode < ST_NBR_MODES; ++mode) { 40361da177e4SLinus Torvalds STm = &(tpnt->modes[mode]); 40371da177e4SLinus Torvalds for (j=0; j < 2; j++) { 40381da177e4SLinus Torvalds cdev = cdev_alloc(); 40391da177e4SLinus Torvalds if (!cdev) { 40401da177e4SLinus Torvalds printk(KERN_ERR 40411da177e4SLinus Torvalds "st%d: out of memory. Device not attached.\n", 40421da177e4SLinus Torvalds dev_num); 40431da177e4SLinus Torvalds goto out_free_tape; 40441da177e4SLinus Torvalds } 40451da177e4SLinus Torvalds cdev->owner = THIS_MODULE; 40461da177e4SLinus Torvalds cdev->ops = &st_fops; 40471da177e4SLinus Torvalds 40481da177e4SLinus Torvalds error = cdev_add(cdev, 40491da177e4SLinus Torvalds MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)), 40501da177e4SLinus Torvalds 1); 40511da177e4SLinus Torvalds if (error) { 40521da177e4SLinus Torvalds printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n", 40531da177e4SLinus Torvalds dev_num, j ? "non" : "auto", mode); 40541da177e4SLinus Torvalds printk(KERN_ERR "st%d: Device not attached.\n", dev_num); 40551da177e4SLinus Torvalds goto out_free_tape; 40561da177e4SLinus Torvalds } 40571da177e4SLinus Torvalds STm->cdevs[j] = cdev; 40581da177e4SLinus Torvalds 40591da177e4SLinus Torvalds } 40601da177e4SLinus Torvalds do_create_class_files(tpnt, dev_num, mode); 40611da177e4SLinus Torvalds } 40621da177e4SLinus Torvalds 40631da177e4SLinus Torvalds for (mode = 0; mode < ST_NBR_MODES; ++mode) { 40641da177e4SLinus Torvalds /* Make sure that the minor numbers corresponding to the four 40651da177e4SLinus Torvalds first modes always get the same names */ 40661da177e4SLinus Torvalds i = mode << (4 - ST_NBR_MODE_BITS); 40671da177e4SLinus Torvalds /* Rewind entry */ 40681da177e4SLinus Torvalds devfs_mk_cdev(MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, 0)), 40691da177e4SLinus Torvalds S_IFCHR | S_IRUGO | S_IWUGO, 40701da177e4SLinus Torvalds "%s/mt%s", SDp->devfs_name, st_formats[i]); 40711da177e4SLinus Torvalds /* No-rewind entry */ 40721da177e4SLinus Torvalds devfs_mk_cdev(MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, 1)), 40731da177e4SLinus Torvalds S_IFCHR | S_IRUGO | S_IWUGO, 40741da177e4SLinus Torvalds "%s/mt%sn", SDp->devfs_name, st_formats[i]); 40751da177e4SLinus Torvalds } 40761da177e4SLinus Torvalds disk->number = devfs_register_tape(SDp->devfs_name); 40771da177e4SLinus Torvalds 40781da177e4SLinus Torvalds printk(KERN_WARNING 40791da177e4SLinus Torvalds "Attached scsi tape %s at scsi%d, channel %d, id %d, lun %d\n", 40801da177e4SLinus Torvalds tape_name(tpnt), SDp->host->host_no, SDp->channel, SDp->id, SDp->lun); 40811da177e4SLinus Torvalds printk(KERN_WARNING "%s: try direct i/o: %s (alignment %d B), max page reachable by HBA %lu\n", 40821da177e4SLinus Torvalds tape_name(tpnt), tpnt->try_dio ? "yes" : "no", 40831da177e4SLinus Torvalds queue_dma_alignment(SDp->request_queue) + 1, tpnt->max_pfn); 40841da177e4SLinus Torvalds 40851da177e4SLinus Torvalds return 0; 40861da177e4SLinus Torvalds 40871da177e4SLinus Torvalds out_free_tape: 40881da177e4SLinus Torvalds for (mode=0; mode < ST_NBR_MODES; mode++) { 40891da177e4SLinus Torvalds STm = &(tpnt->modes[mode]); 40901da177e4SLinus Torvalds sysfs_remove_link(&tpnt->device->sdev_gendev.kobj, 40911da177e4SLinus Torvalds "tape"); 40921da177e4SLinus Torvalds for (j=0; j < 2; j++) { 40931da177e4SLinus Torvalds if (STm->cdevs[j]) { 40941da177e4SLinus Torvalds if (cdev == STm->cdevs[j]) 40951da177e4SLinus Torvalds cdev = NULL; 4096d253878bSgregkh@suse.de class_device_destroy(st_sysfs_class, 4097d253878bSgregkh@suse.de MKDEV(SCSI_TAPE_MAJOR, 40981da177e4SLinus Torvalds TAPE_MINOR(i, mode, j))); 40991da177e4SLinus Torvalds cdev_del(STm->cdevs[j]); 41001da177e4SLinus Torvalds } 41011da177e4SLinus Torvalds } 41021da177e4SLinus Torvalds } 41031da177e4SLinus Torvalds if (cdev) 41041da177e4SLinus Torvalds cdev_del(cdev); 41051da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 41061da177e4SLinus Torvalds scsi_tapes[dev_num] = NULL; 41071da177e4SLinus Torvalds st_nr_dev--; 41081da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 41091da177e4SLinus Torvalds out_put_disk: 41101da177e4SLinus Torvalds put_disk(disk); 41111da177e4SLinus Torvalds if (tpnt) 41121da177e4SLinus Torvalds kfree(tpnt); 41131da177e4SLinus Torvalds out_buffer_free: 41141da177e4SLinus Torvalds kfree(buffer); 41151da177e4SLinus Torvalds out: 41161da177e4SLinus Torvalds return -ENODEV; 41171da177e4SLinus Torvalds }; 41181da177e4SLinus Torvalds 41191da177e4SLinus Torvalds 41201da177e4SLinus Torvalds static int st_remove(struct device *dev) 41211da177e4SLinus Torvalds { 41221da177e4SLinus Torvalds struct scsi_device *SDp = to_scsi_device(dev); 41231da177e4SLinus Torvalds struct scsi_tape *tpnt; 41241da177e4SLinus Torvalds int i, j, mode; 41251da177e4SLinus Torvalds 41261da177e4SLinus Torvalds write_lock(&st_dev_arr_lock); 41271da177e4SLinus Torvalds for (i = 0; i < st_dev_max; i++) { 41281da177e4SLinus Torvalds tpnt = scsi_tapes[i]; 41291da177e4SLinus Torvalds if (tpnt != NULL && tpnt->device == SDp) { 41301da177e4SLinus Torvalds scsi_tapes[i] = NULL; 41311da177e4SLinus Torvalds st_nr_dev--; 41321da177e4SLinus Torvalds write_unlock(&st_dev_arr_lock); 41331da177e4SLinus Torvalds devfs_unregister_tape(tpnt->disk->number); 41341da177e4SLinus Torvalds sysfs_remove_link(&tpnt->device->sdev_gendev.kobj, 41351da177e4SLinus Torvalds "tape"); 41361da177e4SLinus Torvalds for (mode = 0; mode < ST_NBR_MODES; ++mode) { 41371da177e4SLinus Torvalds j = mode << (4 - ST_NBR_MODE_BITS); 41381da177e4SLinus Torvalds devfs_remove("%s/mt%s", SDp->devfs_name, st_formats[j]); 41391da177e4SLinus Torvalds devfs_remove("%s/mt%sn", SDp->devfs_name, st_formats[j]); 41401da177e4SLinus Torvalds for (j=0; j < 2; j++) { 4141d253878bSgregkh@suse.de class_device_destroy(st_sysfs_class, 4142d253878bSgregkh@suse.de MKDEV(SCSI_TAPE_MAJOR, 41431da177e4SLinus Torvalds TAPE_MINOR(i, mode, j))); 41441da177e4SLinus Torvalds cdev_del(tpnt->modes[mode].cdevs[j]); 41451da177e4SLinus Torvalds tpnt->modes[mode].cdevs[j] = NULL; 41461da177e4SLinus Torvalds } 41471da177e4SLinus Torvalds } 4148f03a5670SKai Makisara 4149f03a5670SKai Makisara down(&st_ref_sem); 4150f03a5670SKai Makisara kref_put(&tpnt->kref, scsi_tape_release); 4151f03a5670SKai Makisara up(&st_ref_sem); 4152f03a5670SKai Makisara return 0; 4153f03a5670SKai Makisara } 4154f03a5670SKai Makisara } 4155f03a5670SKai Makisara 4156f03a5670SKai Makisara write_unlock(&st_dev_arr_lock); 4157f03a5670SKai Makisara return 0; 4158f03a5670SKai Makisara } 4159f03a5670SKai Makisara 4160f03a5670SKai Makisara /** 4161f03a5670SKai Makisara * scsi_tape_release - Called to free the Scsi_Tape structure 4162f03a5670SKai Makisara * @kref: pointer to embedded kref 4163f03a5670SKai Makisara * 4164f03a5670SKai Makisara * st_ref_sem must be held entering this routine. Because it is 4165f03a5670SKai Makisara * called on last put, you should always use the scsi_tape_get() 4166f03a5670SKai Makisara * scsi_tape_put() helpers which manipulate the semaphore directly 4167f03a5670SKai Makisara * and never do a direct kref_put(). 4168f03a5670SKai Makisara **/ 4169f03a5670SKai Makisara static void scsi_tape_release(struct kref *kref) 4170f03a5670SKai Makisara { 4171f03a5670SKai Makisara struct scsi_tape *tpnt = to_scsi_tape(kref); 4172f03a5670SKai Makisara struct gendisk *disk = tpnt->disk; 4173f03a5670SKai Makisara 41741da177e4SLinus Torvalds tpnt->device = NULL; 41751da177e4SLinus Torvalds 41761da177e4SLinus Torvalds if (tpnt->buffer) { 41771da177e4SLinus Torvalds tpnt->buffer->orig_frp_segs = 0; 41781da177e4SLinus Torvalds normalize_buffer(tpnt->buffer); 41791da177e4SLinus Torvalds kfree(tpnt->buffer); 41801da177e4SLinus Torvalds } 41811da177e4SLinus Torvalds 4182f03a5670SKai Makisara disk->private_data = NULL; 4183f03a5670SKai Makisara put_disk(disk); 4184f03a5670SKai Makisara kfree(tpnt); 4185f03a5670SKai Makisara return; 41861da177e4SLinus Torvalds } 41871da177e4SLinus Torvalds 41881da177e4SLinus Torvalds static void st_intr(struct scsi_cmnd *SCpnt) 41891da177e4SLinus Torvalds { 41901da177e4SLinus Torvalds scsi_io_completion(SCpnt, (SCpnt->result ? 0: SCpnt->bufflen), 1); 41911da177e4SLinus Torvalds } 41921da177e4SLinus Torvalds 41931da177e4SLinus Torvalds /* 41941da177e4SLinus Torvalds * st_init_command: only called via the scsi_cmd_ioctl (block SG_IO) 41951da177e4SLinus Torvalds * interface for REQ_BLOCK_PC commands. 41961da177e4SLinus Torvalds */ 41971da177e4SLinus Torvalds static int st_init_command(struct scsi_cmnd *SCpnt) 41981da177e4SLinus Torvalds { 41991da177e4SLinus Torvalds struct request *rq; 42001da177e4SLinus Torvalds 42011da177e4SLinus Torvalds if (!(SCpnt->request->flags & REQ_BLOCK_PC)) 42021da177e4SLinus Torvalds return 0; 42031da177e4SLinus Torvalds 42041da177e4SLinus Torvalds rq = SCpnt->request; 42051da177e4SLinus Torvalds if (sizeof(rq->cmd) > sizeof(SCpnt->cmnd)) 42061da177e4SLinus Torvalds return 0; 42071da177e4SLinus Torvalds 42081da177e4SLinus Torvalds memcpy(SCpnt->cmnd, rq->cmd, sizeof(SCpnt->cmnd)); 42091da177e4SLinus Torvalds 42101da177e4SLinus Torvalds if (rq_data_dir(rq) == WRITE) 42111da177e4SLinus Torvalds SCpnt->sc_data_direction = DMA_TO_DEVICE; 42121da177e4SLinus Torvalds else if (rq->data_len) 42131da177e4SLinus Torvalds SCpnt->sc_data_direction = DMA_FROM_DEVICE; 42141da177e4SLinus Torvalds else 42151da177e4SLinus Torvalds SCpnt->sc_data_direction = DMA_NONE; 42161da177e4SLinus Torvalds 42171da177e4SLinus Torvalds SCpnt->timeout_per_command = rq->timeout; 42181da177e4SLinus Torvalds SCpnt->transfersize = rq->data_len; 42191da177e4SLinus Torvalds SCpnt->done = st_intr; 42201da177e4SLinus Torvalds return 1; 42211da177e4SLinus Torvalds } 42221da177e4SLinus Torvalds 42231da177e4SLinus Torvalds static int __init init_st(void) 42241da177e4SLinus Torvalds { 42251da177e4SLinus Torvalds validate_options(); 42261da177e4SLinus Torvalds 42271da177e4SLinus Torvalds printk(KERN_INFO 42281da177e4SLinus Torvalds "st: Version %s, fixed bufsize %d, s/g segs %d\n", 42291da177e4SLinus Torvalds verstr, st_fixed_buffer_size, st_max_sg_segs); 42301da177e4SLinus Torvalds 4231d253878bSgregkh@suse.de st_sysfs_class = class_create(THIS_MODULE, "scsi_tape"); 42321da177e4SLinus Torvalds if (IS_ERR(st_sysfs_class)) { 42331da177e4SLinus Torvalds st_sysfs_class = NULL; 42341da177e4SLinus Torvalds printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n"); 42351da177e4SLinus Torvalds return 1; 42361da177e4SLinus Torvalds } 42371da177e4SLinus Torvalds 42381da177e4SLinus Torvalds if (!register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 42391da177e4SLinus Torvalds ST_MAX_TAPE_ENTRIES, "st")) { 42401da177e4SLinus Torvalds if (scsi_register_driver(&st_template.gendrv) == 0) { 42411da177e4SLinus Torvalds do_create_driverfs_files(); 42421da177e4SLinus Torvalds return 0; 42431da177e4SLinus Torvalds } 42441da177e4SLinus Torvalds if (st_sysfs_class) 4245d253878bSgregkh@suse.de class_destroy(st_sysfs_class); 42461da177e4SLinus Torvalds unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 42471da177e4SLinus Torvalds 42481da177e4SLinus Torvalds ST_MAX_TAPE_ENTRIES); 42491da177e4SLinus Torvalds } 42501da177e4SLinus Torvalds 42511da177e4SLinus Torvalds printk(KERN_ERR "Unable to get major %d for SCSI tapes\n", SCSI_TAPE_MAJOR); 42521da177e4SLinus Torvalds return 1; 42531da177e4SLinus Torvalds } 42541da177e4SLinus Torvalds 42551da177e4SLinus Torvalds static void __exit exit_st(void) 42561da177e4SLinus Torvalds { 42571da177e4SLinus Torvalds if (st_sysfs_class) 4258d253878bSgregkh@suse.de class_destroy(st_sysfs_class); 42591da177e4SLinus Torvalds st_sysfs_class = NULL; 42601da177e4SLinus Torvalds do_remove_driverfs_files(); 42611da177e4SLinus Torvalds scsi_unregister_driver(&st_template.gendrv); 42621da177e4SLinus Torvalds unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 42631da177e4SLinus Torvalds ST_MAX_TAPE_ENTRIES); 42641da177e4SLinus Torvalds kfree(scsi_tapes); 42651da177e4SLinus Torvalds printk(KERN_INFO "st: Unloaded.\n"); 42661da177e4SLinus Torvalds } 42671da177e4SLinus Torvalds 42681da177e4SLinus Torvalds module_init(init_st); 42691da177e4SLinus Torvalds module_exit(exit_st); 42701da177e4SLinus Torvalds 42711da177e4SLinus Torvalds 42721da177e4SLinus Torvalds /* The sysfs driver interface. Read-only at the moment */ 42731da177e4SLinus Torvalds static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf) 42741da177e4SLinus Torvalds { 42751da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io); 42761da177e4SLinus Torvalds } 42771da177e4SLinus Torvalds static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL); 42781da177e4SLinus Torvalds 42791da177e4SLinus Torvalds static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf) 42801da177e4SLinus Torvalds { 42811da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size); 42821da177e4SLinus Torvalds } 42831da177e4SLinus Torvalds static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL); 42841da177e4SLinus Torvalds 42851da177e4SLinus Torvalds static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf) 42861da177e4SLinus Torvalds { 42871da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs); 42881da177e4SLinus Torvalds } 42891da177e4SLinus Torvalds static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL); 42901da177e4SLinus Torvalds 42911da177e4SLinus Torvalds static ssize_t st_version_show(struct device_driver *ddd, char *buf) 42921da177e4SLinus Torvalds { 42931da177e4SLinus Torvalds return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr); 42941da177e4SLinus Torvalds } 42951da177e4SLinus Torvalds static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL); 42961da177e4SLinus Torvalds 42971da177e4SLinus Torvalds static void do_create_driverfs_files(void) 42981da177e4SLinus Torvalds { 42991da177e4SLinus Torvalds struct device_driver *driverfs = &st_template.gendrv; 43001da177e4SLinus Torvalds 43011da177e4SLinus Torvalds driver_create_file(driverfs, &driver_attr_try_direct_io); 43021da177e4SLinus Torvalds driver_create_file(driverfs, &driver_attr_fixed_buffer_size); 43031da177e4SLinus Torvalds driver_create_file(driverfs, &driver_attr_max_sg_segs); 43041da177e4SLinus Torvalds driver_create_file(driverfs, &driver_attr_version); 43051da177e4SLinus Torvalds } 43061da177e4SLinus Torvalds 43071da177e4SLinus Torvalds static void do_remove_driverfs_files(void) 43081da177e4SLinus Torvalds { 43091da177e4SLinus Torvalds struct device_driver *driverfs = &st_template.gendrv; 43101da177e4SLinus Torvalds 43111da177e4SLinus Torvalds driver_remove_file(driverfs, &driver_attr_version); 43121da177e4SLinus Torvalds driver_remove_file(driverfs, &driver_attr_max_sg_segs); 43131da177e4SLinus Torvalds driver_remove_file(driverfs, &driver_attr_fixed_buffer_size); 43141da177e4SLinus Torvalds driver_remove_file(driverfs, &driver_attr_try_direct_io); 43151da177e4SLinus Torvalds } 43161da177e4SLinus Torvalds 43171da177e4SLinus Torvalds 43181da177e4SLinus Torvalds /* The sysfs simple class interface */ 43191da177e4SLinus Torvalds static ssize_t st_defined_show(struct class_device *class_dev, char *buf) 43201da177e4SLinus Torvalds { 43211da177e4SLinus Torvalds struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev); 43221da177e4SLinus Torvalds ssize_t l = 0; 43231da177e4SLinus Torvalds 43241da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined); 43251da177e4SLinus Torvalds return l; 43261da177e4SLinus Torvalds } 43271da177e4SLinus Torvalds 43281da177e4SLinus Torvalds CLASS_DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL); 43291da177e4SLinus Torvalds 43301da177e4SLinus Torvalds static ssize_t st_defblk_show(struct class_device *class_dev, char *buf) 43311da177e4SLinus Torvalds { 43321da177e4SLinus Torvalds struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev); 43331da177e4SLinus Torvalds ssize_t l = 0; 43341da177e4SLinus Torvalds 43351da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize); 43361da177e4SLinus Torvalds return l; 43371da177e4SLinus Torvalds } 43381da177e4SLinus Torvalds 43391da177e4SLinus Torvalds CLASS_DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL); 43401da177e4SLinus Torvalds 43411da177e4SLinus Torvalds static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf) 43421da177e4SLinus Torvalds { 43431da177e4SLinus Torvalds struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev); 43441da177e4SLinus Torvalds ssize_t l = 0; 43451da177e4SLinus Torvalds char *fmt; 43461da177e4SLinus Torvalds 43471da177e4SLinus Torvalds fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n"; 43481da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density); 43491da177e4SLinus Torvalds return l; 43501da177e4SLinus Torvalds } 43511da177e4SLinus Torvalds 43521da177e4SLinus Torvalds CLASS_DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL); 43531da177e4SLinus Torvalds 43541da177e4SLinus Torvalds static ssize_t st_defcompression_show(struct class_device *class_dev, char *buf) 43551da177e4SLinus Torvalds { 43561da177e4SLinus Torvalds struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev); 43571da177e4SLinus Torvalds ssize_t l = 0; 43581da177e4SLinus Torvalds 43591da177e4SLinus Torvalds l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1); 43601da177e4SLinus Torvalds return l; 43611da177e4SLinus Torvalds } 43621da177e4SLinus Torvalds 43631da177e4SLinus Torvalds CLASS_DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL); 43641da177e4SLinus Torvalds 43651da177e4SLinus Torvalds static void do_create_class_files(struct scsi_tape *STp, int dev_num, int mode) 43661da177e4SLinus Torvalds { 43671da177e4SLinus Torvalds int i, rew, error; 43681da177e4SLinus Torvalds char name[10]; 43691da177e4SLinus Torvalds struct class_device *st_class_member; 43701da177e4SLinus Torvalds 43711da177e4SLinus Torvalds if (!st_sysfs_class) 43721da177e4SLinus Torvalds return; 43731da177e4SLinus Torvalds 43741da177e4SLinus Torvalds for (rew=0; rew < 2; rew++) { 43751da177e4SLinus Torvalds /* Make sure that the minor numbers corresponding to the four 43761da177e4SLinus Torvalds first modes always get the same names */ 43771da177e4SLinus Torvalds i = mode << (4 - ST_NBR_MODE_BITS); 43781da177e4SLinus Torvalds snprintf(name, 10, "%s%s%s", rew ? "n" : "", 43791da177e4SLinus Torvalds STp->disk->disk_name, st_formats[i]); 43801da177e4SLinus Torvalds st_class_member = 4381d253878bSgregkh@suse.de class_device_create(st_sysfs_class, 43821da177e4SLinus Torvalds MKDEV(SCSI_TAPE_MAJOR, 43831da177e4SLinus Torvalds TAPE_MINOR(dev_num, mode, rew)), 43841da177e4SLinus Torvalds &STp->device->sdev_gendev, "%s", name); 43851da177e4SLinus Torvalds if (IS_ERR(st_class_member)) { 4386d253878bSgregkh@suse.de printk(KERN_WARNING "st%d: class_device_create failed\n", 43871da177e4SLinus Torvalds dev_num); 43881da177e4SLinus Torvalds goto out; 43891da177e4SLinus Torvalds } 43901da177e4SLinus Torvalds class_set_devdata(st_class_member, &STp->modes[mode]); 43911da177e4SLinus Torvalds 43921da177e4SLinus Torvalds class_device_create_file(st_class_member, 43931da177e4SLinus Torvalds &class_device_attr_defined); 43941da177e4SLinus Torvalds class_device_create_file(st_class_member, 43951da177e4SLinus Torvalds &class_device_attr_default_blksize); 43961da177e4SLinus Torvalds class_device_create_file(st_class_member, 43971da177e4SLinus Torvalds &class_device_attr_default_density); 43981da177e4SLinus Torvalds class_device_create_file(st_class_member, 43991da177e4SLinus Torvalds &class_device_attr_default_compression); 44001da177e4SLinus Torvalds if (mode == 0 && rew == 0) { 44011da177e4SLinus Torvalds error = sysfs_create_link(&STp->device->sdev_gendev.kobj, 44021da177e4SLinus Torvalds &st_class_member->kobj, 44031da177e4SLinus Torvalds "tape"); 44041da177e4SLinus Torvalds if (error) { 44051da177e4SLinus Torvalds printk(KERN_ERR 44061da177e4SLinus Torvalds "st%d: Can't create sysfs link from SCSI device.\n", 44071da177e4SLinus Torvalds dev_num); 44081da177e4SLinus Torvalds } 44091da177e4SLinus Torvalds } 44101da177e4SLinus Torvalds } 44111da177e4SLinus Torvalds out: 44121da177e4SLinus Torvalds return; 44131da177e4SLinus Torvalds } 44141da177e4SLinus Torvalds 44151da177e4SLinus Torvalds 44161da177e4SLinus Torvalds /* Pin down user pages and put them into a scatter gather list. Returns <= 0 if 44171da177e4SLinus Torvalds - mapping of all pages not successful 44181da177e4SLinus Torvalds - any page is above max_pfn 44191da177e4SLinus Torvalds (i.e., either completely successful or fails) 44201da177e4SLinus Torvalds */ 44211da177e4SLinus Torvalds static int st_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages, 44221da177e4SLinus Torvalds unsigned long uaddr, size_t count, int rw, 44231da177e4SLinus Torvalds unsigned long max_pfn) 44241da177e4SLinus Torvalds { 44251da177e4SLinus Torvalds int i, nr_pages; 44261da177e4SLinus Torvalds 44271da177e4SLinus Torvalds nr_pages = sgl_map_user_pages(sgl, max_pages, uaddr, count, rw); 44281da177e4SLinus Torvalds if (nr_pages <= 0) 44291da177e4SLinus Torvalds return nr_pages; 44301da177e4SLinus Torvalds 44311da177e4SLinus Torvalds for (i=0; i < nr_pages; i++) { 44321da177e4SLinus Torvalds if (page_to_pfn(sgl[i].page) > max_pfn) 44331da177e4SLinus Torvalds goto out_unmap; 44341da177e4SLinus Torvalds } 44351da177e4SLinus Torvalds return nr_pages; 44361da177e4SLinus Torvalds 44371da177e4SLinus Torvalds out_unmap: 44381da177e4SLinus Torvalds sgl_unmap_user_pages(sgl, nr_pages, 0); 44391da177e4SLinus Torvalds return 0; 44401da177e4SLinus Torvalds } 44411da177e4SLinus Torvalds 44421da177e4SLinus Torvalds 44431da177e4SLinus Torvalds /* The following functions may be useful for a larger audience. */ 44441da177e4SLinus Torvalds static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages, 44451da177e4SLinus Torvalds unsigned long uaddr, size_t count, int rw) 44461da177e4SLinus Torvalds { 44471da177e4SLinus Torvalds int res, i, j; 44481da177e4SLinus Torvalds unsigned int nr_pages; 44491da177e4SLinus Torvalds struct page **pages; 44501da177e4SLinus Torvalds 44511da177e4SLinus Torvalds nr_pages = ((uaddr & ~PAGE_MASK) + count + ~PAGE_MASK) >> PAGE_SHIFT; 44521da177e4SLinus Torvalds 44531da177e4SLinus Torvalds /* User attempted Overflow! */ 44541da177e4SLinus Torvalds if ((uaddr + count) < uaddr) 44551da177e4SLinus Torvalds return -EINVAL; 44561da177e4SLinus Torvalds 44571da177e4SLinus Torvalds /* Too big */ 44581da177e4SLinus Torvalds if (nr_pages > max_pages) 44591da177e4SLinus Torvalds return -ENOMEM; 44601da177e4SLinus Torvalds 44611da177e4SLinus Torvalds /* Hmm? */ 44621da177e4SLinus Torvalds if (count == 0) 44631da177e4SLinus Torvalds return 0; 44641da177e4SLinus Torvalds 44651da177e4SLinus Torvalds if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL) 44661da177e4SLinus Torvalds return -ENOMEM; 44671da177e4SLinus Torvalds 44681da177e4SLinus Torvalds /* Try to fault in all of the necessary pages */ 44691da177e4SLinus Torvalds down_read(¤t->mm->mmap_sem); 44701da177e4SLinus Torvalds /* rw==READ means read from drive, write into memory area */ 44711da177e4SLinus Torvalds res = get_user_pages( 44721da177e4SLinus Torvalds current, 44731da177e4SLinus Torvalds current->mm, 44741da177e4SLinus Torvalds uaddr, 44751da177e4SLinus Torvalds nr_pages, 44761da177e4SLinus Torvalds rw == READ, 44771da177e4SLinus Torvalds 0, /* don't force */ 44781da177e4SLinus Torvalds pages, 44791da177e4SLinus Torvalds NULL); 44801da177e4SLinus Torvalds up_read(¤t->mm->mmap_sem); 44811da177e4SLinus Torvalds 44821da177e4SLinus Torvalds /* Errors and no page mapped should return here */ 44831da177e4SLinus Torvalds if (res < nr_pages) 44841da177e4SLinus Torvalds goto out_unmap; 44851da177e4SLinus Torvalds 44861da177e4SLinus Torvalds for (i=0; i < nr_pages; i++) { 44871da177e4SLinus Torvalds /* FIXME: flush superflous for rw==READ, 44881da177e4SLinus Torvalds * probably wrong function for rw==WRITE 44891da177e4SLinus Torvalds */ 44901da177e4SLinus Torvalds flush_dcache_page(pages[i]); 44911da177e4SLinus Torvalds } 44921da177e4SLinus Torvalds 44931da177e4SLinus Torvalds /* Populate the scatter/gather list */ 44941da177e4SLinus Torvalds sgl[0].page = pages[0]; 44951da177e4SLinus Torvalds sgl[0].offset = uaddr & ~PAGE_MASK; 44961da177e4SLinus Torvalds if (nr_pages > 1) { 44971da177e4SLinus Torvalds sgl[0].length = PAGE_SIZE - sgl[0].offset; 44981da177e4SLinus Torvalds count -= sgl[0].length; 44991da177e4SLinus Torvalds for (i=1; i < nr_pages ; i++) { 45001da177e4SLinus Torvalds sgl[i].offset = 0; 45011da177e4SLinus Torvalds sgl[i].page = pages[i]; 45021da177e4SLinus Torvalds sgl[i].length = count < PAGE_SIZE ? count : PAGE_SIZE; 45031da177e4SLinus Torvalds count -= PAGE_SIZE; 45041da177e4SLinus Torvalds } 45051da177e4SLinus Torvalds } 45061da177e4SLinus Torvalds else { 45071da177e4SLinus Torvalds sgl[0].length = count; 45081da177e4SLinus Torvalds } 45091da177e4SLinus Torvalds 45101da177e4SLinus Torvalds kfree(pages); 45111da177e4SLinus Torvalds return nr_pages; 45121da177e4SLinus Torvalds 45131da177e4SLinus Torvalds out_unmap: 45141da177e4SLinus Torvalds if (res > 0) { 45151da177e4SLinus Torvalds for (j=0; j < res; j++) 45161da177e4SLinus Torvalds page_cache_release(pages[j]); 45171da177e4SLinus Torvalds } 45181da177e4SLinus Torvalds kfree(pages); 45191da177e4SLinus Torvalds return res; 45201da177e4SLinus Torvalds } 45211da177e4SLinus Torvalds 45221da177e4SLinus Torvalds 45231da177e4SLinus Torvalds /* And unmap them... */ 45241da177e4SLinus Torvalds static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages, 45251da177e4SLinus Torvalds int dirtied) 45261da177e4SLinus Torvalds { 45271da177e4SLinus Torvalds int i; 45281da177e4SLinus Torvalds 45291da177e4SLinus Torvalds for (i=0; i < nr_pages; i++) { 45301da177e4SLinus Torvalds if (dirtied && !PageReserved(sgl[i].page)) 45311da177e4SLinus Torvalds SetPageDirty(sgl[i].page); 45321da177e4SLinus Torvalds /* FIXME: cache flush missing for rw==READ 45331da177e4SLinus Torvalds * FIXME: call the correct reference counting function 45341da177e4SLinus Torvalds */ 45351da177e4SLinus Torvalds page_cache_release(sgl[i].page); 45361da177e4SLinus Torvalds } 45371da177e4SLinus Torvalds 45381da177e4SLinus Torvalds return 0; 45391da177e4SLinus Torvalds } 4540