projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'irq-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[deliverable/linux.git] / drivers / scsi / st.c
CommitLineData
1da177e4
LT		 1/*
2 SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
3 file Documentation/scsi/st.txt for more information.
4
5 History:
6 Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.
7 Contribution and ideas from several people including (in alphabetical
8 order) Klaus Ehrenfried, Eugene Exarevsky, Eric Lee Green, Wolfgang Denk,
9 Steve Hirsch, Andreas Koppenh"ofer, Michael Leodolter, Eyal Lebedinsky,
10 Michael Schaefer, J"org Weule, and Eric Youngdale.
11
3e51d3c9 12 Copyright 1992 - 2010 Kai Makisara
1da177e4
LT		 13 email Kai.Makisara@kolumbus.fi
14
15 Some small formal changes - aeb, 950809
16
17 Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
18 */
19
373daacf 20static const char *verstr = "20101219";
1da177e4
LT		 21
22#include <linux/module.h>
23
24#include <linux/fs.h>
25#include <linux/kernel.h>
26#include <linux/sched.h>
27#include <linux/mm.h>
28#include <linux/init.h>
29#include <linux/string.h>
5a0e3ad6 30#include <linux/slab.h>
1da177e4
LT		 31#include <linux/errno.h>
32#include <linux/mtio.h>
16c4b3e2 33#include <linux/cdrom.h>
1da177e4
LT		 34#include <linux/ioctl.h>
35#include <linux/fcntl.h>
36#include <linux/spinlock.h>
37#include <linux/blkdev.h>
38#include <linux/moduleparam.h>
1da177e4 39#include <linux/cdev.h>
6c648d95 40#include <linux/idr.h>
1da177e4 41#include <linux/delay.h>
0b950672 42#include <linux/mutex.h>
1da177e4
LT		 43
44#include <asm/uaccess.h>
45#include <asm/dma.h>
1da177e4
LT		 46
47#include <scsi/scsi.h>
48#include <scsi/scsi_dbg.h>
49#include <scsi/scsi_device.h>
50#include <scsi/scsi_driver.h>
51#include <scsi/scsi_eh.h>
52#include <scsi/scsi_host.h>
53#include <scsi/scsi_ioctl.h>
16c4b3e2 54#include <scsi/sg.h>
1da177e4
LT		 55
56
57/* The driver prints some debugging information on the console if DEBUG
58 is defined and non-zero. */
2bec708a
LO		 59#define DEBUG 1
60#define NO_DEBUG 0
1da177e4 61
b30d8bca 62#define ST_DEB_MSG KERN_NOTICE
1da177e4
LT		 63#if DEBUG
64/* The message level for the debug messages is currently set to KERN_NOTICE
65 so that people can easily see the messages. Later when the debugging messages
66 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
1da177e4
LT		 67#define DEB(a) a
68#define DEBC(a) if (debugging) { a ; }
69#else
70#define DEB(a)
71#define DEBC(a)
72#endif
73
74#define ST_KILOBYTE 1024
75
76#include "st_options.h"
77#include "st.h"
78
79static int buffer_kbs;
80static int max_sg_segs;
81static int try_direct_io = TRY_DIRECT_IO;
82static int try_rdio = 1;
83static int try_wdio = 1;
2bec708a 84static int debug_flag;
1da177e4 85
af23782b 86static struct class st_sysfs_class;
c69c6be5 87static const struct attribute_group *st_dev_groups[];
1da177e4
LT		 88
89MODULE_AUTHOR("Kai Makisara");
f018fa55 90MODULE_DESCRIPTION("SCSI tape (st) driver");
1da177e4 91MODULE_LICENSE("GPL");
f018fa55 92MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
d7b8bcb0 93MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE);
1da177e4
LT		 94
95/* Set 'perm' (4th argument) to 0 to disable module_param's definition
96 * of sysfs parameters (which module_param doesn't yet support).
97 * Sysfs parameters defined explicitly later.
98 */
99module_param_named(buffer_kbs, buffer_kbs, int, 0);
100MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
101module_param_named(max_sg_segs, max_sg_segs, int, 0);
102MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
103module_param_named(try_direct_io, try_direct_io, int, 0);
104MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
2bec708a
LO		 105module_param_named(debug_flag, debug_flag, int, 0);
106MODULE_PARM_DESC(debug_flag, "Enable DEBUG, same as setting debugging=1");
107
1da177e4
LT		 108
109/* Extra parameters for testing */
110module_param_named(try_rdio, try_rdio, int, 0);
111MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
112module_param_named(try_wdio, try_wdio, int, 0);
113MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
114
115#ifndef MODULE
116static int write_threshold_kbs; /* retained for compatibility */
117static struct st_dev_parm {
118 char *name;
119 int *val;
120} parms[] __initdata = {
121 {
122 "buffer_kbs", &buffer_kbs
123 },
124 { /* Retained for compatibility with 2.4 */
125 "write_threshold_kbs", &write_threshold_kbs
126 },
127 {
128 "max_sg_segs", NULL
129 },
130 {
131 "try_direct_io", &try_direct_io
2bec708a
LO		 132 },
133 {
134 "debug_flag", &debug_flag
1da177e4
LT		 135 }
136};
137#endif
138
139/* Restrict the number of modes so that names for all are assigned */
140#if ST_NBR_MODES > 16
141#error "Maximum number of modes is 16"
142#endif
143/* Bit reversed order to get same names for same minors with all
144 mode counts */
0ad78200 145static const char *st_formats[] = {
1da177e4
LT		 146 "", "r", "k", "s", "l", "t", "o", "u",
147 "m", "v", "p", "x", "a", "y", "q", "z"};
148
149/* The default definitions have been moved to st_options.h */
150
151#define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
152
153/* The buffer size should fit into the 24 bits for length in the
154 6-byte SCSI read and write commands. */
155#if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
156#error "Buffer size should not exceed (2 << 24 - 1) bytes!"
157#endif
158
159static int debugging = DEBUG;
160
161#define MAX_RETRIES 0
162#define MAX_WRITE_RETRIES 0
163#define MAX_READY_RETRIES 0
164#define NO_TAPE NOT_READY
165
166#define ST_TIMEOUT (900 * HZ)
167#define ST_LONG_TIMEOUT (14000 * HZ)
168
169/* Remove mode bits and auto-rewind bit (7) */
170#define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
171 (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
172#define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
173
174/* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
175#define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
176 (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
177
178/* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
179 24 bits) */
180#define SET_DENS_AND_BLK 0x10001
181
1da177e4
LT		 182static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
183static int st_max_sg_segs = ST_MAX_SG;
184
1da177e4
LT		 185static int modes_defined;
186
1da177e4 187static int enlarge_buffer(struct st_buffer *, int, int);
40f6b36c 188static void clear_buffer(struct st_buffer *);
1da177e4
LT		 189static void normalize_buffer(struct st_buffer *);
190static int append_to_buffer(const char __user *, struct st_buffer *, int);
191static int from_buffer(struct st_buffer *, char __user *, int);
192static void move_buffer_data(struct st_buffer *, int);
1da177e4 193
6620742f 194static int sgl_map_user_pages(struct st_buffer *, const unsigned int,
1da177e4 195 unsigned long, size_t, int);
6620742f 196static int sgl_unmap_user_pages(struct st_buffer *, const unsigned int, int);
1da177e4
LT		 197
198static int st_probe(struct device *);
199static int st_remove(struct device *);
1da177e4 200
405ae7d3
RD		 201static int do_create_sysfs_files(void);
202static void do_remove_sysfs_files(void);
1da177e4
LT		 203
204static struct scsi_driver st_template = {
1da177e4
LT		 205 .gendrv = {
206 .name = "st",
3af6b352 207 .owner = THIS_MODULE,
1da177e4
LT		 208 .probe = st_probe,
209 .remove = st_remove,
210 },
1da177e4
LT		 211};
212
213static int st_compression(struct scsi_tape *, int);
214
215static int find_partition(struct scsi_tape *);
216static int switch_partition(struct scsi_tape *);
217
218static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
219
f03a5670
KM		 220static void scsi_tape_release(struct kref *);
221
222#define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
223
0b950672 224static DEFINE_MUTEX(st_ref_mutex);
6c648d95
JM		 225static DEFINE_SPINLOCK(st_index_lock);
226static DEFINE_SPINLOCK(st_use_lock);
227static DEFINE_IDR(st_index_idr);
228
f03a5670 229
1da177e4
LT		 230\f
231#include "osst_detect.h"
232#ifndef SIGS_FROM_OSST
233#define SIGS_FROM_OSST \
234 {"OnStream", "SC-", "", "osst"}, \
235 {"OnStream", "DI-", "", "osst"}, \
236 {"OnStream", "DP-", "", "osst"}, \
237 {"OnStream", "USB", "", "osst"}, \
238 {"OnStream", "FW-", "", "osst"}
239#endif
240
f03a5670
KM		 241static struct scsi_tape *scsi_tape_get(int dev)
242{
243 struct scsi_tape *STp = NULL;
244
0b950672 245 mutex_lock(&st_ref_mutex);
6c648d95 246 spin_lock(&st_index_lock);
f03a5670 247
6c648d95 248 STp = idr_find(&st_index_idr, dev);
f03a5670
KM		 249 if (!STp) goto out;
250
251 kref_get(&STp->kref);
252
253 if (!STp->device)
254 goto out_put;
255
256 if (scsi_device_get(STp->device))
257 goto out_put;
258
259 goto out;
260
261out_put:
262 kref_put(&STp->kref, scsi_tape_release);
263 STp = NULL;
264out:
6c648d95 265 spin_unlock(&st_index_lock);
0b950672 266 mutex_unlock(&st_ref_mutex);
f03a5670
KM		 267 return STp;
268}
269
270static void scsi_tape_put(struct scsi_tape *STp)
271{
272 struct scsi_device *sdev = STp->device;
273
0b950672 274 mutex_lock(&st_ref_mutex);
f03a5670
KM		 275 kref_put(&STp->kref, scsi_tape_release);
276 scsi_device_put(sdev);
0b950672 277 mutex_unlock(&st_ref_mutex);
f03a5670
KM		 278}
279
1da177e4
LT		 280struct st_reject_data {
281 char *vendor;
282 char *model;
283 char *rev;
284 char *driver_hint; /* Name of the correct driver, NULL if unknown */
285};
286
287static struct st_reject_data reject_list[] = {
288 /* {"XXX", "Yy-", "", NULL}, example */
289 SIGS_FROM_OSST,
290 {NULL, }};
291
292/* If the device signature is on the list of incompatible drives, the
293 function returns a pointer to the name of the correct driver (if known) */
294static char * st_incompatible(struct scsi_device* SDp)
295{
296 struct st_reject_data *rp;
297
298 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
299 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
300 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
301 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
302 if (rp->driver_hint)
303 return rp->driver_hint;
304 else
305 return "unknown";
306 }
307 return NULL;
308}
309\f
310
311static inline char *tape_name(struct scsi_tape *tape)
312{
313 return tape->disk->disk_name;
314}
315
b30d8bca 316#define st_printk(prefix, t, fmt, a...) \
22e0d994 317 sdev_prefix_printk(prefix, (t)->device, tape_name(t), fmt, ##a)
b30d8bca
HR		 318#ifdef DEBUG
319#define DEBC_printk(t, fmt, a...) \
320 if (debugging) { st_printk(ST_DEB_MSG, t, fmt, ##a ); }
321#else
322#define DEBC_printk(t, fmt, a...)
323#endif
1da177e4 324
8b05b773 325static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
1da177e4
LT		 326{
327 const u8 *ucp;
8b05b773 328 const u8 *sense = SRpnt->sense;
1da177e4 329
8b05b773
MC		 330 s->have_sense = scsi_normalize_sense(SRpnt->sense,
331 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
1da177e4
LT		 332 s->flags = 0;
333
334 if (s->have_sense) {
335 s->deferred = 0;
336 s->remainder_valid =
337 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
338 switch (sense[0] & 0x7f) {
339 case 0x71:
340 s->deferred = 1;
341 case 0x70:
342 s->fixed_format = 1;
343 s->flags = sense[2] & 0xe0;
344 break;
345 case 0x73:
346 s->deferred = 1;
347 case 0x72:
348 s->fixed_format = 0;
349 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
350 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
351 break;
352 }
353 }
354}
355
356
357/* Convert the result to success code */
8b05b773 358static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
1da177e4 359{
8b05b773 360 int result = SRpnt->result;
1da177e4
LT		 361 u8 scode;
362 DEB(const char *stp;)
363 char *name = tape_name(STp);
364 struct st_cmdstatus *cmdstatp;
365
366 if (!result)
367 return 0;
368
369 cmdstatp = &STp->buffer->cmdstat;
f03a5670 370 st_analyze_sense(SRpnt, cmdstatp);
1da177e4
LT		 371
372 if (cmdstatp->have_sense)
373 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
374 else
375 scode = 0;
376
b30d8bca
HR		 377 DEB(
378 if (debugging) {
379 st_printk(ST_DEB_MSG, STp,
380 "Error: %x, cmd: %x %x %x %x %x %x\n", result,
381 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
382 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
1da177e4 383 if (cmdstatp->have_sense)
d811b848
HR		 384 __scsi_print_sense(STp->device, name,
385 SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
1da177e4
LT		 386 } ) /* end DEB */
387 if (!debugging) { /* Abnormal conditions for tape */
388 if (!cmdstatp->have_sense)
b30d8bca
HR		 389 st_printk(KERN_WARNING, STp,
390 "Error %x (driver bt 0x%x, host bt 0x%x).\n",
391 result, driver_byte(result), host_byte(result));
1da177e4
LT		 392 else if (cmdstatp->have_sense &&
393 scode != NO_SENSE &&
394 scode != RECOVERED_ERROR &&
395 /* scode != UNIT_ATTENTION && */
396 scode != BLANK_CHECK &&
397 scode != VOLUME_OVERFLOW &&
8b05b773
MC		 398 SRpnt->cmd[0] != MODE_SENSE &&
399 SRpnt->cmd[0] != TEST_UNIT_READY) {
4e73ea7b 400
d811b848
HR		 401 __scsi_print_sense(STp->device, name,
402 SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
1da177e4
LT		 403 }
404 }
405
406 if (cmdstatp->fixed_format &&
407 STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */
408 if (STp->cln_sense_value)
8b05b773 409 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
1da177e4
LT		 410 STp->cln_sense_mask) == STp->cln_sense_value);
411 else
8b05b773 412 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
1da177e4
LT		 413 STp->cln_sense_mask) != 0);
414 }
415 if (cmdstatp->have_sense &&
416 cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
417 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
418
419 STp->pos_unknown |= STp->device->was_reset;
420
421 if (cmdstatp->have_sense &&
422 scode == RECOVERED_ERROR
423#if ST_RECOVERED_WRITE_FATAL
8b05b773
MC		 424 && SRpnt->cmd[0] != WRITE_6
425 && SRpnt->cmd[0] != WRITE_FILEMARKS
1da177e4
LT		 426#endif
427 ) {
428 STp->recover_count++;
429 STp->recover_reg++;
430
b30d8bca 431 DEB(
1da177e4 432 if (debugging) {
8b05b773 433 if (SRpnt->cmd[0] == READ_6)
1da177e4 434 stp = "read";
8b05b773 435 else if (SRpnt->cmd[0] == WRITE_6)
1da177e4
LT		 436 stp = "write";
437 else
438 stp = "ioctl";
b30d8bca
HR		 439 st_printk(ST_DEB_MSG, STp,
440 "Recovered %s error (%d).\n",
441 stp, STp->recover_count);
1da177e4
LT		 442 } ) /* end DEB */
443
444 if (cmdstatp->flags == 0)
445 return 0;
446 }
447 return (-EIO);
448}
449
4deba245 450static struct st_request *st_allocate_request(struct scsi_tape *stp)
8b05b773 451{
4deba245
FT		 452 struct st_request *streq;
453
454 streq = kzalloc(sizeof(*streq), GFP_KERNEL);
455 if (streq)
456 streq->stp = stp;
457 else {
b30d8bca
HR		 458 st_printk(KERN_ERR, stp,
459 "Can't get SCSI request.\n");
4deba245
FT		 460 if (signal_pending(current))
461 stp->buffer->syscall_result = -EINTR;
462 else
463 stp->buffer->syscall_result = -EBUSY;
464 }
465
466 return streq;
8b05b773
MC		 467}
468
469static void st_release_request(struct st_request *streq)
470{
471 kfree(streq);
1da177e4
LT		 472}
473
05545c92
SS		 474static void st_do_stats(struct scsi_tape *STp, struct request *req)
475{
476 ktime_t now;
477
478 now = ktime_get();
479 if (req->cmd[0] == WRITE_6) {
480 now = ktime_sub(now, STp->stats->write_time);
481 atomic64_add(ktime_to_ns(now), &STp->stats->tot_write_time);
482 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
483 atomic64_inc(&STp->stats->write_cnt);
484 if (req->errors) {
485 atomic64_add(atomic_read(&STp->stats->last_write_size)
486 - STp->buffer->cmdstat.residual,
487 &STp->stats->write_byte_cnt);
488 if (STp->buffer->cmdstat.residual > 0)
489 atomic64_inc(&STp->stats->resid_cnt);
490 } else
491 atomic64_add(atomic_read(&STp->stats->last_write_size),
492 &STp->stats->write_byte_cnt);
493 } else if (req->cmd[0] == READ_6) {
494 now = ktime_sub(now, STp->stats->read_time);
495 atomic64_add(ktime_to_ns(now), &STp->stats->tot_read_time);
496 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
497 atomic64_inc(&STp->stats->read_cnt);
498 if (req->errors) {
499 atomic64_add(atomic_read(&STp->stats->last_read_size)
500 - STp->buffer->cmdstat.residual,
501 &STp->stats->read_byte_cnt);
502 if (STp->buffer->cmdstat.residual > 0)
503 atomic64_inc(&STp->stats->resid_cnt);
504 } else
505 atomic64_add(atomic_read(&STp->stats->last_read_size),
506 &STp->stats->read_byte_cnt);
507 } else {
508 now = ktime_sub(now, STp->stats->other_time);
509 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
510 atomic64_inc(&STp->stats->other_cnt);
511 }
512 atomic64_dec(&STp->stats->in_flight);
513}
514
13b53b44
FT		 515static void st_scsi_execute_end(struct request *req, int uptodate)
516{
517 struct st_request *SRpnt = req->end_io_data;
518 struct scsi_tape *STp = SRpnt->stp;
c68bf8ee 519 struct bio *tmp;
13b53b44
FT		 520
521 STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors;
c3a4d78c 522 STp->buffer->cmdstat.residual = req->resid_len;
13b53b44 523
05545c92
SS		 524 st_do_stats(STp, req);
525
c68bf8ee 526 tmp = SRpnt->bio;
13b53b44
FT		 527 if (SRpnt->waiting)
528 complete(SRpnt->waiting);
529
c68bf8ee 530 blk_rq_unmap_user(tmp);
13b53b44
FT		 531 __blk_put_request(req->q, req);
532}
533
534static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
535 int data_direction, void *buffer, unsigned bufflen,
536 int timeout, int retries)
537{
538 struct request *req;
539 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
540 int err = 0;
541 int write = (data_direction == DMA_TO_DEVICE);
05545c92 542 struct scsi_tape *STp = SRpnt->stp;
13b53b44
FT		 543
544 req = blk_get_request(SRpnt->stp->device->request_queue, write,
545 GFP_KERNEL);
a492f075 546 if (IS_ERR(req))
13b53b44
FT		 547 return DRIVER_ERROR << 24;
548
f27b087b 549 blk_rq_set_block_pc(req);
13b53b44
FT		 550 req->cmd_flags |= REQ_QUIET;
551
552 mdata->null_mapped = 1;
553
02ae2c0e
KM		 554 if (bufflen) {
555 err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen,
556 GFP_KERNEL);
557 if (err) {
558 blk_put_request(req);
559 return DRIVER_ERROR << 24;
560 }
13b53b44
FT		 561 }
562
05545c92
SS		 563 atomic64_inc(&STp->stats->in_flight);
564 if (cmd[0] == WRITE_6) {
565 atomic_set(&STp->stats->last_write_size, bufflen);
566 STp->stats->write_time = ktime_get();
567 } else if (cmd[0] == READ_6) {
568 atomic_set(&STp->stats->last_read_size, bufflen);
569 STp->stats->read_time = ktime_get();
570 } else {
571 STp->stats->other_time = ktime_get();
572 }
573
13b53b44
FT		 574 SRpnt->bio = req->bio;
575 req->cmd_len = COMMAND_SIZE(cmd[0]);
576 memset(req->cmd, 0, BLK_MAX_CDB);
577 memcpy(req->cmd, cmd, req->cmd_len);
578 req->sense = SRpnt->sense;
579 req->sense_len = 0;
580 req->timeout = timeout;
581 req->retries = retries;
582 req->end_io_data = SRpnt;
583
584 blk_execute_rq_nowait(req->q, NULL, req, 1, st_scsi_execute_end);
585 return 0;
586}
587
1da177e4
LT		 588/* Do the scsi command. Waits until command performed if do_wait is true.
589 Otherwise write_behind_check() is used to check that the command
590 has finished. */
8b05b773
MC		 591static struct st_request *
592st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
1da177e4
LT		 593 int bytes, int direction, int timeout, int retries, int do_wait)
594{
f03a5670 595 struct completion *waiting;
6d476267
FT		 596 struct rq_map_data *mdata = &STp->buffer->map_data;
597 int ret;
1da177e4 598
f03a5670
KM		 599 /* if async, make sure there's no command outstanding */
600 if (!do_wait && ((STp->buffer)->last_SRpnt)) {
b30d8bca
HR		 601 st_printk(KERN_ERR, STp,
602 "Async command already active.\n");
f03a5670
KM		 603 if (signal_pending(current))
604 (STp->buffer)->syscall_result = (-EINTR);
605 else
606 (STp->buffer)->syscall_result = (-EBUSY);
607 return NULL;
608 }
609
4deba245
FT		 610 if (!SRpnt) {
611 SRpnt = st_allocate_request(STp);
612 if (!SRpnt)
1da177e4 613 return NULL;
1da177e4
LT		 614 }
615
f03a5670
KM		 616 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
617 which IO is outstanding. It's nulled out when the IO completes. */
618 if (!do_wait)
619 (STp->buffer)->last_SRpnt = SRpnt;
620
621 waiting = &STp->wait;
622 init_completion(waiting);
8b05b773 623 SRpnt->waiting = waiting;
1da177e4 624
6620742f 625 if (STp->buffer->do_dio) {
c982c368 626 mdata->page_order = 0;
6620742f
FT		 627 mdata->nr_entries = STp->buffer->sg_segs;
628 mdata->pages = STp->buffer->mapped_pages;
629 } else {
c982c368 630 mdata->page_order = STp->buffer->reserved_page_order;
6d476267
FT		 631 mdata->nr_entries =
632 DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order);
c982c368
FT		 633 mdata->pages = STp->buffer->reserved_pages;
634 mdata->offset = 0;
6d476267
FT		 635 }
636
8b05b773
MC		 637 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
638 STp->buffer->cmdstat.have_sense = 0;
639 STp->buffer->syscall_result = 0;
640
6620742f
FT		 641 ret = st_scsi_execute(SRpnt, cmd, direction, NULL, bytes, timeout,
642 retries);
6d476267 643 if (ret) {
8b05b773
MC		 644 /* could not allocate the buffer or request was too large */
645 (STp->buffer)->syscall_result = (-EBUSY);
787926b1 646 (STp->buffer)->last_SRpnt = NULL;
6d476267 647 } else if (do_wait) {
f03a5670 648 wait_for_completion(waiting);
8b05b773 649 SRpnt->waiting = NULL;
1da177e4
LT		 650 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
651 }
8b05b773 652
1da177e4
LT		 653 return SRpnt;
654}
655
656
657/* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
658 write has been correct but EOM early warning reached, -EIO if write ended in
659 error or zero if write successful. Asynchronous writes are used only in
660 variable block mode. */
661static int write_behind_check(struct scsi_tape * STp)
662{
663 int retval = 0;
664 struct st_buffer *STbuffer;
665 struct st_partstat *STps;
666 struct st_cmdstatus *cmdstatp;
8b05b773 667 struct st_request *SRpnt;
1da177e4
LT		 668
669 STbuffer = STp->buffer;
670 if (!STbuffer->writing)
671 return 0;
672
b30d8bca 673 DEB(
1da177e4
LT		 674 if (STp->write_pending)
675 STp->nbr_waits++;
676 else
677 STp->nbr_finished++;
b30d8bca 678 ) /* end DEB */
1da177e4
LT		 679
680 wait_for_completion(&(STp->wait));
f03a5670
KM		 681 SRpnt = STbuffer->last_SRpnt;
682 STbuffer->last_SRpnt = NULL;
8b05b773 683 SRpnt->waiting = NULL;
1da177e4 684
f03a5670 685 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
8b05b773 686 st_release_request(SRpnt);
1da177e4
LT		 687
688 STbuffer->buffer_bytes -= STbuffer->writing;
689 STps = &(STp->ps[STp->partition]);
690 if (STps->drv_block >= 0) {
691 if (STp->block_size == 0)
692 STps->drv_block++;
693 else
694 STps->drv_block += STbuffer->writing / STp->block_size;
695 }
696
697 cmdstatp = &STbuffer->cmdstat;
698 if (STbuffer->syscall_result) {
699 retval = -EIO;
700 if (cmdstatp->have_sense && !cmdstatp->deferred &&
701 (cmdstatp->flags & SENSE_EOM) &&
702 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
703 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
704 /* EOM at write-behind, has all data been written? */
705 if (!cmdstatp->remainder_valid ||
706 cmdstatp->uremainder64 == 0)
707 retval = -ENOSPC;
708 }
709 if (retval == -EIO)
710 STps->drv_block = -1;
711 }
712 STbuffer->writing = 0;
713
714 DEB(if (debugging && retval)
b30d8bca
HR		 715 st_printk(ST_DEB_MSG, STp,
716 "Async write error %x, return value %d.\n",
717 STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
1da177e4
LT		 718
719 return retval;
720}
721
722
723/* Step over EOF if it has been inadvertently crossed (ioctl not used because
724 it messes up the block number). */
725static int cross_eof(struct scsi_tape * STp, int forward)
726{
8b05b773 727 struct st_request *SRpnt;
1da177e4
LT		 728 unsigned char cmd[MAX_COMMAND_SIZE];
729
730 cmd[0] = SPACE;
731 cmd[1] = 0x01; /* Space FileMarks */
732 if (forward) {
733 cmd[2] = cmd[3] = 0;
734 cmd[4] = 1;
735 } else
736 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
737 cmd[5] = 0;
738
b30d8bca
HR		 739 DEBC_printk(STp, "Stepping over filemark %s.\n",
740 forward ? "forward" : "backward");
1da177e4 741
02ae2c0e
KM		 742 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
743 STp->device->request_queue->rq_timeout,
744 MAX_RETRIES, 1);
1da177e4 745 if (!SRpnt)
02ae2c0e 746 return (STp->buffer)->syscall_result;
39ade4b1 747
02ae2c0e
KM		 748 st_release_request(SRpnt);
749 SRpnt = NULL;
1da177e4
LT		 750
751 if ((STp->buffer)->cmdstat.midlevel_result != 0)
b30d8bca
HR		 752 st_printk(KERN_ERR, STp,
753 "Stepping over filemark %s failed.\n",
754 forward ? "forward" : "backward");
1da177e4 755
02ae2c0e 756 return (STp->buffer)->syscall_result;
1da177e4
LT		 757}
758
759
760/* Flush the write buffer (never need to write if variable blocksize). */
8ef8d594 761static int st_flush_write_buffer(struct scsi_tape * STp)
1da177e4 762{
786231af 763 int transfer, blks;
1da177e4
LT		 764 int result;
765 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 766 struct st_request *SRpnt;
1da177e4
LT		 767 struct st_partstat *STps;
768
769 result = write_behind_check(STp);
770 if (result)
771 return result;
772
773 result = 0;
774 if (STp->dirty == 1) {
775
786231af 776 transfer = STp->buffer->buffer_bytes;
b30d8bca 777 DEBC_printk(STp, "Flushing %d bytes.\n", transfer);
1da177e4 778
1da177e4
LT		 779 memset(cmd, 0, MAX_COMMAND_SIZE);
780 cmd[0] = WRITE_6;
781 cmd[1] = 1;
782 blks = transfer / STp->block_size;
783 cmd[2] = blks >> 16;
784 cmd[3] = blks >> 8;
785 cmd[4] = blks;
786
787 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
a02488ed
JB		 788 STp->device->request_queue->rq_timeout,
789 MAX_WRITE_RETRIES, 1);
1da177e4
LT		 790 if (!SRpnt)
791 return (STp->buffer)->syscall_result;
792
793 STps = &(STp->ps[STp->partition]);
794 if ((STp->buffer)->syscall_result != 0) {
795 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
796
797 if (cmdstatp->have_sense && !cmdstatp->deferred &&
798 (cmdstatp->flags & SENSE_EOM) &&
799 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
800 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
801 (!cmdstatp->remainder_valid ||
802 cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
803 STp->dirty = 0;
804 (STp->buffer)->buffer_bytes = 0;
805 if (STps->drv_block >= 0)
806 STps->drv_block += blks;
807 result = (-ENOSPC);
808 } else {
b30d8bca 809 st_printk(KERN_ERR, STp, "Error on flush.\n");
1da177e4
LT		 810 STps->drv_block = (-1);
811 result = (-EIO);
812 }
813 } else {
814 if (STps->drv_block >= 0)
815 STps->drv_block += blks;
816 STp->dirty = 0;
817 (STp->buffer)->buffer_bytes = 0;
818 }
8b05b773 819 st_release_request(SRpnt);
1da177e4
LT		 820 SRpnt = NULL;
821 }
822 return result;
823}
824
825
826/* Flush the tape buffer. The tape will be positioned correctly unless
827 seek_next is true. */
828static int flush_buffer(struct scsi_tape *STp, int seek_next)
829{
830 int backspace, result;
831 struct st_buffer *STbuffer;
832 struct st_partstat *STps;
833
834 STbuffer = STp->buffer;
835
836 /*
837 * If there was a bus reset, block further access
838 * to this device.
839 */
840 if (STp->pos_unknown)
841 return (-EIO);
842
843 if (STp->ready != ST_READY)
844 return 0;
845 STps = &(STp->ps[STp->partition]);
846 if (STps->rw == ST_WRITING) /* Writing */
8ef8d594 847 return st_flush_write_buffer(STp);
1da177e4
LT		 848
849 if (STp->block_size == 0)
850 return 0;
851
852 backspace = ((STp->buffer)->buffer_bytes +
853 (STp->buffer)->read_pointer) / STp->block_size -
854 ((STp->buffer)->read_pointer + STp->block_size - 1) /
855 STp->block_size;
856 (STp->buffer)->buffer_bytes = 0;
857 (STp->buffer)->read_pointer = 0;
858 result = 0;
859 if (!seek_next) {
860 if (STps->eof == ST_FM_HIT) {
861 result = cross_eof(STp, 0); /* Back over the EOF hit */
862 if (!result)
863 STps->eof = ST_NOEOF;
864 else {
865 if (STps->drv_file >= 0)
866 STps->drv_file++;
867 STps->drv_block = 0;
868 }
869 }
870 if (!result && backspace > 0)
871 result = st_int_ioctl(STp, MTBSR, backspace);
872 } else if (STps->eof == ST_FM_HIT) {
873 if (STps->drv_file >= 0)
874 STps->drv_file++;
875 STps->drv_block = 0;
876 STps->eof = ST_NOEOF;
877 }
878 return result;
879
880}
881\f
882/* Set the mode parameters */
883static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
884{
885 int set_it = 0;
886 unsigned long arg;
1da177e4
LT		 887
888 if (!STp->density_changed &&
889 STm->default_density >= 0 &&
890 STm->default_density != STp->density) {
891 arg = STm->default_density;
892 set_it = 1;
893 } else
894 arg = STp->density;
895 arg <<= MT_ST_DENSITY_SHIFT;
896 if (!STp->blksize_changed &&
897 STm->default_blksize >= 0 &&
898 STm->default_blksize != STp->block_size) {
899 arg |= STm->default_blksize;
900 set_it = 1;
901 } else
902 arg |= STp->block_size;
903 if (set_it &&
904 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
b30d8bca
HR		 905 st_printk(KERN_WARNING, STp,
906 "Can't set default block size to %d bytes "
907 "and density %x.\n",
908 STm->default_blksize, STm->default_density);
1da177e4
LT		 909 if (modes_defined)
910 return (-EINVAL);
911 }
912 return 0;
913}
914
915
8b05b773 916/* Lock or unlock the drive door. Don't use when st_request allocated. */
1da177e4
LT		 917static int do_door_lock(struct scsi_tape * STp, int do_lock)
918{
dccfa688 919 int retval;
1da177e4 920
b30d8bca 921 DEBC_printk(STp, "%socking drive door.\n", do_lock ? "L" : "Unl");
dccfa688
CH		 922
923 retval = scsi_set_medium_removal(STp->device,
924 do_lock ? SCSI_REMOVAL_PREVENT : SCSI_REMOVAL_ALLOW);
925 if (!retval)
1da177e4 926 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
dccfa688 927 else
1da177e4 928 STp->door_locked = ST_LOCK_FAILS;
1da177e4
LT		 929 return retval;
930}
931
932
933/* Set the internal state after reset */
934static void reset_state(struct scsi_tape *STp)
935{
936 int i;
937 struct st_partstat *STps;
938
939 STp->pos_unknown = 0;
940 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
941 STps = &(STp->ps[i]);
942 STps->rw = ST_IDLE;
943 STps->eof = ST_NOEOF;
944 STps->at_sm = 0;
945 STps->last_block_valid = 0;
946 STps->drv_block = -1;
947 STps->drv_file = -1;
948 }
949 if (STp->can_partitions) {
950 STp->partition = find_partition(STp);
951 if (STp->partition < 0)
952 STp->partition = 0;
953 STp->new_partition = STp->partition;
954 }
955}
956\f
957/* Test if the drive is ready. Returns either one of the codes below or a negative system
958 error code. */
959#define CHKRES_READY 0
960#define CHKRES_NEW_SESSION 1
961#define CHKRES_NOT_READY 2
962#define CHKRES_NO_TAPE 3
963
964#define MAX_ATTENTIONS 10
965
966static int test_ready(struct scsi_tape *STp, int do_wait)
967{
968 int attentions, waits, max_wait, scode;
969 int retval = CHKRES_READY, new_session = 0;
970 unsigned char cmd[MAX_COMMAND_SIZE];
02ae2c0e 971 struct st_request *SRpnt = NULL;
1da177e4
LT		 972 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
973
974 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
975
976 for (attentions=waits=0; ; ) {
977 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
978 cmd[0] = TEST_UNIT_READY;
02ae2c0e
KM		 979 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
980 STp->long_timeout, MAX_READY_RETRIES, 1);
1da177e4 981
02ae2c0e
KM		 982 if (!SRpnt) {
983 retval = (STp->buffer)->syscall_result;
1da177e4 984 break;
02ae2c0e 985 }
1da177e4
LT		 986
987 if (cmdstatp->have_sense) {
988
989 scode = cmdstatp->sense_hdr.sense_key;
990
991 if (scode == UNIT_ATTENTION) { /* New media? */
992 new_session = 1;
993 if (attentions < MAX_ATTENTIONS) {
994 attentions++;
995 continue;
996 }
997 else {
998 retval = (-EIO);
999 break;
1000 }
1001 }
1002
1003 if (scode == NOT_READY) {
1004 if (waits < max_wait) {
1005 if (msleep_interruptible(1000)) {
1006 retval = (-EINTR);
1007 break;
1008 }
1009 waits++;
1010 continue;
1011 }
1012 else {
1013 if ((STp->device)->scsi_level >= SCSI_2 &&
1014 cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
1015 retval = CHKRES_NO_TAPE;
1016 else
1017 retval = CHKRES_NOT_READY;
1018 break;
1019 }
1020 }
1021 }
1022
1023 retval = (STp->buffer)->syscall_result;
1024 if (!retval)
1025 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
1026 break;
1027 }
1028
02ae2c0e
KM		 1029 if (SRpnt != NULL)
1030 st_release_request(SRpnt);
1da177e4
LT		 1031 return retval;
1032}
1033
1034
1035/* See if the drive is ready and gather information about the tape. Return values:
1036 < 0 negative error code from errno.h
1037 0 drive ready
1038 1 drive not ready (possibly no tape)
1039*/
1040static int check_tape(struct scsi_tape *STp, struct file *filp)
1041{
1042 int i, retval, new_session = 0, do_wait;
1043 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
1044 unsigned short st_flags = filp->f_flags;
8b05b773 1045 struct st_request *SRpnt = NULL;
1da177e4
LT		 1046 struct st_modedef *STm;
1047 struct st_partstat *STps;
496ad9aa 1048 struct inode *inode = file_inode(filp);
1da177e4
LT		 1049 int mode = TAPE_MODE(inode);
1050
1051 STp->ready = ST_READY;
1052
1053 if (mode != STp->current_mode) {
b30d8bca
HR		 1054 DEBC_printk(STp, "Mode change from %d to %d.\n",
1055 STp->current_mode, mode);
1da177e4
LT		 1056 new_session = 1;
1057 STp->current_mode = mode;
1058 }
1059 STm = &(STp->modes[STp->current_mode]);
1060
1061 saved_cleaning = STp->cleaning_req;
1062 STp->cleaning_req = 0;
1063
1064 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
1065 retval = test_ready(STp, do_wait);
1066
1067 if (retval < 0)
1068 goto err_out;
1069
1070 if (retval == CHKRES_NEW_SESSION) {
1071 STp->pos_unknown = 0;
1072 STp->partition = STp->new_partition = 0;
1073 if (STp->can_partitions)
1074 STp->nbr_partitions = 1; /* This guess will be updated later
1075 if necessary */
1076 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1077 STps = &(STp->ps[i]);
1078 STps->rw = ST_IDLE;
1079 STps->eof = ST_NOEOF;
1080 STps->at_sm = 0;
1081 STps->last_block_valid = 0;
1082 STps->drv_block = 0;
1083 STps->drv_file = 0;
1084 }
1085 new_session = 1;
1086 }
1087 else {
1088 STp->cleaning_req |= saved_cleaning;
1089
1090 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
1091 if (retval == CHKRES_NO_TAPE)
1092 STp->ready = ST_NO_TAPE;
1093 else
1094 STp->ready = ST_NOT_READY;
1095
1096 STp->density = 0; /* Clear the erroneous "residue" */
1097 STp->write_prot = 0;
1098 STp->block_size = 0;
1099 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
1100 STp->partition = STp->new_partition = 0;
1101 STp->door_locked = ST_UNLOCKED;
1102 return CHKRES_NOT_READY;
1103 }
1104 }
1105
1106 if (STp->omit_blklims)
1107 STp->min_block = STp->max_block = (-1);
1108 else {
1109 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1110 cmd[0] = READ_BLOCK_LIMITS;
1111
02ae2c0e
KM		 1112 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
1113 STp->device->request_queue->rq_timeout,
1114 MAX_READY_RETRIES, 1);
1115 if (!SRpnt) {
1116 retval = (STp->buffer)->syscall_result;
1da177e4
LT		 1117 goto err_out;
1118 }
1119
8b05b773 1120 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
1da177e4
LT		 1121 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1122 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1123 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1124 (STp->buffer)->b_data[5];
1125 if ( DEB( debugging || ) !STp->inited)
b30d8bca
HR		 1126 st_printk(KERN_INFO, STp,
1127 "Block limits %d - %d bytes.\n",
1128 STp->min_block, STp->max_block);
1da177e4
LT		 1129 } else {
1130 STp->min_block = STp->max_block = (-1);
b30d8bca 1131 DEBC_printk(STp, "Can't read block limits.\n");
1da177e4
LT		 1132 }
1133 }
1134
1135 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1136 cmd[0] = MODE_SENSE;
1137 cmd[4] = 12;
1138
02ae2c0e
KM		 1139 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1140 STp->device->request_queue->rq_timeout,
1141 MAX_READY_RETRIES, 1);
1142 if (!SRpnt) {
1143 retval = (STp->buffer)->syscall_result;
1da177e4
LT		 1144 goto err_out;
1145 }
1146
1147 if ((STp->buffer)->syscall_result != 0) {
b30d8bca 1148 DEBC_printk(STp, "No Mode Sense.\n");
1da177e4
LT		 1149 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
1150 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */
1151 STp->drv_write_prot = 0;
1152 } else {
b30d8bca
HR		 1153 DEBC_printk(STp,"Mode sense. Length %d, "
1154 "medium %x, WBS %x, BLL %d\n",
1155 (STp->buffer)->b_data[0],
1156 (STp->buffer)->b_data[1],
1157 (STp->buffer)->b_data[2],
1158 (STp->buffer)->b_data[3]);
1da177e4
LT		 1159
1160 if ((STp->buffer)->b_data[3] >= 8) {
1161 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1162 STp->density = (STp->buffer)->b_data[4];
1163 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1164 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
b30d8bca
HR		 1165 DEBC_printk(STp, "Density %x, tape length: %x, "
1166 "drv buffer: %d\n",
1167 STp->density,
1168 (STp->buffer)->b_data[5] * 65536 +
1169 (STp->buffer)->b_data[6] * 256 +
1170 (STp->buffer)->b_data[7],
1171 STp->drv_buffer);
1da177e4
LT		 1172 }
1173 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
c743e44f 1174 if (!STp->drv_buffer && STp->immediate_filemark) {
b30d8bca
HR		 1175 st_printk(KERN_WARNING, STp,
1176 "non-buffered tape: disabling "
1177 "writing immediate filemarks\n");
c743e44f
LD		 1178 STp->immediate_filemark = 0;
1179 }
1da177e4 1180 }
8b05b773 1181 st_release_request(SRpnt);
1da177e4 1182 SRpnt = NULL;
b30d8bca 1183 STp->inited = 1;
1da177e4
LT		 1184
1185 if (STp->block_size > 0)
1186 (STp->buffer)->buffer_blocks =
b30d8bca 1187 (STp->buffer)->buffer_size / STp->block_size;
1da177e4
LT		 1188 else
1189 (STp->buffer)->buffer_blocks = 1;
1190 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1191
b30d8bca
HR		 1192 DEBC_printk(STp, "Block size: %d, buffer size: %d (%d blocks).\n",
1193 STp->block_size, (STp->buffer)->buffer_size,
1194 (STp->buffer)->buffer_blocks);
1da177e4
LT		 1195
1196 if (STp->drv_write_prot) {
1197 STp->write_prot = 1;
1198
b30d8bca 1199 DEBC_printk(STp, "Write protected\n");
1da177e4
LT		 1200
1201 if (do_wait &&
1202 ((st_flags & O_ACCMODE) == O_WRONLY ||
1203 (st_flags & O_ACCMODE) == O_RDWR)) {
1204 retval = (-EROFS);
1205 goto err_out;
1206 }
1207 }
1208
1209 if (STp->can_partitions && STp->nbr_partitions < 1) {
1210 /* This code is reached when the device is opened for the first time
1211 after the driver has been initialized with tape in the drive and the
1212 partition support has been enabled. */
b30d8bca 1213 DEBC_printk(STp, "Updating partition number in status.\n");
1da177e4
LT		 1214 if ((STp->partition = find_partition(STp)) < 0) {
1215 retval = STp->partition;
1216 goto err_out;
1217 }
1218 STp->new_partition = STp->partition;
1219 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1220 }
1221
1222 if (new_session) { /* Change the drive parameters for the new mode */
1223 STp->density_changed = STp->blksize_changed = 0;
1224 STp->compression_changed = 0;
1225 if (!(STm->defaults_for_writes) &&
1226 (retval = set_mode_densblk(STp, STm)) < 0)
1227 goto err_out;
1228
1229 if (STp->default_drvbuffer != 0xff) {
1230 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
b30d8bca
HR		 1231 st_printk(KERN_WARNING, STp,
1232 "Can't set default drive "
1233 "buffering to %d.\n",
1234 STp->default_drvbuffer);
1da177e4
LT		 1235 }
1236 }
1237
1238 return CHKRES_READY;
1239
1240 err_out:
1241 return retval;
1242}
1243
1244
b3369c68 1245\f/* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1da177e4
LT		 1246 module count. */
1247static int st_open(struct inode *inode, struct file *filp)
1248{
1249 int i, retval = (-EIO);
46a243f7 1250 int resumed = 0;
1da177e4
LT		 1251 struct scsi_tape *STp;
1252 struct st_partstat *STps;
1253 int dev = TAPE_NR(inode);
1da177e4
LT		 1254
1255 /*
1256 * We really want to do nonseekable_open(inode, filp); here, but some
1257 * versions of tar incorrectly call lseek on tapes and bail out if that
1258 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1259 */
1260 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1261
b3369c68 1262 if (!(STp = scsi_tape_get(dev))) {
f03a5670 1263 return -ENXIO;
b3369c68 1264 }
f03a5670 1265
1da177e4 1266 filp->private_data = STp;
1da177e4 1267
6c648d95 1268 spin_lock(&st_use_lock);
1da177e4 1269 if (STp->in_use) {
6c648d95 1270 spin_unlock(&st_use_lock);
f03a5670 1271 scsi_tape_put(STp);
b30d8bca 1272 DEBC_printk(STp, "Device already in use.\n");
1da177e4
LT		 1273 return (-EBUSY);
1274 }
1275
1da177e4 1276 STp->in_use = 1;
6c648d95 1277 spin_unlock(&st_use_lock);
1da177e4
LT		 1278 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1279
46a243f7
ON		 1280 if (scsi_autopm_get_device(STp->device) < 0) {
1281 retval = -EIO;
1282 goto err_out;
1283 }
1284 resumed = 1;
1da177e4
LT		 1285 if (!scsi_block_when_processing_errors(STp->device)) {
1286 retval = (-ENXIO);
1287 goto err_out;
1288 }
1289
1290 /* See that we have at least a one page buffer available */
1291 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
b30d8bca
HR		 1292 st_printk(KERN_WARNING, STp,
1293 "Can't allocate one page tape buffer.\n");
1da177e4
LT		 1294 retval = (-EOVERFLOW);
1295 goto err_out;
1296 }
1297
40f6b36c 1298 (STp->buffer)->cleared = 0;
1da177e4
LT		 1299 (STp->buffer)->writing = 0;
1300 (STp->buffer)->syscall_result = 0;
1301
1302 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1303
1304 STp->dirty = 0;
1305 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1306 STps = &(STp->ps[i]);
1307 STps->rw = ST_IDLE;
1308 }
9abe16c6 1309 STp->try_dio_now = STp->try_dio;
1da177e4
LT		 1310 STp->recover_count = 0;
1311 DEB( STp->nbr_waits = STp->nbr_finished = 0;
deee13df 1312 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
1da177e4
LT		 1313
1314 retval = check_tape(STp, filp);
1315 if (retval < 0)
1316 goto err_out;
1317 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1318 retval != CHKRES_READY) {
413f7327
KM		 1319 if (STp->ready == NO_TAPE)
1320 retval = (-ENOMEDIUM);
1321 else
1322 retval = (-EIO);
1da177e4
LT		 1323 goto err_out;
1324 }
1325 return 0;
1326
1327 err_out:
1328 normalize_buffer(STp->buffer);
0644f539 1329 spin_lock(&st_use_lock);
1da177e4 1330 STp->in_use = 0;
0644f539 1331 spin_unlock(&st_use_lock);
f03a5670 1332 scsi_tape_put(STp);
46a243f7
ON		 1333 if (resumed)
1334 scsi_autopm_put_device(STp->device);
1da177e4
LT		 1335 return retval;
1336
1337}
1338\f
1339
1340/* Flush the tape buffer before close */
75e1fcc0 1341static int st_flush(struct file *filp, fl_owner_t id)
1da177e4
LT		 1342{
1343 int result = 0, result2;
1344 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 1345 struct st_request *SRpnt;
1da177e4
LT		 1346 struct scsi_tape *STp = filp->private_data;
1347 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1348 struct st_partstat *STps = &(STp->ps[STp->partition]);
1da177e4
LT		 1349
1350 if (file_count(filp) > 1)
1351 return 0;
1352
1353 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
8ef8d594 1354 result = st_flush_write_buffer(STp);
1da177e4
LT		 1355 if (result != 0 && result != (-ENOSPC))
1356 goto out;
1357 }
1358
1359 if (STp->can_partitions &&
1360 (result2 = switch_partition(STp)) < 0) {
b30d8bca 1361 DEBC_printk(STp, "switch_partition at close failed.\n");
1da177e4
LT		 1362 if (result == 0)
1363 result = result2;
1364 goto out;
1365 }
1366
1367 DEBC( if (STp->nbr_requests)
b30d8bca
HR		 1368 st_printk(KERN_DEBUG, STp,
1369 "Number of r/w requests %d, dio used in %d, "
1370 "pages %d.\n", STp->nbr_requests, STp->nbr_dio,
1371 STp->nbr_pages));
1da177e4
LT		 1372
1373 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1374 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1375
b30d8bca
HR		 1376#if DEBUG
1377 DEBC_printk(STp, "Async write waits %d, finished %d.\n",
1378 STp->nbr_waits, STp->nbr_finished);
1379#endif
1da177e4
LT		 1380 memset(cmd, 0, MAX_COMMAND_SIZE);
1381 cmd[0] = WRITE_FILEMARKS;
c743e44f
LD		 1382 if (STp->immediate_filemark)
1383 cmd[1] = 1;
1da177e4
LT		 1384 cmd[4] = 1 + STp->two_fm;
1385
02ae2c0e
KM		 1386 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1387 STp->device->request_queue->rq_timeout,
1388 MAX_WRITE_RETRIES, 1);
1da177e4 1389 if (!SRpnt) {
02ae2c0e 1390 result = (STp->buffer)->syscall_result;
1da177e4
LT		 1391 goto out;
1392 }
1393
1394 if (STp->buffer->syscall_result == 0 ||
1395 (cmdstatp->have_sense && !cmdstatp->deferred &&
1396 (cmdstatp->flags & SENSE_EOM) &&
1397 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1398 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1399 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1400 /* Write successful at EOM */
8b05b773 1401 st_release_request(SRpnt);
1da177e4
LT		 1402 SRpnt = NULL;
1403 if (STps->drv_file >= 0)
1404 STps->drv_file++;
1405 STps->drv_block = 0;
1406 if (STp->two_fm)
1407 cross_eof(STp, 0);
1408 STps->eof = ST_FM;
1409 }
1410 else { /* Write error */
8b05b773 1411 st_release_request(SRpnt);
1da177e4 1412 SRpnt = NULL;
b30d8bca
HR		 1413 st_printk(KERN_ERR, STp,
1414 "Error on write filemark.\n");
1da177e4
LT		 1415 if (result == 0)
1416 result = (-EIO);
1417 }
1418
b30d8bca 1419 DEBC_printk(STp, "Buffer flushed, %d EOF(s) written\n", cmd[4]);
1da177e4
LT		 1420 } else if (!STp->rew_at_close) {
1421 STps = &(STp->ps[STp->partition]);
1422 if (!STm->sysv || STps->rw != ST_READING) {
1423 if (STp->can_bsr)
1424 result = flush_buffer(STp, 0);
1425 else if (STps->eof == ST_FM_HIT) {
1426 result = cross_eof(STp, 0);
1427 if (result) {
1428 if (STps->drv_file >= 0)
1429 STps->drv_file++;
1430 STps->drv_block = 0;
1431 STps->eof = ST_FM;
1432 } else
1433 STps->eof = ST_NOEOF;
1434 }
1435 } else if ((STps->eof == ST_NOEOF &&
1436 !(result = cross_eof(STp, 1))) ||
1437 STps->eof == ST_FM_HIT) {
1438 if (STps->drv_file >= 0)
1439 STps->drv_file++;
1440 STps->drv_block = 0;
1441 STps->eof = ST_FM;
1442 }
1443 }
1444
1445 out:
1446 if (STp->rew_at_close) {
1447 result2 = st_int_ioctl(STp, MTREW, 1);
1448 if (result == 0)
1449 result = result2;
1450 }
1451 return result;
1452}
1453
1454
1455/* Close the device and release it. BKL is not needed: this is the only thread
1456 accessing this tape. */
1457static int st_release(struct inode *inode, struct file *filp)
1458{
1459 int result = 0;
1460 struct scsi_tape *STp = filp->private_data;
1461
1462 if (STp->door_locked == ST_LOCKED_AUTO)
1463 do_door_lock(STp, 0);
1464
1465 normalize_buffer(STp->buffer);
6c648d95 1466 spin_lock(&st_use_lock);
1da177e4 1467 STp->in_use = 0;
6c648d95 1468 spin_unlock(&st_use_lock);
46a243f7 1469 scsi_autopm_put_device(STp->device);
f03a5670 1470 scsi_tape_put(STp);
1da177e4
LT		 1471
1472 return result;
1473}
1474\f
1475/* The checks common to both reading and writing */
1476static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1477{
1478 ssize_t retval = 0;
1479
1480 /*
1481 * If we are in the middle of error recovery, don't let anyone
1482 * else try and use this device. Also, if error recovery fails, it
1483 * may try and take the device offline, in which case all further
1484 * access to the device is prohibited.
1485 */
1486 if (!scsi_block_when_processing_errors(STp->device)) {
1487 retval = (-ENXIO);
1488 goto out;
1489 }
1490
1491 if (STp->ready != ST_READY) {
1492 if (STp->ready == ST_NO_TAPE)
1493 retval = (-ENOMEDIUM);
1494 else
1495 retval = (-EIO);
1496 goto out;
1497 }
1498
1499 if (! STp->modes[STp->current_mode].defined) {
1500 retval = (-ENXIO);
1501 goto out;
1502 }
1503
1504
1505 /*
1506 * If there was a bus reset, block further access
1507 * to this device.
1508 */
1509 if (STp->pos_unknown) {
1510 retval = (-EIO);
1511 goto out;
1512 }
1513
1514 if (count == 0)
1515 goto out;
1516
b30d8bca 1517 DEB(
1da177e4 1518 if (!STp->in_use) {
b30d8bca
HR		 1519 st_printk(ST_DEB_MSG, STp,
1520 "Incorrect device.\n");
1da177e4
LT		 1521 retval = (-EIO);
1522 goto out;
1523 } ) /* end DEB */
1524
1525 if (STp->can_partitions &&
1526 (retval = switch_partition(STp)) < 0)
1527 goto out;
1528
1529 if (STp->block_size == 0 && STp->max_block > 0 &&
1530 (count < STp->min_block || count > STp->max_block)) {
1531 retval = (-EINVAL);
1532 goto out;
1533 }
1534
1535 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1536 !do_door_lock(STp, 1))
1537 STp->door_locked = ST_LOCKED_AUTO;
1538
1539 out:
1540 return retval;
1541}
1542
1543
1544static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1545 size_t count, int is_read)
1546{
1547 int i, bufsize, retval = 0;
1548 struct st_buffer *STbp = STp->buffer;
1549
1550 if (is_read)
9abe16c6 1551 i = STp->try_dio_now && try_rdio;
1da177e4 1552 else
9abe16c6 1553 i = STp->try_dio_now && try_wdio;
8b05b773 1554
1da177e4
LT		 1555 if (i && ((unsigned long)buf & queue_dma_alignment(
1556 STp->device->request_queue)) == 0) {
6620742f
FT		 1557 i = sgl_map_user_pages(STbp, STbp->use_sg, (unsigned long)buf,
1558 count, (is_read ? READ : WRITE));
1da177e4
LT		 1559 if (i > 0) {
1560 STbp->do_dio = i;
1561 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1562 }
1563 else
1564 STbp->do_dio = 0; /* fall back to buffering with any error */
1565 STbp->sg_segs = STbp->do_dio;
1da177e4
LT		 1566 DEB(
1567 if (STbp->do_dio) {
1568 STp->nbr_dio++;
1569 STp->nbr_pages += STbp->do_dio;
1da177e4
LT		 1570 }
1571 )
1572 } else
1573 STbp->do_dio = 0;
1574 DEB( STp->nbr_requests++; )
1575
1576 if (!STbp->do_dio) {
1577 if (STp->block_size)
1578 bufsize = STp->block_size > st_fixed_buffer_size ?
1579 STp->block_size : st_fixed_buffer_size;
40f6b36c 1580 else {
1da177e4 1581 bufsize = count;
40f6b36c
KM		 1582 /* Make sure that data from previous user is not leaked even if
1583 HBA does not return correct residual */
1584 if (is_read && STp->sili && !STbp->cleared)
1585 clear_buffer(STbp);
1586 }
1587
1da177e4
LT		 1588 if (bufsize > STbp->buffer_size &&
1589 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
b30d8bca
HR		 1590 st_printk(KERN_WARNING, STp,
1591 "Can't allocate %d byte tape buffer.\n",
1592 bufsize);
1da177e4
LT		 1593 retval = (-EOVERFLOW);
1594 goto out;
1595 }
1596 if (STp->block_size)
1597 STbp->buffer_blocks = bufsize / STp->block_size;
1598 }
1599
1600 out:
1601 return retval;
1602}
1603
1604
1605/* Can be called more than once after each setup_buffer() */
787926b1 1606static void release_buffering(struct scsi_tape *STp, int is_read)
1da177e4
LT		 1607{
1608 struct st_buffer *STbp;
1609
1610 STbp = STp->buffer;
1611 if (STbp->do_dio) {
6620742f 1612 sgl_unmap_user_pages(STbp, STbp->do_dio, is_read);
1da177e4 1613 STbp->do_dio = 0;
787926b1 1614 STbp->sg_segs = 0;
1da177e4
LT		 1615 }
1616}
1617
1618
1619/* Write command */
1620static ssize_t
1621st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1622{
1623 ssize_t total;
1624 ssize_t i, do_count, blks, transfer;
1625 ssize_t retval;
1626 int undone, retry_eot = 0, scode;
1627 int async_write;
1628 unsigned char cmd[MAX_COMMAND_SIZE];
1629 const char __user *b_point;
8b05b773 1630 struct st_request *SRpnt = NULL;
1da177e4
LT		 1631 struct scsi_tape *STp = filp->private_data;
1632 struct st_modedef *STm;
1633 struct st_partstat *STps;
1634 struct st_buffer *STbp;
1da177e4 1635
28f85009 1636 if (mutex_lock_interruptible(&STp->lock))
1da177e4
LT		 1637 return -ERESTARTSYS;
1638
1639 retval = rw_checks(STp, filp, count);
1640 if (retval || count == 0)
1641 goto out;
1642
1643 /* Write must be integral number of blocks */
1644 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
b30d8bca
HR		 1645 st_printk(KERN_WARNING, STp,
1646 "Write not multiple of tape block size.\n");
1da177e4
LT		 1647 retval = (-EINVAL);
1648 goto out;
1649 }
1650
1651 STm = &(STp->modes[STp->current_mode]);
1652 STps = &(STp->ps[STp->partition]);
1653
1654 if (STp->write_prot) {
1655 retval = (-EACCES);
1656 goto out;
1657 }
1658
1659
1660 if (STps->rw == ST_READING) {
1661 retval = flush_buffer(STp, 0);
1662 if (retval)
1663 goto out;
1664 STps->rw = ST_WRITING;
1665 } else if (STps->rw != ST_WRITING &&
1666 STps->drv_file == 0 && STps->drv_block == 0) {
1667 if ((retval = set_mode_densblk(STp, STm)) < 0)
1668 goto out;
1669 if (STm->default_compression != ST_DONT_TOUCH &&
1670 !(STp->compression_changed)) {
1671 if (st_compression(STp, (STm->default_compression == ST_YES))) {
b30d8bca
HR		 1672 st_printk(KERN_WARNING, STp,
1673 "Can't set default compression.\n");
1da177e4
LT		 1674 if (modes_defined) {
1675 retval = (-EINVAL);
1676 goto out;
1677 }
1678 }
1679 }
1680 }
1681
1682 STbp = STp->buffer;
1683 i = write_behind_check(STp);
1684 if (i) {
1685 if (i == -ENOSPC)
1686 STps->eof = ST_EOM_OK;
1687 else
1688 STps->eof = ST_EOM_ERROR;
1689 }
1690
1691 if (STps->eof == ST_EOM_OK) {
1692 STps->eof = ST_EOD_1; /* allow next write */
1693 retval = (-ENOSPC);
1694 goto out;
1695 }
1696 else if (STps->eof == ST_EOM_ERROR) {
1697 retval = (-EIO);
1698 goto out;
1699 }
1700
1701 /* Check the buffer readability in cases where copy_user might catch
1702 the problems after some tape movement. */
1703 if (STp->block_size != 0 &&
1704 !STbp->do_dio &&
1705 (copy_from_user(&i, buf, 1) != 0 ||
1706 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1707 retval = (-EFAULT);
1708 goto out;
1709 }
1710
1711 retval = setup_buffering(STp, buf, count, 0);
1712 if (retval)
1713 goto out;
1714
1715 total = count;
1716
1717 memset(cmd, 0, MAX_COMMAND_SIZE);
1718 cmd[0] = WRITE_6;
1719 cmd[1] = (STp->block_size != 0);
1720
1721 STps->rw = ST_WRITING;
1722
1723 b_point = buf;
1724 while (count > 0 && !retry_eot) {
1725
1726 if (STbp->do_dio) {
1727 do_count = count;
1728 }
1729 else {
1730 if (STp->block_size == 0)
1731 do_count = count;
1732 else {
1733 do_count = STbp->buffer_blocks * STp->block_size -
1734 STbp->buffer_bytes;
1735 if (do_count > count)
1736 do_count = count;
1737 }
1738
1739 i = append_to_buffer(b_point, STbp, do_count);
1740 if (i) {
1741 retval = i;
1742 goto out;
1743 }
1744 }
1745 count -= do_count;
1746 b_point += do_count;
1747
1748 async_write = STp->block_size == 0 && !STbp->do_dio &&
1749 STm->do_async_writes && STps->eof < ST_EOM_OK;
1750
1751 if (STp->block_size != 0 && STm->do_buffer_writes &&
9abe16c6 1752 !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1da177e4
LT		 1753 STbp->buffer_bytes < STbp->buffer_size) {
1754 STp->dirty = 1;
1755 /* Don't write a buffer that is not full enough. */
1756 if (!async_write && count == 0)
1757 break;
1758 }
1759
1760 retry_write:
1761 if (STp->block_size == 0)
1762 blks = transfer = do_count;
1763 else {
1764 if (!STbp->do_dio)
1765 blks = STbp->buffer_bytes;
1766 else
1767 blks = do_count;
1768 blks /= STp->block_size;
1769 transfer = blks * STp->block_size;
1770 }
1771 cmd[2] = blks >> 16;
1772 cmd[3] = blks >> 8;
1773 cmd[4] = blks;
1774
1775 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
a02488ed
JB		 1776 STp->device->request_queue->rq_timeout,
1777 MAX_WRITE_RETRIES, !async_write);
1da177e4
LT		 1778 if (!SRpnt) {
1779 retval = STbp->syscall_result;
1780 goto out;
1781 }
8b05b773 1782 if (async_write && !STbp->syscall_result) {
1da177e4
LT		 1783 STbp->writing = transfer;
1784 STp->dirty = !(STbp->writing ==
1785 STbp->buffer_bytes);
1786 SRpnt = NULL; /* Prevent releasing this request! */
1787 DEB( STp->write_pending = 1; )
1788 break;
1789 }
1790
1791 if (STbp->syscall_result != 0) {
1792 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1793
b30d8bca 1794 DEBC_printk(STp, "Error on write:\n");
1da177e4
LT		 1795 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1796 scode = cmdstatp->sense_hdr.sense_key;
1797 if (cmdstatp->remainder_valid)
1798 undone = (int)cmdstatp->uremainder64;
1799 else if (STp->block_size == 0 &&
1800 scode == VOLUME_OVERFLOW)
1801 undone = transfer;
1802 else
1803 undone = 0;
1804 if (STp->block_size != 0)
1805 undone *= STp->block_size;
1806 if (undone <= do_count) {
1807 /* Only data from this write is not written */
1808 count += undone;
626dcb1e 1809 b_point -= undone;
1da177e4
LT		 1810 do_count -= undone;
1811 if (STp->block_size)
1812 blks = (transfer - undone) / STp->block_size;
1813 STps->eof = ST_EOM_OK;
1814 /* Continue in fixed block mode if all written
1815 in this request but still something left to write
1816 (retval left to zero)
1817 */
1818 if (STp->block_size == 0 ||
1819 undone > 0 || count == 0)
1820 retval = (-ENOSPC); /* EOM within current request */
b30d8bca
HR		 1821 DEBC_printk(STp, "EOM with %d "
1822 "bytes unwritten.\n",
1823 (int)count);
1da177e4
LT		 1824 } else {
1825 /* EOT within data buffered earlier (possible only
1826 in fixed block mode without direct i/o) */
1827 if (!retry_eot && !cmdstatp->deferred &&
1828 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1829 move_buffer_data(STp->buffer, transfer - undone);
1830 retry_eot = 1;
1831 if (STps->drv_block >= 0) {
1832 STps->drv_block += (transfer - undone) /
1833 STp->block_size;
1834 }
1835 STps->eof = ST_EOM_OK;
b30d8bca
HR		 1836 DEBC_printk(STp, "Retry "
1837 "write of %d "
1838 "bytes at EOM.\n",
1839 STp->buffer->buffer_bytes);
1da177e4
LT		 1840 goto retry_write;
1841 }
1842 else {
1843 /* Either error within data buffered by driver or
1844 failed retry */
1845 count -= do_count;
1846 blks = do_count = 0;
1847 STps->eof = ST_EOM_ERROR;
1848 STps->drv_block = (-1); /* Too cautious? */
1849 retval = (-EIO); /* EOM for old data */
b30d8bca
HR		 1850 DEBC_printk(STp, "EOM with "
1851 "lost data.\n");
1da177e4
LT		 1852 }
1853 }
1854 } else {
1855 count += do_count;
1856 STps->drv_block = (-1); /* Too cautious? */
8b05b773 1857 retval = STbp->syscall_result;
1da177e4
LT		 1858 }
1859
1860 }
1861
1862 if (STps->drv_block >= 0) {
1863 if (STp->block_size == 0)
1864 STps->drv_block += (do_count > 0);
1865 else
1866 STps->drv_block += blks;
1867 }
1868
1869 STbp->buffer_bytes = 0;
1870 STp->dirty = 0;
1871
1872 if (retval || retry_eot) {
1873 if (count < total)
1874 retval = total - count;
1875 goto out;
1876 }
1877 }
1878
1879 if (STps->eof == ST_EOD_1)
1880 STps->eof = ST_EOM_OK;
1881 else if (STps->eof != ST_EOM_OK)
1882 STps->eof = ST_NOEOF;
1883 retval = total - count;
1884
1885 out:
1886 if (SRpnt != NULL)
8b05b773 1887 st_release_request(SRpnt);
787926b1 1888 release_buffering(STp, 0);
28f85009 1889 mutex_unlock(&STp->lock);
1da177e4
LT		 1890
1891 return retval;
1892}
1893\f
1894/* Read data from the tape. Returns zero in the normal case, one if the
1895 eof status has changed, and the negative error code in case of a
1896 fatal error. Otherwise updates the buffer and the eof state.
1897
1898 Does release user buffer mapping if it is set.
1899*/
1900static long read_tape(struct scsi_tape *STp, long count,
8b05b773 1901 struct st_request ** aSRpnt)
1da177e4
LT		 1902{
1903 int transfer, blks, bytes;
1904 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 1905 struct st_request *SRpnt;
1da177e4
LT		 1906 struct st_modedef *STm;
1907 struct st_partstat *STps;
1908 struct st_buffer *STbp;
1909 int retval = 0;
1da177e4
LT		 1910
1911 if (count == 0)
1912 return 0;
1913
1914 STm = &(STp->modes[STp->current_mode]);
1915 STps = &(STp->ps[STp->partition]);
1916 if (STps->eof == ST_FM_HIT)
1917 return 1;
1918 STbp = STp->buffer;
1919
1920 if (STp->block_size == 0)
1921 blks = bytes = count;
1922 else {
9abe16c6 1923 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1da177e4
LT		 1924 blks = (STp->buffer)->buffer_blocks;
1925 bytes = blks * STp->block_size;
1926 } else {
1927 bytes = count;
1928 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1929 bytes = (STp->buffer)->buffer_size;
1930 blks = bytes / STp->block_size;
1931 bytes = blks * STp->block_size;
1932 }
1933 }
1934
1935 memset(cmd, 0, MAX_COMMAND_SIZE);
1936 cmd[0] = READ_6;
1937 cmd[1] = (STp->block_size != 0);
40f6b36c
KM		 1938 if (!cmd[1] && STp->sili)
1939 cmd[1] |= 2;
1da177e4
LT		 1940 cmd[2] = blks >> 16;
1941 cmd[3] = blks >> 8;
1942 cmd[4] = blks;
1943
1944 SRpnt = *aSRpnt;
1945 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
a02488ed
JB		 1946 STp->device->request_queue->rq_timeout,
1947 MAX_RETRIES, 1);
787926b1 1948 release_buffering(STp, 1);
1da177e4
LT		 1949 *aSRpnt = SRpnt;
1950 if (!SRpnt)
1951 return STbp->syscall_result;
1952
1953 STbp->read_pointer = 0;
1954 STps->at_sm = 0;
1955
1956 /* Something to check */
1957 if (STbp->syscall_result) {
1958 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1959
1960 retval = 1;
b30d8bca
HR		 1961 DEBC_printk(STp,
1962 "Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1963 SRpnt->sense[0], SRpnt->sense[1],
1964 SRpnt->sense[2], SRpnt->sense[3],
1965 SRpnt->sense[4], SRpnt->sense[5],
1966 SRpnt->sense[6], SRpnt->sense[7]);
1da177e4
LT		 1967 if (cmdstatp->have_sense) {
1968
1969 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1970 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1971
1972 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1973 /* Compute the residual count */
1974 if (cmdstatp->remainder_valid)
1975 transfer = (int)cmdstatp->uremainder64;
1976 else
1977 transfer = 0;
1978 if (STp->block_size == 0 &&
1979 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1980 transfer = bytes;
1981
1982 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
b30d8bca
HR		 1983 if (STp->block_size == 0 &&
1984 transfer < 0) {
1985 st_printk(KERN_NOTICE, STp,
1986 "Failed to read %d "
1987 "byte block with %d "
1988 "byte transfer.\n",
1989 bytes - transfer,
1990 bytes);
1991 if (STps->drv_block >= 0)
1992 STps->drv_block += 1;
1993 STbp->buffer_bytes = 0;
1994 return (-ENOMEM);
1995 } else if (STp->block_size == 0) {
1da177e4
LT		 1996 STbp->buffer_bytes = bytes - transfer;
1997 } else {
8b05b773 1998 st_release_request(SRpnt);
1da177e4
LT		 1999 SRpnt = *aSRpnt = NULL;
2000 if (transfer == blks) { /* We did not get anything, error */
b30d8bca
HR		 2001 st_printk(KERN_NOTICE, STp,
2002 "Incorrect "
2003 "block size.\n");
1da177e4
LT		 2004 if (STps->drv_block >= 0)
2005 STps->drv_block += blks - transfer + 1;
2006 st_int_ioctl(STp, MTBSR, 1);
2007 return (-EIO);
2008 }
2009 /* We have some data, deliver it */
2010 STbp->buffer_bytes = (blks - transfer) *
2011 STp->block_size;
b30d8bca
HR		 2012 DEBC_printk(STp, "ILI but "
2013 "enough data "
2014 "received %ld "
2015 "%d.\n", count,
2016 STbp->buffer_bytes);
1da177e4
LT		 2017 if (STps->drv_block >= 0)
2018 STps->drv_block += 1;
2019 if (st_int_ioctl(STp, MTBSR, 1))
2020 return (-EIO);
2021 }
2022 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
2023 if (STps->eof != ST_FM_HIT)
2024 STps->eof = ST_FM_HIT;
2025 else
2026 STps->eof = ST_EOD_2;
2027 if (STp->block_size == 0)
2028 STbp->buffer_bytes = 0;
2029 else
2030 STbp->buffer_bytes =
2031 bytes - transfer * STp->block_size;
b30d8bca
HR		 2032 DEBC_printk(STp, "EOF detected (%d "
2033 "bytes read).\n",
2034 STbp->buffer_bytes);
1da177e4
LT		 2035 } else if (cmdstatp->flags & SENSE_EOM) {
2036 if (STps->eof == ST_FM)
2037 STps->eof = ST_EOD_1;
2038 else
2039 STps->eof = ST_EOM_OK;
2040 if (STp->block_size == 0)
2041 STbp->buffer_bytes = bytes - transfer;
2042 else
2043 STbp->buffer_bytes =
2044 bytes - transfer * STp->block_size;
2045
b30d8bca
HR		 2046 DEBC_printk(STp, "EOM detected (%d "
2047 "bytes read).\n",
2048 STbp->buffer_bytes);
1da177e4
LT		 2049 }
2050 }
b30d8bca 2051 /* end of EOF, EOM, ILI test */
1da177e4 2052 else { /* nonzero sense key */
b30d8bca 2053 DEBC_printk(STp, "Tape error while reading.\n");
1da177e4
LT		 2054 STps->drv_block = (-1);
2055 if (STps->eof == ST_FM &&
2056 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
b30d8bca
HR		 2057 DEBC_printk(STp, "Zero returned for "
2058 "first BLANK CHECK "
2059 "after EOF.\n");
1da177e4
LT		 2060 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
2061 } else /* Some other extended sense code */
2062 retval = (-EIO);
2063 }
2064
2065 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
2066 STbp->buffer_bytes = 0;
2067 }
b30d8bca 2068 /* End of extended sense test */
1da177e4
LT		 2069 else { /* Non-extended sense */
2070 retval = STbp->syscall_result;
2071 }
2072
2073 }
b30d8bca 2074 /* End of error handling */
40f6b36c 2075 else { /* Read successful */
1da177e4 2076 STbp->buffer_bytes = bytes;
40f6b36c
KM		 2077 if (STp->sili) /* In fixed block mode residual is always zero here */
2078 STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
2079 }
1da177e4
LT		 2080
2081 if (STps->drv_block >= 0) {
2082 if (STp->block_size == 0)
2083 STps->drv_block++;
2084 else
2085 STps->drv_block += STbp->buffer_bytes / STp->block_size;
2086 }
2087 return retval;
2088}
2089\f
2090
2091/* Read command */
2092static ssize_t
2093st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
2094{
2095 ssize_t total;
2096 ssize_t retval = 0;
2097 ssize_t i, transfer;
2098 int special, do_dio = 0;
8b05b773 2099 struct st_request *SRpnt = NULL;
1da177e4
LT		 2100 struct scsi_tape *STp = filp->private_data;
2101 struct st_modedef *STm;
2102 struct st_partstat *STps;
2103 struct st_buffer *STbp = STp->buffer;
1da177e4 2104
28f85009 2105 if (mutex_lock_interruptible(&STp->lock))
1da177e4
LT		 2106 return -ERESTARTSYS;
2107
2108 retval = rw_checks(STp, filp, count);
2109 if (retval || count == 0)
2110 goto out;
2111
2112 STm = &(STp->modes[STp->current_mode]);
9abe16c6
KM		 2113 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
2114 if (!STm->do_read_ahead) {
2115 retval = (-EINVAL); /* Read must be integral number of blocks */
2116 goto out;
2117 }
2118 STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */
1da177e4
LT		 2119 }
2120
2121 STps = &(STp->ps[STp->partition]);
2122 if (STps->rw == ST_WRITING) {
2123 retval = flush_buffer(STp, 0);
2124 if (retval)
2125 goto out;
2126 STps->rw = ST_READING;
2127 }
b30d8bca 2128 DEB(
1da177e4 2129 if (debugging && STps->eof != ST_NOEOF)
b30d8bca
HR		 2130 st_printk(ST_DEB_MSG, STp,
2131 "EOF/EOM flag up (%d). Bytes %d\n",
2132 STps->eof, STbp->buffer_bytes);
2133 ) /* end DEB */
1da177e4
LT		 2134
2135 retval = setup_buffering(STp, buf, count, 1);
2136 if (retval)
2137 goto out;
2138 do_dio = STbp->do_dio;
2139
2140 if (STbp->buffer_bytes == 0 &&
2141 STps->eof >= ST_EOD_1) {
2142 if (STps->eof < ST_EOD) {
2143 STps->eof += 1;
2144 retval = 0;
2145 goto out;
2146 }
2147 retval = (-EIO); /* EOM or Blank Check */
2148 goto out;
2149 }
2150
2151 if (do_dio) {
2152 /* Check the buffer writability before any tape movement. Don't alter
2153 buffer data. */
2154 if (copy_from_user(&i, buf, 1) != 0 ||
2155 copy_to_user(buf, &i, 1) != 0 ||
2156 copy_from_user(&i, buf + count - 1, 1) != 0 ||
2157 copy_to_user(buf + count - 1, &i, 1) != 0) {
2158 retval = (-EFAULT);
2159 goto out;
2160 }
2161 }
2162
2163 STps->rw = ST_READING;
2164
2165
2166 /* Loop until enough data in buffer or a special condition found */
2167 for (total = 0, special = 0; total < count && !special;) {
2168
2169 /* Get new data if the buffer is empty */
2170 if (STbp->buffer_bytes == 0) {
2171 special = read_tape(STp, count - total, &SRpnt);
2172 if (special < 0) { /* No need to continue read */
2173 retval = special;
2174 goto out;
2175 }
2176 }
2177
2178 /* Move the data from driver buffer to user buffer */
2179 if (STbp->buffer_bytes > 0) {
b30d8bca 2180 DEB(
1da177e4 2181 if (debugging && STps->eof != ST_NOEOF)
b30d8bca
HR		 2182 st_printk(ST_DEB_MSG, STp,
2183 "EOF up (%d). Left %d, needed %d.\n",
2184 STps->eof, STbp->buffer_bytes,
2185 (int)(count - total));
2186 ) /* end DEB */
1da177e4
LT		 2187 transfer = STbp->buffer_bytes < count - total ?
2188 STbp->buffer_bytes : count - total;
2189 if (!do_dio) {
2190 i = from_buffer(STbp, buf, transfer);
2191 if (i) {
2192 retval = i;
2193 goto out;
2194 }
2195 }
2196 buf += transfer;
2197 total += transfer;
2198 }
2199
2200 if (STp->block_size == 0)
2201 break; /* Read only one variable length block */
2202
2203 } /* for (total = 0, special = 0;
2204 total < count && !special; ) */
2205
2206 /* Change the eof state if no data from tape or buffer */
2207 if (total == 0) {
2208 if (STps->eof == ST_FM_HIT) {
2209 STps->eof = ST_FM;
2210 STps->drv_block = 0;
2211 if (STps->drv_file >= 0)
2212 STps->drv_file++;
2213 } else if (STps->eof == ST_EOD_1) {
2214 STps->eof = ST_EOD_2;
2215 STps->drv_block = 0;
2216 if (STps->drv_file >= 0)
2217 STps->drv_file++;
2218 } else if (STps->eof == ST_EOD_2)
2219 STps->eof = ST_EOD;
2220 } else if (STps->eof == ST_FM)
2221 STps->eof = ST_NOEOF;
2222 retval = total;
2223
2224 out:
2225 if (SRpnt != NULL) {
8b05b773 2226 st_release_request(SRpnt);
1da177e4
LT		 2227 SRpnt = NULL;
2228 }
2229 if (do_dio) {
787926b1 2230 release_buffering(STp, 1);
1da177e4
LT		 2231 STbp->buffer_bytes = 0;
2232 }
28f85009 2233 mutex_unlock(&STp->lock);
1da177e4
LT		 2234
2235 return retval;
2236}
2237\f
2238
2239
2240DEB(
2241/* Set the driver options */
b30d8bca 2242static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm)
1da177e4
LT		 2243{
2244 if (debugging) {
b30d8bca
HR		 2245 st_printk(KERN_INFO, STp,
2246 "Mode %d options: buffer writes: %d, "
2247 "async writes: %d, read ahead: %d\n",
2248 STp->current_mode, STm->do_buffer_writes,
2249 STm->do_async_writes, STm->do_read_ahead);
2250 st_printk(KERN_INFO, STp,
2251 " can bsr: %d, two FMs: %d, "
2252 "fast mteom: %d, auto lock: %d,\n",
2253 STp->can_bsr, STp->two_fm, STp->fast_mteom,
2254 STp->do_auto_lock);
2255 st_printk(KERN_INFO, STp,
2256 " defs for wr: %d, no block limits: %d, "
2257 "partitions: %d, s2 log: %d\n",
2258 STm->defaults_for_writes, STp->omit_blklims,
2259 STp->can_partitions, STp->scsi2_logical);
2260 st_printk(KERN_INFO, STp,
2261 " sysv: %d nowait: %d sili: %d "
2262 "nowait_filemark: %d\n",
2263 STm->sysv, STp->immediate, STp->sili,
2264 STp->immediate_filemark);
2265 st_printk(KERN_INFO, STp, " debugging: %d\n", debugging);
1da177e4
LT		 2266 }
2267}
2268 )
2269
2270
2271static int st_set_options(struct scsi_tape *STp, long options)
2272{
2273 int value;
2274 long code;
2275 struct st_modedef *STm;
1da177e4 2276 struct cdev *cd0, *cd1;
d6216c47 2277 struct device *d0, *d1;
1da177e4
LT		 2278
2279 STm = &(STp->modes[STp->current_mode]);
2280 if (!STm->defined) {
d6216c47
ML		 2281 cd0 = STm->cdevs[0];
2282 cd1 = STm->cdevs[1];
2283 d0 = STm->devs[0];
2284 d1 = STm->devs[1];
1da177e4 2285 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
d6216c47
ML		 2286 STm->cdevs[0] = cd0;
2287 STm->cdevs[1] = cd1;
2288 STm->devs[0] = d0;
2289 STm->devs[1] = d1;
1da177e4 2290 modes_defined = 1;
b30d8bca
HR		 2291 DEBC_printk(STp, "Initialized mode %d definition from mode 0\n",
2292 STp->current_mode);
1da177e4
LT		 2293 }
2294
2295 code = options & MT_ST_OPTIONS;
2296 if (code == MT_ST_BOOLEANS) {
2297 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2298 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2299 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2300 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2301 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2302 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2303 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2304 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2305 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2306 if ((STp->device)->scsi_level >= SCSI_2)
2307 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2308 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2309 STp->immediate = (options & MT_ST_NOWAIT) != 0;
c743e44f 2310 STp->immediate_filemark = (options & MT_ST_NOWAIT_EOF) != 0;
1da177e4 2311 STm->sysv = (options & MT_ST_SYSV) != 0;
40f6b36c 2312 STp->sili = (options & MT_ST_SILI) != 0;
1da177e4 2313 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
b30d8bca 2314 st_log_options(STp, STm); )
1da177e4
LT		 2315 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2316 value = (code == MT_ST_SETBOOLEANS);
2317 if ((options & MT_ST_BUFFER_WRITES) != 0)
2318 STm->do_buffer_writes = value;
2319 if ((options & MT_ST_ASYNC_WRITES) != 0)
2320 STm->do_async_writes = value;
2321 if ((options & MT_ST_DEF_WRITES) != 0)
2322 STm->defaults_for_writes = value;
2323 if ((options & MT_ST_READ_AHEAD) != 0)
2324 STm->do_read_ahead = value;
2325 if ((options & MT_ST_TWO_FM) != 0)
2326 STp->two_fm = value;
2327 if ((options & MT_ST_FAST_MTEOM) != 0)
2328 STp->fast_mteom = value;
2329 if ((options & MT_ST_AUTO_LOCK) != 0)
2330 STp->do_auto_lock = value;
2331 if ((options & MT_ST_CAN_BSR) != 0)
2332 STp->can_bsr = value;
2333 if ((options & MT_ST_NO_BLKLIMS) != 0)
2334 STp->omit_blklims = value;
2335 if ((STp->device)->scsi_level >= SCSI_2 &&
2336 (options & MT_ST_CAN_PARTITIONS) != 0)
2337 STp->can_partitions = value;
2338 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2339 STp->scsi2_logical = value;
2340 if ((options & MT_ST_NOWAIT) != 0)
2341 STp->immediate = value;
c743e44f
LD		 2342 if ((options & MT_ST_NOWAIT_EOF) != 0)
2343 STp->immediate_filemark = value;
1da177e4
LT		 2344 if ((options & MT_ST_SYSV) != 0)
2345 STm->sysv = value;
40f6b36c
KM		 2346 if ((options & MT_ST_SILI) != 0)
2347 STp->sili = value;
b30d8bca 2348 DEB(
1da177e4
LT		 2349 if ((options & MT_ST_DEBUGGING) != 0)
2350 debugging = value;
b30d8bca 2351 st_log_options(STp, STm); )
1da177e4
LT		 2352 } else if (code == MT_ST_WRITE_THRESHOLD) {
2353 /* Retained for compatibility */
2354 } else if (code == MT_ST_DEF_BLKSIZE) {
2355 value = (options & ~MT_ST_OPTIONS);
2356 if (value == ~MT_ST_OPTIONS) {
2357 STm->default_blksize = (-1);
b30d8bca 2358 DEBC_printk(STp, "Default block size disabled.\n");
1da177e4
LT		 2359 } else {
2360 STm->default_blksize = value;
b30d8bca
HR		 2361 DEBC_printk(STp,"Default block size set to "
2362 "%d bytes.\n", STm->default_blksize);
1da177e4
LT		 2363 if (STp->ready == ST_READY) {
2364 STp->blksize_changed = 0;
2365 set_mode_densblk(STp, STm);
2366 }
2367 }
2368 } else if (code == MT_ST_TIMEOUTS) {
2369 value = (options & ~MT_ST_OPTIONS);
2370 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2371 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
b30d8bca
HR		 2372 DEBC_printk(STp, "Long timeout set to %d seconds.\n",
2373 (value & ~MT_ST_SET_LONG_TIMEOUT));
1da177e4 2374 } else {
a02488ed
JB		 2375 blk_queue_rq_timeout(STp->device->request_queue,
2376 value * HZ);
b30d8bca
HR		 2377 DEBC_printk(STp, "Normal timeout set to %d seconds.\n",
2378 value);
1da177e4
LT		 2379 }
2380 } else if (code == MT_ST_SET_CLN) {
2381 value = (options & ~MT_ST_OPTIONS) & 0xff;
2382 if (value != 0 &&
832151f4
RK		 2383 (value < EXTENDED_SENSE_START ||
2384 value >= SCSI_SENSE_BUFFERSIZE))
1da177e4
LT		 2385 return (-EINVAL);
2386 STp->cln_mode = value;
2387 STp->cln_sense_mask = (options >> 8) & 0xff;
2388 STp->cln_sense_value = (options >> 16) & 0xff;
b30d8bca
HR		 2389 st_printk(KERN_INFO, STp,
2390 "Cleaning request mode %d, mask %02x, value %02x\n",
2391 value, STp->cln_sense_mask, STp->cln_sense_value);
1da177e4
LT		 2392 } else if (code == MT_ST_DEF_OPTIONS) {
2393 code = (options & ~MT_ST_CLEAR_DEFAULT);
2394 value = (options & MT_ST_CLEAR_DEFAULT);
2395 if (code == MT_ST_DEF_DENSITY) {
2396 if (value == MT_ST_CLEAR_DEFAULT) {
2397 STm->default_density = (-1);
b30d8bca
HR		 2398 DEBC_printk(STp,
2399 "Density default disabled.\n");
1da177e4
LT		 2400 } else {
2401 STm->default_density = value & 0xff;
b30d8bca
HR		 2402 DEBC_printk(STp, "Density default set to %x\n",
2403 STm->default_density);
1da177e4
LT		 2404 if (STp->ready == ST_READY) {
2405 STp->density_changed = 0;
2406 set_mode_densblk(STp, STm);
2407 }
2408 }
2409 } else if (code == MT_ST_DEF_DRVBUFFER) {
2410 if (value == MT_ST_CLEAR_DEFAULT) {
2411 STp->default_drvbuffer = 0xff;
b30d8bca
HR		 2412 DEBC_printk(STp,
2413 "Drive buffer default disabled.\n");
1da177e4
LT		 2414 } else {
2415 STp->default_drvbuffer = value & 7;
b30d8bca
HR		 2416 DEBC_printk(STp,
2417 "Drive buffer default set to %x\n",
2418 STp->default_drvbuffer);
1da177e4
LT		 2419 if (STp->ready == ST_READY)
2420 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2421 }
2422 } else if (code == MT_ST_DEF_COMPRESSION) {
2423 if (value == MT_ST_CLEAR_DEFAULT) {
2424 STm->default_compression = ST_DONT_TOUCH;
b30d8bca
HR		 2425 DEBC_printk(STp,
2426 "Compression default disabled.\n");
1da177e4
LT		 2427 } else {
2428 if ((value & 0xff00) != 0) {
2429 STp->c_algo = (value & 0xff00) >> 8;
b30d8bca
HR		 2430 DEBC_printk(STp, "Compression "
2431 "algorithm set to 0x%x.\n",
2432 STp->c_algo);
1da177e4
LT		 2433 }
2434 if ((value & 0xff) != 0xff) {
2435 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
b30d8bca
HR		 2436 DEBC_printk(STp, "Compression default "
2437 "set to %x\n",
2438 (value & 1));
1da177e4
LT		 2439 if (STp->ready == ST_READY) {
2440 STp->compression_changed = 0;
2441 st_compression(STp, (STm->default_compression == ST_YES));
2442 }
2443 }
2444 }
2445 }
2446 } else
2447 return (-EIO);
2448
2449 return 0;
2450}
2451\f
2452#define MODE_HEADER_LENGTH 4
2453
2454/* Mode header and page byte offsets */
2455#define MH_OFF_DATA_LENGTH 0
2456#define MH_OFF_MEDIUM_TYPE 1
2457#define MH_OFF_DEV_SPECIFIC 2
2458#define MH_OFF_BDESCS_LENGTH 3
2459#define MP_OFF_PAGE_NBR 0
2460#define MP_OFF_PAGE_LENGTH 1
2461
2462/* Mode header and page bit masks */
2463#define MH_BIT_WP 0x80
2464#define MP_MSK_PAGE_NBR 0x3f
2465
2466/* Don't return block descriptors */
2467#define MODE_SENSE_OMIT_BDESCS 0x08
2468
2469#define MODE_SELECT_PAGE_FORMAT 0x10
2470
2471/* Read a mode page into the tape buffer. The block descriptors are included
2472 if incl_block_descs is true. The page control is ored to the page number
2473 parameter, if necessary. */
2474static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2475{
2476 unsigned char cmd[MAX_COMMAND_SIZE];
8ecf0d99 2477 struct st_request *SRpnt;
1da177e4
LT		 2478
2479 memset(cmd, 0, MAX_COMMAND_SIZE);
2480 cmd[0] = MODE_SENSE;
2481 if (omit_block_descs)
2482 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2483 cmd[2] = page;
2484 cmd[4] = 255;
2485
02ae2c0e
KM		 2486 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2487 STp->device->request_queue->rq_timeout, 0, 1);
2488 if (SRpnt == NULL)
2489 return (STp->buffer)->syscall_result;
1da177e4 2490
8b05b773 2491 st_release_request(SRpnt);
1da177e4 2492
02ae2c0e 2493 return STp->buffer->syscall_result;
1da177e4
LT		 2494}
2495
2496
2497/* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2498 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2499static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2500{
02ae2c0e 2501 int pgo;
1da177e4 2502 unsigned char cmd[MAX_COMMAND_SIZE];
18c87015 2503 struct st_request *SRpnt;
02ae2c0e 2504 int timeout;
1da177e4
LT		 2505
2506 memset(cmd, 0, MAX_COMMAND_SIZE);
2507 cmd[0] = MODE_SELECT;
2508 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2509 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2510 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2511
2512 /* Clear reserved fields */
2513 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2514 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2515 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2516 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2517
02ae2c0e
KM		 2518 timeout = slow ?
2519 STp->long_timeout : STp->device->request_queue->rq_timeout;
2520 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_TO_DEVICE,
2521 timeout, 0, 1);
2522 if (SRpnt == NULL)
2523 return (STp->buffer)->syscall_result;
1da177e4 2524
8b05b773 2525 st_release_request(SRpnt);
1da177e4 2526
02ae2c0e 2527 return STp->buffer->syscall_result;
1da177e4
LT		 2528}
2529
2530
2531#define COMPRESSION_PAGE 0x0f
2532#define COMPRESSION_PAGE_LENGTH 16
2533
2534#define CP_OFF_DCE_DCC 2
2535#define CP_OFF_C_ALGO 7
2536
2537#define DCE_MASK 0x80
2538#define DCC_MASK 0x40
2539#define RED_MASK 0x60
2540
2541
2542/* Control the compression with mode page 15. Algorithm not changed if zero.
2543
2544 The block descriptors are read and written because Sony SDT-7000 does not
2545 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2546 Including block descriptors should not cause any harm to other drives. */
2547
2548static int st_compression(struct scsi_tape * STp, int state)
2549{
2550 int retval;
2551 int mpoffs; /* Offset to mode page start */
2552 unsigned char *b_data = (STp->buffer)->b_data;
1da177e4
LT		 2553
2554 if (STp->ready != ST_READY)
2555 return (-EIO);
2556
2557 /* Read the current page contents */
2558 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2559 if (retval) {
b30d8bca 2560 DEBC_printk(STp, "Compression mode page not supported.\n");
1da177e4
LT		 2561 return (-EIO);
2562 }
2563
2564 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
b30d8bca
HR		 2565 DEBC_printk(STp, "Compression state is %d.\n",
2566 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0));
1da177e4
LT		 2567
2568 /* Check if compression can be changed */
2569 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
b30d8bca 2570 DEBC_printk(STp, "Compression not supported.\n");
1da177e4
LT		 2571 return (-EIO);
2572 }
2573
2574 /* Do the change */
2575 if (state) {
2576 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2577 if (STp->c_algo != 0)
2578 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2579 }
2580 else {
2581 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2582 if (STp->c_algo != 0)
2583 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2584 }
2585
2586 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2587 if (retval) {
b30d8bca 2588 DEBC_printk(STp, "Compression change failed.\n");
1da177e4
LT		 2589 return (-EIO);
2590 }
b30d8bca 2591 DEBC_printk(STp, "Compression state changed to %d.\n", state);
1da177e4
LT		 2592
2593 STp->compression_changed = 1;
2594 return 0;
2595}
2596
2597
2598/* Process the load and unload commands (does unload if the load code is zero) */
2599static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2600{
2601 int retval = (-EIO), timeout;
1da177e4
LT		 2602 unsigned char cmd[MAX_COMMAND_SIZE];
2603 struct st_partstat *STps;
8b05b773 2604 struct st_request *SRpnt;
1da177e4
LT		 2605
2606 if (STp->ready != ST_READY && !load_code) {
2607 if (STp->ready == ST_NO_TAPE)
2608 return (-ENOMEDIUM);
2609 else
2610 return (-EIO);
2611 }
2612
2613 memset(cmd, 0, MAX_COMMAND_SIZE);
2614 cmd[0] = START_STOP;
2615 if (load_code)
2616 cmd[4] |= 1;
2617 /*
2618 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2619 */
2620 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2621 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
b30d8bca
HR		 2622 DEBC_printk(STp, " Enhanced %sload slot %2d.\n",
2623 (cmd[4]) ? "" : "un",
2624 load_code - MT_ST_HPLOADER_OFFSET);
1da177e4
LT		 2625 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2626 }
2627 if (STp->immediate) {
2628 cmd[1] = 1; /* Don't wait for completion */
a02488ed 2629 timeout = STp->device->request_queue->rq_timeout;
1da177e4
LT		 2630 }
2631 else
2632 timeout = STp->long_timeout;
2633
2634 DEBC(
2635 if (!load_code)
b30d8bca 2636 st_printk(ST_DEB_MSG, STp, "Unloading tape.\n");
1da177e4 2637 else
b30d8bca 2638 st_printk(ST_DEB_MSG, STp, "Loading tape.\n");
1da177e4
LT		 2639 );
2640
02ae2c0e
KM		 2641 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2642 timeout, MAX_RETRIES, 1);
1da177e4 2643 if (!SRpnt)
02ae2c0e 2644 return (STp->buffer)->syscall_result;
1da177e4
LT		 2645
2646 retval = (STp->buffer)->syscall_result;
02ae2c0e 2647 st_release_request(SRpnt);
1da177e4
LT		 2648
2649 if (!retval) { /* SCSI command successful */
2650
2651 if (!load_code) {
2652 STp->rew_at_close = 0;
2653 STp->ready = ST_NO_TAPE;
2654 }
2655 else {
2656 STp->rew_at_close = STp->autorew_dev;
2657 retval = check_tape(STp, filp);
2658 if (retval > 0)
2659 retval = 0;
2660 }
2661 }
2662 else {
2663 STps = &(STp->ps[STp->partition]);
2664 STps->drv_file = STps->drv_block = (-1);
2665 }
2666
2667 return retval;
2668}
2669\f
2670#if DEBUG
2671#define ST_DEB_FORWARD 0
2672#define ST_DEB_BACKWARD 1
b30d8bca 2673static void deb_space_print(struct scsi_tape *STp, int direction, char *units, unsigned char *cmd)
1da177e4
LT		 2674{
2675 s32 sc;
2676
b30d8bca
HR		 2677 if (!debugging)
2678 return;
2679
1da177e4
LT		 2680 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2681 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2682 if (direction)
2683 sc = -sc;
b30d8bca
HR		 2684 st_printk(ST_DEB_MSG, STp, "Spacing tape %s over %d %s.\n",
2685 direction ? "backward" : "forward", sc, units);
1da177e4 2686}
b30d8bca
HR		 2687#else
2688#define ST_DEB_FORWARD 0
2689#define ST_DEB_BACKWARD 1
2690static void deb_space_print(struct scsi_tape *STp, int direction, char *units, unsigned char *cmd) {}
1da177e4
LT		 2691#endif
2692
2693
2694/* Internal ioctl function */
2695static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2696{
2697 int timeout;
2698 long ltmp;
2699 int ioctl_result;
2700 int chg_eof = 1;
2701 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 2702 struct st_request *SRpnt;
1da177e4
LT		 2703 struct st_partstat *STps;
2704 int fileno, blkno, at_sm, undone;
2705 int datalen = 0, direction = DMA_NONE;
1da177e4
LT		 2706
2707 WARN_ON(STp->buffer->do_dio != 0);
2708 if (STp->ready != ST_READY) {
2709 if (STp->ready == ST_NO_TAPE)
2710 return (-ENOMEDIUM);
2711 else
2712 return (-EIO);
2713 }
2714 timeout = STp->long_timeout;
2715 STps = &(STp->ps[STp->partition]);
2716 fileno = STps->drv_file;
2717 blkno = STps->drv_block;
2718 at_sm = STps->at_sm;
2719
2720 memset(cmd, 0, MAX_COMMAND_SIZE);
2721 switch (cmd_in) {
2722 case MTFSFM:
2723 chg_eof = 0; /* Changed from the FSF after this */
2724 case MTFSF:
2725 cmd[0] = SPACE;
2726 cmd[1] = 0x01; /* Space FileMarks */
2727 cmd[2] = (arg >> 16);
2728 cmd[3] = (arg >> 8);
2729 cmd[4] = arg;
b30d8bca 2730 deb_space_print(STp, ST_DEB_FORWARD, "filemarks", cmd);
1da177e4
LT		 2731 if (fileno >= 0)
2732 fileno += arg;
2733 blkno = 0;
2734 at_sm &= (arg == 0);
2735 break;
2736 case MTBSFM:
2737 chg_eof = 0; /* Changed from the FSF after this */
2738 case MTBSF:
2739 cmd[0] = SPACE;
2740 cmd[1] = 0x01; /* Space FileMarks */
2741 ltmp = (-arg);
2742 cmd[2] = (ltmp >> 16);
2743 cmd[3] = (ltmp >> 8);
2744 cmd[4] = ltmp;
b30d8bca 2745 deb_space_print(STp, ST_DEB_BACKWARD, "filemarks", cmd);
1da177e4
LT		 2746 if (fileno >= 0)
2747 fileno -= arg;
2748 blkno = (-1); /* We can't know the block number */
2749 at_sm &= (arg == 0);
2750 break;
2751 case MTFSR:
2752 cmd[0] = SPACE;
2753 cmd[1] = 0x00; /* Space Blocks */
2754 cmd[2] = (arg >> 16);
2755 cmd[3] = (arg >> 8);
2756 cmd[4] = arg;
b30d8bca 2757 deb_space_print(STp, ST_DEB_FORWARD, "blocks", cmd);
1da177e4
LT		 2758 if (blkno >= 0)
2759 blkno += arg;
2760 at_sm &= (arg == 0);
2761 break;
2762 case MTBSR:
2763 cmd[0] = SPACE;
2764 cmd[1] = 0x00; /* Space Blocks */
2765 ltmp = (-arg);
2766 cmd[2] = (ltmp >> 16);
2767 cmd[3] = (ltmp >> 8);
2768 cmd[4] = ltmp;
b30d8bca 2769 deb_space_print(STp, ST_DEB_BACKWARD, "blocks", cmd);
1da177e4
LT		 2770 if (blkno >= 0)
2771 blkno -= arg;
2772 at_sm &= (arg == 0);
2773 break;
2774 case MTFSS:
2775 cmd[0] = SPACE;
2776 cmd[1] = 0x04; /* Space Setmarks */
2777 cmd[2] = (arg >> 16);
2778 cmd[3] = (arg >> 8);
2779 cmd[4] = arg;
b30d8bca 2780 deb_space_print(STp, ST_DEB_FORWARD, "setmarks", cmd);
1da177e4
LT		 2781 if (arg != 0) {
2782 blkno = fileno = (-1);
2783 at_sm = 1;
2784 }
2785 break;
2786 case MTBSS:
2787 cmd[0] = SPACE;
2788 cmd[1] = 0x04; /* Space Setmarks */
2789 ltmp = (-arg);
2790 cmd[2] = (ltmp >> 16);
2791 cmd[3] = (ltmp >> 8);
2792 cmd[4] = ltmp;
b30d8bca 2793 deb_space_print(STp, ST_DEB_BACKWARD, "setmarks", cmd);
1da177e4
LT		 2794 if (arg != 0) {
2795 blkno = fileno = (-1);
2796 at_sm = 1;
2797 }
2798 break;
2799 case MTWEOF:
3e51d3c9 2800 case MTWEOFI:
1da177e4
LT		 2801 case MTWSM:
2802 if (STp->write_prot)
2803 return (-EACCES);
2804 cmd[0] = WRITE_FILEMARKS;
2805 if (cmd_in == MTWSM)
2806 cmd[1] = 2;
c743e44f
LD		 2807 if (cmd_in == MTWEOFI ||
2808 (cmd_in == MTWEOF && STp->immediate_filemark))
3e51d3c9 2809 cmd[1] |= 1;
1da177e4
LT		 2810 cmd[2] = (arg >> 16);
2811 cmd[3] = (arg >> 8);
2812 cmd[4] = arg;
a02488ed 2813 timeout = STp->device->request_queue->rq_timeout;
b30d8bca
HR		 2814 DEBC(
2815 if (cmd_in != MTWSM)
2816 st_printk(ST_DEB_MSG, STp,
2817 "Writing %d filemarks.\n",
2818 cmd[2] * 65536 +
2819 cmd[3] * 256 +
2820 cmd[4]);
2821 else
2822 st_printk(ST_DEB_MSG, STp,
2823 "Writing %d setmarks.\n",
2824 cmd[2] * 65536 +
2825 cmd[3] * 256 +
2826 cmd[4]);
1da177e4
LT		 2827 )
2828 if (fileno >= 0)
2829 fileno += arg;
2830 blkno = 0;
2831 at_sm = (cmd_in == MTWSM);
2832 break;
2833 case MTREW:
2834 cmd[0] = REZERO_UNIT;
2835 if (STp->immediate) {
2836 cmd[1] = 1; /* Don't wait for completion */
a02488ed 2837 timeout = STp->device->request_queue->rq_timeout;
1da177e4 2838 }
b30d8bca 2839 DEBC_printk(STp, "Rewinding tape.\n");
1da177e4
LT		 2840 fileno = blkno = at_sm = 0;
2841 break;
2842 case MTNOP:
b30d8bca 2843 DEBC_printk(STp, "No op on tape.\n");
1da177e4
LT		 2844 return 0; /* Should do something ? */
2845 break;
2846 case MTRETEN:
2847 cmd[0] = START_STOP;
2848 if (STp->immediate) {
2849 cmd[1] = 1; /* Don't wait for completion */
a02488ed 2850 timeout = STp->device->request_queue->rq_timeout;
1da177e4
LT		 2851 }
2852 cmd[4] = 3;
b30d8bca 2853 DEBC_printk(STp, "Retensioning tape.\n");
1da177e4
LT		 2854 fileno = blkno = at_sm = 0;
2855 break;
2856 case MTEOM:
2857 if (!STp->fast_mteom) {
2858 /* space to the end of tape */
2859 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2860 fileno = STps->drv_file;
2861 if (STps->eof >= ST_EOD_1)
2862 return 0;
2863 /* The next lines would hide the number of spaced FileMarks
2864 That's why I inserted the previous lines. I had no luck
2865 with detecting EOM with FSF, so we go now to EOM.
2866 Joerg Weule */
2867 } else
2868 fileno = (-1);
2869 cmd[0] = SPACE;
2870 cmd[1] = 3;
b30d8bca 2871 DEBC_printk(STp, "Spacing to end of recorded medium.\n");
1da177e4
LT		 2872 blkno = -1;
2873 at_sm = 0;
2874 break;
2875 case MTERASE:
2876 if (STp->write_prot)
2877 return (-EACCES);
2878 cmd[0] = ERASE;
2879 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2880 if (STp->immediate) {
2881 cmd[1] |= 2; /* Don't wait for completion */
a02488ed 2882 timeout = STp->device->request_queue->rq_timeout;
1da177e4
LT		 2883 }
2884 else
2885 timeout = STp->long_timeout * 8;
2886
b30d8bca 2887 DEBC_printk(STp, "Erasing tape.\n");
1da177e4
LT		 2888 fileno = blkno = at_sm = 0;
2889 break;
2890 case MTSETBLK: /* Set block length */
2891 case MTSETDENSITY: /* Set tape density */
2892 case MTSETDRVBUFFER: /* Set drive buffering */
2893 case SET_DENS_AND_BLK: /* Set density and block size */
2894 chg_eof = 0;
2895 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2896 return (-EIO); /* Not allowed if data in buffer */
2897 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2898 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2899 STp->max_block > 0 &&
2900 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2901 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
b30d8bca 2902 st_printk(KERN_WARNING, STp, "Illegal block size.\n");
1da177e4
LT		 2903 return (-EINVAL);
2904 }
2905 cmd[0] = MODE_SELECT;
2906 if ((STp->use_pf & USE_PF))
2907 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2908 cmd[4] = datalen = 12;
2909 direction = DMA_TO_DEVICE;
2910
2911 memset((STp->buffer)->b_data, 0, 12);
2912 if (cmd_in == MTSETDRVBUFFER)
2913 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2914 else
2915 (STp->buffer)->b_data[2] =
2916 STp->drv_buffer << 4;
2917 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2918 if (cmd_in == MTSETDENSITY) {
2919 (STp->buffer)->b_data[4] = arg;
2920 STp->density_changed = 1; /* At least we tried ;-) */
2921 } else if (cmd_in == SET_DENS_AND_BLK)
2922 (STp->buffer)->b_data[4] = arg >> 24;
2923 else
2924 (STp->buffer)->b_data[4] = STp->density;
2925 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2926 ltmp = arg & MT_ST_BLKSIZE_MASK;
2927 if (cmd_in == MTSETBLK)
2928 STp->blksize_changed = 1; /* At least we tried ;-) */
2929 } else
2930 ltmp = STp->block_size;
2931 (STp->buffer)->b_data[9] = (ltmp >> 16);
2932 (STp->buffer)->b_data[10] = (ltmp >> 8);
2933 (STp->buffer)->b_data[11] = ltmp;
a02488ed 2934 timeout = STp->device->request_queue->rq_timeout;
b30d8bca 2935 DEBC(
1da177e4 2936 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
b30d8bca
HR		 2937 st_printk(ST_DEB_MSG, STp,
2938 "Setting block size to %d bytes.\n",
2939 (STp->buffer)->b_data[9] * 65536 +
2940 (STp->buffer)->b_data[10] * 256 +
2941 (STp->buffer)->b_data[11]);
1da177e4 2942 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
b30d8bca
HR		 2943 st_printk(ST_DEB_MSG, STp,
2944 "Setting density code to %x.\n",
2945 (STp->buffer)->b_data[4]);
1da177e4 2946 if (cmd_in == MTSETDRVBUFFER)
b30d8bca
HR		 2947 st_printk(ST_DEB_MSG, STp,
2948 "Setting drive buffer code to %d.\n",
2949 ((STp->buffer)->b_data[2] >> 4) & 7);
1da177e4
LT		 2950 )
2951 break;
2952 default:
2953 return (-ENOSYS);
2954 }
2955
02ae2c0e
KM		 2956 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2957 timeout, MAX_RETRIES, 1);
1da177e4
LT		 2958 if (!SRpnt)
2959 return (STp->buffer)->syscall_result;
2960
02ae2c0e 2961 ioctl_result = (STp->buffer)->syscall_result;
1da177e4
LT		 2962
2963 if (!ioctl_result) { /* SCSI command successful */
8b05b773 2964 st_release_request(SRpnt);
1da177e4
LT		 2965 SRpnt = NULL;
2966 STps->drv_block = blkno;
2967 STps->drv_file = fileno;
2968 STps->at_sm = at_sm;
2969
2970 if (cmd_in == MTBSFM)
2971 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2972 else if (cmd_in == MTFSFM)
2973 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2974
2975 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
1da177e4
LT		 2976 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2977 if (STp->block_size != 0) {
1da177e4
LT		 2978 (STp->buffer)->buffer_blocks =
2979 (STp->buffer)->buffer_size / STp->block_size;
2980 }
2981 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2982 if (cmd_in == SET_DENS_AND_BLK)
2983 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2984 } else if (cmd_in == MTSETDRVBUFFER)
2985 STp->drv_buffer = (arg & 7);
2986 else if (cmd_in == MTSETDENSITY)
2987 STp->density = arg;
2988
2989 if (cmd_in == MTEOM)
2990 STps->eof = ST_EOD;
2991 else if (cmd_in == MTFSF)
2992 STps->eof = ST_FM;
2993 else if (chg_eof)
2994 STps->eof = ST_NOEOF;
2995
3e51d3c9
KM		 2996 if (cmd_in == MTWEOF || cmd_in == MTWEOFI)
2997 STps->rw = ST_IDLE; /* prevent automatic WEOF at close */
1da177e4
LT		 2998 } else { /* SCSI command was not completely successful. Don't return
2999 from this block without releasing the SCSI command block! */
3000 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
3001
3002 if (cmdstatp->flags & SENSE_EOM) {
3003 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
3004 cmd_in != MTBSR && cmd_in != MTBSS)
3005 STps->eof = ST_EOM_OK;
3006 STps->drv_block = 0;
3007 }
3008
3009 if (cmdstatp->remainder_valid)
3010 undone = (int)cmdstatp->uremainder64;
3011 else
3012 undone = 0;
3013
3e51d3c9 3014 if ((cmd_in == MTWEOF || cmd_in == MTWEOFI) &&
1da177e4 3015 cmdstatp->have_sense &&
91614c05
KM		 3016 (cmdstatp->flags & SENSE_EOM)) {
3017 if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
3018 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
3019 ioctl_result = 0; /* EOF(s) written successfully at EOM */
3020 STps->eof = ST_NOEOF;
3021 } else { /* Writing EOF(s) failed */
3022 if (fileno >= 0)
3023 fileno -= undone;
3024 if (undone < arg)
3025 STps->eof = ST_NOEOF;
3026 }
1da177e4 3027 STps->drv_file = fileno;
1da177e4
LT		 3028 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
3029 if (fileno >= 0)
3030 STps->drv_file = fileno - undone;
3031 else
3032 STps->drv_file = fileno;
3033 STps->drv_block = -1;
3034 STps->eof = ST_NOEOF;
3035 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
3036 if (arg > 0 && undone < 0) /* Some drives get this wrong */
3037 undone = (-undone);
3038 if (STps->drv_file >= 0)
3039 STps->drv_file = fileno + undone;
3040 STps->drv_block = 0;
3041 STps->eof = ST_NOEOF;
3042 } else if (cmd_in == MTFSR) {
3043 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
3044 if (STps->drv_file >= 0)
3045 STps->drv_file++;
3046 STps->drv_block = 0;
3047 STps->eof = ST_FM;
3048 } else {
3049 if (blkno >= undone)
3050 STps->drv_block = blkno - undone;
3051 else
3052 STps->drv_block = (-1);
3053 STps->eof = ST_NOEOF;
3054 }
3055 } else if (cmd_in == MTBSR) {
3056 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
3057 STps->drv_file--;
3058 STps->drv_block = (-1);
3059 } else {
3060 if (arg > 0 && undone < 0) /* Some drives get this wrong */
3061 undone = (-undone);
3062 if (STps->drv_block >= 0)
3063 STps->drv_block = blkno + undone;
3064 }
3065 STps->eof = ST_NOEOF;
3066 } else if (cmd_in == MTEOM) {
3067 STps->drv_file = (-1);
3068 STps->drv_block = (-1);
3069 STps->eof = ST_EOD;
3070 } else if (cmd_in == MTSETBLK ||
3071 cmd_in == MTSETDENSITY ||
3072 cmd_in == MTSETDRVBUFFER ||
3073 cmd_in == SET_DENS_AND_BLK) {
3074 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
3075 !(STp->use_pf & PF_TESTED)) {
3076 /* Try the other possible state of Page Format if not
3077 already tried */
1da2019f 3078 STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED;
8b05b773 3079 st_release_request(SRpnt);
1da177e4
LT		 3080 SRpnt = NULL;
3081 return st_int_ioctl(STp, cmd_in, arg);
3082 }
3083 } else if (chg_eof)
3084 STps->eof = ST_NOEOF;
3085
3086 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
3087 STps->eof = ST_EOD;
3088
8b05b773 3089 st_release_request(SRpnt);
1da177e4
LT		 3090 SRpnt = NULL;
3091 }
3092
3093 return ioctl_result;
3094}
3095\f
3096
3097/* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
3098 structure. */
3099
3100static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
3101 int logical)
3102{
3103 int result;
3104 unsigned char scmd[MAX_COMMAND_SIZE];
8b05b773 3105 struct st_request *SRpnt;
1da177e4
LT		 3106
3107 if (STp->ready != ST_READY)
3108 return (-EIO);
3109
3110 memset(scmd, 0, MAX_COMMAND_SIZE);
3111 if ((STp->device)->scsi_level < SCSI_2) {
3112 scmd[0] = QFA_REQUEST_BLOCK;
3113 scmd[4] = 3;
3114 } else {
3115 scmd[0] = READ_POSITION;
3116 if (!logical && !STp->scsi2_logical)
3117 scmd[1] = 1;
3118 }
02ae2c0e
KM		 3119 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
3120 STp->device->request_queue->rq_timeout,
3121 MAX_READY_RETRIES, 1);
1da177e4 3122 if (!SRpnt)
02ae2c0e 3123 return (STp->buffer)->syscall_result;
1da177e4
LT		 3124
3125 if ((STp->buffer)->syscall_result != 0 ||
3126 (STp->device->scsi_level >= SCSI_2 &&
3127 ((STp->buffer)->b_data[0] & 4) != 0)) {
3128 *block = *partition = 0;
b30d8bca 3129 DEBC_printk(STp, " Can't read tape position.\n");
1da177e4
LT		 3130 result = (-EIO);
3131 } else {
3132 result = 0;
3133 if ((STp->device)->scsi_level < SCSI_2) {
3134 *block = ((STp->buffer)->b_data[0] << 16)
3135 + ((STp->buffer)->b_data[1] << 8)
3136 + (STp->buffer)->b_data[2];
3137 *partition = 0;
3138 } else {
3139 *block = ((STp->buffer)->b_data[4] << 24)
3140 + ((STp->buffer)->b_data[5] << 16)
3141 + ((STp->buffer)->b_data[6] << 8)
3142 + (STp->buffer)->b_data[7];
3143 *partition = (STp->buffer)->b_data[1];
3144 if (((STp->buffer)->b_data[0] & 0x80) &&
3145 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
3146 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3147 }
b30d8bca
HR		 3148 DEBC_printk(STp, "Got tape pos. blk %d part %d.\n",
3149 *block, *partition);
1da177e4 3150 }
8b05b773 3151 st_release_request(SRpnt);
1da177e4
LT		 3152 SRpnt = NULL;
3153
3154 return result;
3155}
3156
3157
3158/* Set the tape block and partition. Negative partition means that only the
3159 block should be set in vendor specific way. */
3160static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3161 int logical)
3162{
3163 struct st_partstat *STps;
3164 int result, p;
3165 unsigned int blk;
3166 int timeout;
3167 unsigned char scmd[MAX_COMMAND_SIZE];
8b05b773 3168 struct st_request *SRpnt;
1da177e4
LT		 3169
3170 if (STp->ready != ST_READY)
3171 return (-EIO);
3172 timeout = STp->long_timeout;
3173 STps = &(STp->ps[STp->partition]);
3174
b30d8bca
HR		 3175 DEBC_printk(STp, "Setting block to %d and partition to %d.\n",
3176 block, partition);
1da177e4
LT		 3177 DEB(if (partition < 0)
3178 return (-EIO); )
3179
3180 /* Update the location at the partition we are leaving */
3181 if ((!STp->can_partitions && partition != 0) ||
3182 partition >= ST_NBR_PARTITIONS)
3183 return (-EINVAL);
3184 if (partition != STp->partition) {
3185 if (get_location(STp, &blk, &p, 1))
3186 STps->last_block_valid = 0;
3187 else {
3188 STps->last_block_valid = 1;
3189 STps->last_block_visited = blk;
b30d8bca
HR		 3190 DEBC_printk(STp, "Visited block %d for "
3191 "partition %d saved.\n",
3192 blk, STp->partition);
1da177e4
LT		 3193 }
3194 }
3195
3196 memset(scmd, 0, MAX_COMMAND_SIZE);
3197 if ((STp->device)->scsi_level < SCSI_2) {
3198 scmd[0] = QFA_SEEK_BLOCK;
3199 scmd[2] = (block >> 16);
3200 scmd[3] = (block >> 8);
3201 scmd[4] = block;
3202 scmd[5] = 0;
3203 } else {
3204 scmd[0] = SEEK_10;
3205 scmd[3] = (block >> 24);
3206 scmd[4] = (block >> 16);
3207 scmd[5] = (block >> 8);
3208 scmd[6] = block;
3209 if (!logical && !STp->scsi2_logical)
3210 scmd[1] = 4;
3211 if (STp->partition != partition) {
3212 scmd[1] |= 2;
3213 scmd[8] = partition;
b30d8bca
HR		 3214 DEBC_printk(STp, "Trying to change partition "
3215 "from %d to %d\n", STp->partition,
3216 partition);
1da177e4
LT		 3217 }
3218 }
3219 if (STp->immediate) {
3220 scmd[1] |= 1; /* Don't wait for completion */
a02488ed 3221 timeout = STp->device->request_queue->rq_timeout;
1da177e4
LT		 3222 }
3223
02ae2c0e
KM		 3224 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3225 timeout, MAX_READY_RETRIES, 1);
1da177e4 3226 if (!SRpnt)
02ae2c0e 3227 return (STp->buffer)->syscall_result;
1da177e4
LT		 3228
3229 STps->drv_block = STps->drv_file = (-1);
3230 STps->eof = ST_NOEOF;
3231 if ((STp->buffer)->syscall_result != 0) {
3232 result = (-EIO);
3233 if (STp->can_partitions &&
3234 (STp->device)->scsi_level >= SCSI_2 &&
3235 (p = find_partition(STp)) >= 0)
3236 STp->partition = p;
3237 } else {
3238 if (STp->can_partitions) {
3239 STp->partition = partition;
3240 STps = &(STp->ps[partition]);
3241 if (!STps->last_block_valid ||
3242 STps->last_block_visited != block) {
3243 STps->at_sm = 0;
3244 STps->rw = ST_IDLE;
3245 }
3246 } else
3247 STps->at_sm = 0;
3248 if (block == 0)
3249 STps->drv_block = STps->drv_file = 0;
3250 result = 0;
3251 }
02ae2c0e 3252
8b05b773 3253 st_release_request(SRpnt);
1da177e4
LT		 3254 SRpnt = NULL;
3255
3256 return result;
3257}
3258
3259
3260/* Find the current partition number for the drive status. Called from open and
3261 returns either partition number of negative error code. */
3262static int find_partition(struct scsi_tape *STp)
3263{
3264 int i, partition;
3265 unsigned int block;
3266
3267 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3268 return i;
3269 if (partition >= ST_NBR_PARTITIONS)
3270 return (-EIO);
3271 return partition;
3272}
3273
3274
3275/* Change the partition if necessary */
3276static int switch_partition(struct scsi_tape *STp)
3277{
3278 struct st_partstat *STps;
3279
3280 if (STp->partition == STp->new_partition)
3281 return 0;
3282 STps = &(STp->ps[STp->new_partition]);
3283 if (!STps->last_block_valid)
3284 STps->last_block_visited = 0;
3285 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3286}
3287\f
3288/* Functions for reading and writing the medium partition mode page. */
3289
3290#define PART_PAGE 0x11
3291#define PART_PAGE_FIXED_LENGTH 8
3292
3293#define PP_OFF_MAX_ADD_PARTS 2
3294#define PP_OFF_NBR_ADD_PARTS 3
3295#define PP_OFF_FLAGS 4
3296#define PP_OFF_PART_UNITS 6
3297#define PP_OFF_RESERVED 7
3298
3299#define PP_BIT_IDP 0x20
3300#define PP_MSK_PSUM_MB 0x10
3301
3302/* Get the number of partitions on the tape. As a side effect reads the
3303 mode page into the tape buffer. */
3304static int nbr_partitions(struct scsi_tape *STp)
3305{
3306 int result;
1da177e4
LT		 3307
3308 if (STp->ready != ST_READY)
3309 return (-EIO);
3310
3311 result = read_mode_page(STp, PART_PAGE, 1);
3312
3313 if (result) {
b30d8bca 3314 DEBC_printk(STp, "Can't read medium partition page.\n");
1da177e4
LT		 3315 result = (-EIO);
3316 } else {
3317 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3318 PP_OFF_NBR_ADD_PARTS] + 1;
b30d8bca 3319 DEBC_printk(STp, "Number of partitions %d.\n", result);
1da177e4
LT		 3320 }
3321
3322 return result;
3323}
3324
3325
3326/* Partition the tape into two partitions if size > 0 or one partition if
3327 size == 0.
3328
3329 The block descriptors are read and written because Sony SDT-7000 does not
3330 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3331
3332 My HP C1533A drive returns only one partition size field. This is used to
3333 set the size of partition 1. There is no size field for the default partition.
3334 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3335 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3336 The following algorithm is used to accommodate both drives: if the number of
3337 partition size fields is greater than the maximum number of additional partitions
3338 in the mode page, the second field is used. Otherwise the first field is used.
3339
3340 For Seagate DDS drives the page length must be 8 when no partitions is defined
3341 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3342 is acceptable also to some other old drives and enforced if the first partition
3343 size field is used for the first additional partition size.
3344 */
3345static int partition_tape(struct scsi_tape *STp, int size)
3346{
1da177e4
LT		 3347 int result;
3348 int pgo, psd_cnt, psdo;
3349 unsigned char *bp;
3350
3351 result = read_mode_page(STp, PART_PAGE, 0);
3352 if (result) {
b30d8bca 3353 DEBC_printk(STp, "Can't read partition mode page.\n");
1da177e4
LT		 3354 return result;
3355 }
3356 /* The mode page is in the buffer. Let's modify it and write it. */
3357 bp = (STp->buffer)->b_data;
3358 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
b30d8bca
HR		 3359 DEBC_printk(STp, "Partition page length is %d bytes.\n",
3360 bp[pgo + MP_OFF_PAGE_LENGTH] + 2);
1da177e4
LT		 3361
3362 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3363 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3364 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3365 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3366 psdo += 2;
3367 }
3368 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3369
b30d8bca 3370 DEBC_printk(STp, "psd_cnt %d, max.parts %d, nbr_parts %d\n",
1da177e4 3371 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
b30d8bca 3372 bp[pgo + PP_OFF_NBR_ADD_PARTS]);
1da177e4
LT		 3373
3374 if (size <= 0) {
3375 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3376 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3377 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
b30d8bca 3378 DEBC_printk(STp, "Formatting tape with one partition.\n");
1da177e4
LT		 3379 } else {
3380 bp[psdo] = (size >> 8) & 0xff;
3381 bp[psdo + 1] = size & 0xff;
3382 bp[pgo + 3] = 1;
3383 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3384 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
b30d8bca
HR		 3385 DEBC_printk(STp, "Formatting tape with two partitions "
3386 "(1 = %d MB).\n", size);
1da177e4
LT		 3387 }
3388 bp[pgo + PP_OFF_PART_UNITS] = 0;
3389 bp[pgo + PP_OFF_RESERVED] = 0;
3390 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3391
3392 result = write_mode_page(STp, PART_PAGE, 1);
3393 if (result) {
b30d8bca 3394 st_printk(KERN_INFO, STp, "Partitioning of tape failed.\n");
1da177e4
LT		 3395 result = (-EIO);
3396 }
3397
3398 return result;
3399}
3400\f
3401
3402
3403/* The ioctl command */
fd66c1b4 3404static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
1da177e4
LT		 3405{
3406 int i, cmd_nr, cmd_type, bt;
3407 int retval = 0;
3408 unsigned int blk;
3409 struct scsi_tape *STp = file->private_data;
3410 struct st_modedef *STm;
3411 struct st_partstat *STps;
1da177e4
LT		 3412 void __user *p = (void __user *)arg;
3413
28f85009 3414 if (mutex_lock_interruptible(&STp->lock))
1da177e4
LT		 3415 return -ERESTARTSYS;
3416
b30d8bca 3417 DEB(
1da177e4 3418 if (debugging && !STp->in_use) {
b30d8bca 3419 st_printk(ST_DEB_MSG, STp, "Incorrect device.\n");
1da177e4
LT		 3420 retval = (-EIO);
3421 goto out;
3422 } ) /* end DEB */
3423
3424 STm = &(STp->modes[STp->current_mode]);
3425 STps = &(STp->ps[STp->partition]);
3426
3427 /*
3428 * If we are in the middle of error recovery, don't let anyone
3429 * else try and use this device. Also, if error recovery fails, it
3430 * may try and take the device offline, in which case all further
3431 * access to the device is prohibited.
3432 */
906d15fb
CH		 3433 retval = scsi_ioctl_block_when_processing_errors(STp->device, cmd_in,
3434 file->f_flags & O_NDELAY);
3435 if (retval)
1da177e4 3436 goto out;
1da177e4
LT		 3437
3438 cmd_type = _IOC_TYPE(cmd_in);
3439 cmd_nr = _IOC_NR(cmd_in);
3440
3441 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3442 struct mtop mtc;
3443
3444 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3445 retval = (-EINVAL);
3446 goto out;
3447 }
3448
3449 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3450 if (i) {
3451 retval = (-EFAULT);
3452 goto out;
3453 }
3454
3455 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
b30d8bca
HR		 3456 st_printk(KERN_WARNING, STp,
3457 "MTSETDRVBUFFER only allowed for root.\n");
1da177e4
LT		 3458 retval = (-EPERM);
3459 goto out;
3460 }
3461 if (!STm->defined &&
3462 (mtc.mt_op != MTSETDRVBUFFER &&
3463 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3464 retval = (-ENXIO);
3465 goto out;
3466 }
3467
3468 if (!STp->pos_unknown) {
3469
3470 if (STps->eof == ST_FM_HIT) {
3471 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3472 mtc.mt_op == MTEOM) {
3473 mtc.mt_count -= 1;
3474 if (STps->drv_file >= 0)
3475 STps->drv_file += 1;
3476 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3477 mtc.mt_count += 1;
3478 if (STps->drv_file >= 0)
3479 STps->drv_file += 1;
3480 }
3481 }
3482
3483 if (mtc.mt_op == MTSEEK) {
3484 /* Old position must be restored if partition will be
3485 changed */
3486 i = !STp->can_partitions ||
3487 (STp->new_partition != STp->partition);
3488 } else {
3489 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3490 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3491 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3492 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3493 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3494 mtc.mt_op == MTCOMPRESSION;
3495 }
3496 i = flush_buffer(STp, i);
3497 if (i < 0) {
3498 retval = i;
3499 goto out;
3500 }
3501 if (STps->rw == ST_WRITING &&
3502 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3503 mtc.mt_op == MTSEEK ||
3504 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3505 i = st_int_ioctl(STp, MTWEOF, 1);
3506 if (i < 0) {
3507 retval = i;
3508 goto out;
3509 }
3510 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3511 mtc.mt_count++;
3512 STps->rw = ST_IDLE;
3513 }
3514
3515 } else {
3516 /*
3517 * If there was a bus reset, block further access
3518 * to this device. If the user wants to rewind the tape,
3519 * then reset the flag and allow access again.
3520 */
3521 if (mtc.mt_op != MTREW &&
3522 mtc.mt_op != MTOFFL &&
3523 mtc.mt_op != MTRETEN &&
3524 mtc.mt_op != MTERASE &&
3525 mtc.mt_op != MTSEEK &&
3526 mtc.mt_op != MTEOM) {
3527 retval = (-EIO);
3528 goto out;
3529 }
3530 reset_state(STp);
3531 /* remove this when the midlevel properly clears was_reset */
3532 STp->device->was_reset = 0;
3533 }
3534
3535 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3536 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3537 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3538 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3539
3540 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3541 do_door_lock(STp, 0); /* Ignore result! */
3542
3543 if (mtc.mt_op == MTSETDRVBUFFER &&
3544 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3545 retval = st_set_options(STp, mtc.mt_count);
3546 goto out;
3547 }
3548
3549 if (mtc.mt_op == MTSETPART) {
3550 if (!STp->can_partitions ||
3551 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3552 retval = (-EINVAL);
3553 goto out;
3554 }
3555 if (mtc.mt_count >= STp->nbr_partitions &&
3556 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3557 retval = (-EIO);
3558 goto out;
3559 }
3560 if (mtc.mt_count >= STp->nbr_partitions) {
3561 retval = (-EINVAL);
3562 goto out;
3563 }
3564 STp->new_partition = mtc.mt_count;
3565 retval = 0;
3566 goto out;
3567 }
3568
3569 if (mtc.mt_op == MTMKPART) {
3570 if (!STp->can_partitions) {
3571 retval = (-EINVAL);
3572 goto out;
3573 }
3574 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3575 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3576 retval = i;
3577 goto out;
3578 }
3579 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3580 STp->ps[i].rw = ST_IDLE;
3581 STp->ps[i].at_sm = 0;
3582 STp->ps[i].last_block_valid = 0;
3583 }
3584 STp->partition = STp->new_partition = 0;
3585 STp->nbr_partitions = 1; /* Bad guess ?-) */
3586 STps->drv_block = STps->drv_file = 0;
3587 retval = 0;
3588 goto out;
3589 }
3590
3591 if (mtc.mt_op == MTSEEK) {
3592 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3593 if (!STp->can_partitions)
3594 STp->ps[0].rw = ST_IDLE;
3595 retval = i;
3596 goto out;
3597 }
3598
3599 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3600 retval = do_load_unload(STp, file, 0);
3601 goto out;
3602 }
3603
3604 if (mtc.mt_op == MTLOAD) {
3605 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3606 goto out;
3607 }
3608
3609 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3610 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3611 goto out;
3612 }
3613
3614 if (STp->can_partitions && STp->ready == ST_READY &&
3615 (i = switch_partition(STp)) < 0) {
3616 retval = i;
3617 goto out;
3618 }
3619
3620 if (mtc.mt_op == MTCOMPRESSION)
3621 retval = st_compression(STp, (mtc.mt_count & 1));
3622 else
3623 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3624 goto out;
3625 }
3626 if (!STm->defined) {
3627 retval = (-ENXIO);
3628 goto out;
3629 }
3630
3631 if ((i = flush_buffer(STp, 0)) < 0) {
3632 retval = i;
3633 goto out;
3634 }
3635 if (STp->can_partitions &&
3636 (i = switch_partition(STp)) < 0) {
3637 retval = i;
3638 goto out;
3639 }
3640
3641 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3642 struct mtget mt_status;
3643
3644 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3645 retval = (-EINVAL);
3646 goto out;
3647 }
3648
3649 mt_status.mt_type = STp->tape_type;
3650 mt_status.mt_dsreg =
3651 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3652 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3653 mt_status.mt_blkno = STps->drv_block;
3654 mt_status.mt_fileno = STps->drv_file;
3655 if (STp->block_size != 0) {
3656 if (STps->rw == ST_WRITING)
3657 mt_status.mt_blkno +=
3658 (STp->buffer)->buffer_bytes / STp->block_size;
3659 else if (STps->rw == ST_READING)
3660 mt_status.mt_blkno -=
3661 ((STp->buffer)->buffer_bytes +
3662 STp->block_size - 1) / STp->block_size;
3663 }
3664
3665 mt_status.mt_gstat = 0;
3666 if (STp->drv_write_prot)
3667 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3668 if (mt_status.mt_blkno == 0) {
3669 if (mt_status.mt_fileno == 0)
3670 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3671 else
3672 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3673 }
3674 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3675 mt_status.mt_resid = STp->partition;
3676 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3677 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3678 else if (STps->eof >= ST_EOM_OK)
3679 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3680 if (STp->density == 1)
3681 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3682 else if (STp->density == 2)
3683 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3684 else if (STp->density == 3)
3685 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3686 if (STp->ready == ST_READY)
3687 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3688 if (STp->ready == ST_NO_TAPE)
3689 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3690 if (STps->at_sm)
3691 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3692 if (STm->do_async_writes ||
3693 (STm->do_buffer_writes && STp->block_size != 0) ||
3694 STp->drv_buffer != 0)
3695 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3696 if (STp->cleaning_req)
3697 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3698
3699 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3700 if (i) {
3701 retval = (-EFAULT);
3702 goto out;
3703 }
3704
3705 STp->recover_reg = 0; /* Clear after read */
3706 retval = 0;
3707 goto out;
3708 } /* End of MTIOCGET */
3709 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3710 struct mtpos mt_pos;
3711 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3712 retval = (-EINVAL);
3713 goto out;
3714 }
3715 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3716 retval = i;
3717 goto out;
3718 }
3719 mt_pos.mt_blkno = blk;
3720 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3721 if (i)
3722 retval = (-EFAULT);
3723 goto out;
3724 }
28f85009 3725 mutex_unlock(&STp->lock);
1da177e4
LT		 3726 switch (cmd_in) {
3727 case SCSI_IOCTL_GET_IDLUN:
3728 case SCSI_IOCTL_GET_BUS_NUMBER:
3729 break;
3730 default:
16c4b3e2
KM		 3731 if ((cmd_in == SG_IO ||
3732 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3733 cmd_in == CDROM_SEND_PACKET) &&
3734 !capable(CAP_SYS_RAWIO))
1da177e4
LT		 3735 i = -EPERM;
3736 else
74f3c8af
AV		 3737 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3738 file->f_mode, cmd_in, p);
1da177e4
LT		 3739 if (i != -ENOTTY)
3740 return i;
3741 break;
3742 }
16c4b3e2
KM		 3743 retval = scsi_ioctl(STp->device, cmd_in, p);
3744 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3745 STp->rew_at_close = 0;
3746 STp->ready = ST_NO_TAPE;
3747 }
3748 return retval;
1da177e4
LT		 3749
3750 out:
28f85009 3751 mutex_unlock(&STp->lock);
1da177e4
LT		 3752 return retval;
3753}
3754
3755#ifdef CONFIG_COMPAT
3756static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3757{
3758 struct scsi_tape *STp = file->private_data;
3759 struct scsi_device *sdev = STp->device;
3760 int ret = -ENOIOCTLCMD;
3761 if (sdev->host->hostt->compat_ioctl) {
3762
3763 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3764
3765 }
3766 return ret;
3767}
3768#endif
3769
3770\f
3771
3772/* Try to allocate a new tape buffer. Calling function must not hold
3773 dev_arr_lock. */
f409d6cc 3774static struct st_buffer *new_tape_buffer(int need_dma, int max_sg)
1da177e4 3775{
1da177e4
LT		 3776 struct st_buffer *tb;
3777
f409d6cc 3778 tb = kzalloc(sizeof(struct st_buffer), GFP_ATOMIC);
1da177e4
LT		 3779 if (!tb) {
3780 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3781 return NULL;
3782 }
1ac63cf5 3783 tb->frp_segs = 0;
1da177e4 3784 tb->use_sg = max_sg;
1da177e4 3785 tb->dma = need_dma;
f409d6cc 3786 tb->buffer_size = 0;
1da177e4 3787
f409d6cc
FT		 3788 tb->reserved_pages = kzalloc(max_sg * sizeof(struct page *),
3789 GFP_ATOMIC);
d0e1ae31
FT		 3790 if (!tb->reserved_pages) {
3791 kfree(tb);
3792 return NULL;
3793 }
3794
1da177e4
LT		 3795 return tb;
3796}
3797
3798
3799/* Try to allocate enough space in the tape buffer */
8f78fc5e
KM		 3800#define ST_MAX_ORDER 6
3801
1da177e4
LT		 3802static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3803{
769989a4 3804 int segs, max_segs, b_size, order, got;
c53033f6 3805 gfp_t priority;
1da177e4
LT		 3806
3807 if (new_size <= STbuffer->buffer_size)
3808 return 1;
3809
3810 if (STbuffer->buffer_size <= PAGE_SIZE)
3811 normalize_buffer(STbuffer); /* Avoid extra segment */
3812
3813 max_segs = STbuffer->use_sg;
1da177e4
LT		 3814
3815 priority = GFP_KERNEL | __GFP_NOWARN;
3816 if (need_dma)
3817 priority |= GFP_DMA;
9c905966 3818
08c95832
FT		 3819 if (STbuffer->cleared)
3820 priority |= __GFP_ZERO;
3821
9c905966 3822 if (STbuffer->frp_segs) {
c982c368 3823 order = STbuffer->reserved_page_order;
08c95832 3824 b_size = PAGE_SIZE << order;
9c905966
FT		 3825 } else {
3826 for (b_size = PAGE_SIZE, order = 0;
46081b16
FT		 3827 order < ST_MAX_ORDER &&
3828 max_segs * (PAGE_SIZE << order) < new_size;
8f78fc5e 3829 order++, b_size *= 2)
9c905966 3830 ; /* empty */
373daacf 3831 STbuffer->reserved_page_order = order;
9c905966 3832 }
8f78fc5e
KM		 3833 if (max_segs * (PAGE_SIZE << order) < new_size) {
3834 if (order == ST_MAX_ORDER)
3835 return 0;
3836 normalize_buffer(STbuffer);
3837 return enlarge_buffer(STbuffer, new_size, need_dma);
3838 }
1da177e4
LT		 3839
3840 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3841 segs < max_segs && got < new_size;) {
08c95832
FT		 3842 struct page *page;
3843
3844 page = alloc_pages(priority, order);
3845 if (!page) {
1da177e4
LT		 3846 DEB(STbuffer->buffer_size = got);
3847 normalize_buffer(STbuffer);
3848 return 0;
3849 }
08c95832 3850
1da177e4
LT		 3851 STbuffer->frp_segs += 1;
3852 got += b_size;
3853 STbuffer->buffer_size = got;
08c95832 3854 STbuffer->reserved_pages[segs] = page;
1da177e4
LT		 3855 segs++;
3856 }
08c95832 3857 STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
1da177e4
LT		 3858
3859 return 1;
3860}
3861
3862
40f6b36c
KM		 3863/* Make sure that no data from previous user is in the internal buffer */
3864static void clear_buffer(struct st_buffer * st_bp)
3865{
3866 int i;
3867
3868 for (i=0; i < st_bp->frp_segs; i++)
08c95832 3869 memset(page_address(st_bp->reserved_pages[i]), 0,
c982c368 3870 PAGE_SIZE << st_bp->reserved_page_order);
40f6b36c
KM		 3871 st_bp->cleared = 1;
3872}
3873
3874
1da177e4
LT		 3875/* Release the extra buffer */
3876static void normalize_buffer(struct st_buffer * STbuffer)
3877{
c982c368 3878 int i, order = STbuffer->reserved_page_order;
1da177e4 3879
1ac63cf5 3880 for (i = 0; i < STbuffer->frp_segs; i++) {
08c95832
FT		 3881 __free_pages(STbuffer->reserved_pages[i], order);
3882 STbuffer->buffer_size -= (PAGE_SIZE << order);
1da177e4 3883 }
1ac63cf5 3884 STbuffer->frp_segs = 0;
8b05b773 3885 STbuffer->sg_segs = 0;
c982c368 3886 STbuffer->reserved_page_order = 0;
d0e1ae31 3887 STbuffer->map_data.offset = 0;
1da177e4
LT		 3888}
3889
3890
3891/* Move data from the user buffer to the tape buffer. Returns zero (success) or
3892 negative error code. */
3893static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3894{
3895 int i, cnt, res, offset;
c982c368 3896 int length = PAGE_SIZE << st_bp->reserved_page_order;
1da177e4
LT		 3897
3898 for (i = 0, offset = st_bp->buffer_bytes;
08c95832
FT		 3899 i < st_bp->frp_segs && offset >= length; i++)
3900 offset -= length;
1da177e4
LT		 3901 if (i == st_bp->frp_segs) { /* Should never happen */
3902 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3903 return (-EIO);
3904 }
3905 for (; i < st_bp->frp_segs && do_count > 0; i++) {
08c95832
FT		 3906 struct page *page = st_bp->reserved_pages[i];
3907 cnt = length - offset < do_count ? length - offset : do_count;
3908 res = copy_from_user(page_address(page) + offset, ubp, cnt);
1da177e4
LT		 3909 if (res)
3910 return (-EFAULT);
3911 do_count -= cnt;
3912 st_bp->buffer_bytes += cnt;
3913 ubp += cnt;
3914 offset = 0;
3915 }
3916 if (do_count) /* Should never happen */
3917 return (-EIO);
3918
3919 return 0;
3920}
3921
3922
3923/* Move data from the tape buffer to the user buffer. Returns zero (success) or
3924 negative error code. */
3925static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3926{
3927 int i, cnt, res, offset;
c982c368 3928 int length = PAGE_SIZE << st_bp->reserved_page_order;
1da177e4
LT		 3929
3930 for (i = 0, offset = st_bp->read_pointer;
08c95832
FT		 3931 i < st_bp->frp_segs && offset >= length; i++)
3932 offset -= length;
1da177e4
LT		 3933 if (i == st_bp->frp_segs) { /* Should never happen */
3934 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3935 return (-EIO);
3936 }
3937 for (; i < st_bp->frp_segs && do_count > 0; i++) {
08c95832
FT		 3938 struct page *page = st_bp->reserved_pages[i];
3939 cnt = length - offset < do_count ? length - offset : do_count;
3940 res = copy_to_user(ubp, page_address(page) + offset, cnt);
1da177e4
LT		 3941 if (res)
3942 return (-EFAULT);
3943 do_count -= cnt;
3944 st_bp->buffer_bytes -= cnt;
3945 st_bp->read_pointer += cnt;
3946 ubp += cnt;
3947 offset = 0;
3948 }
3949 if (do_count) /* Should never happen */
3950 return (-EIO);
3951
3952 return 0;
3953}
3954
3955
3956/* Move data towards start of buffer */
3957static void move_buffer_data(struct st_buffer * st_bp, int offset)
3958{
3959 int src_seg, dst_seg, src_offset = 0, dst_offset;
3960 int count, total;
c982c368 3961 int length = PAGE_SIZE << st_bp->reserved_page_order;
1da177e4
LT		 3962
3963 if (offset == 0)
3964 return;
3965
3966 total=st_bp->buffer_bytes - offset;
3967 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3968 src_offset = offset;
08c95832 3969 if (src_offset < length)
1da177e4 3970 break;
08c95832 3971 offset -= length;
1da177e4
LT		 3972 }
3973
3974 st_bp->buffer_bytes = st_bp->read_pointer = total;
3975 for (dst_seg=dst_offset=0; total > 0; ) {
08c95832
FT		 3976 struct page *dpage = st_bp->reserved_pages[dst_seg];
3977 struct page *spage = st_bp->reserved_pages[src_seg];
3978
3979 count = min(length - dst_offset, length - src_offset);
3980 memmove(page_address(dpage) + dst_offset,
3981 page_address(spage) + src_offset, count);
1da177e4 3982 src_offset += count;
08c95832 3983 if (src_offset >= length) {
1da177e4
LT		 3984 src_seg++;
3985 src_offset = 0;
3986 }
3987 dst_offset += count;
08c95832 3988 if (dst_offset >= length) {
1da177e4
LT		 3989 dst_seg++;
3990 dst_offset = 0;
3991 }
3992 total -= count;
3993 }
3994}
3995
1da177e4
LT		 3996/* Validate the options from command line or module parameters */
3997static void validate_options(void)
3998{
3999 if (buffer_kbs > 0)
4000 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
4001 if (max_sg_segs >= ST_FIRST_SG)
4002 st_max_sg_segs = max_sg_segs;
4003}
4004
4005#ifndef MODULE
4006/* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
4007 */
4008static int __init st_setup(char *str)
4009{
4010 int i, len, ints[5];
4011 char *stp;
4012
4013 stp = get_options(str, ARRAY_SIZE(ints), ints);
4014
4015 if (ints[0] > 0) {
4016 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
4017 if (parms[i].val)
4018 *parms[i].val = ints[i + 1];
4019 } else {
4020 while (stp != NULL) {
4021 for (i = 0; i < ARRAY_SIZE(parms); i++) {
4022 len = strlen(parms[i].name);
4023 if (!strncmp(stp, parms[i].name, len) &&
4024 (*(stp + len) == ':' || *(stp + len) == '=')) {
4025 if (parms[i].val)
4026 *parms[i].val =
4027 simple_strtoul(stp + len + 1, NULL, 0);
4028 else
4029 printk(KERN_WARNING "st: Obsolete parameter %s\n",
4030 parms[i].name);
4031 break;
4032 }
4033 }
6391a113 4034 if (i >= ARRAY_SIZE(parms))
1da177e4
LT		 4035 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
4036 stp);
4037 stp = strchr(stp, ',');
4038 if (stp)
4039 stp++;
4040 }
4041 }
4042
4043 validate_options();
4044
4045 return 1;
4046}
4047
4048__setup("st=", st_setup);
4049
4050#endif
4051
00977a59 4052static const struct file_operations st_fops =
1da177e4
LT		 4053{
4054 .owner = THIS_MODULE,
4055 .read = st_read,
4056 .write = st_write,
fd66c1b4 4057 .unlocked_ioctl = st_ioctl,
1da177e4
LT		 4058#ifdef CONFIG_COMPAT
4059 .compat_ioctl = st_compat_ioctl,
4060#endif
4061 .open = st_open,
4062 .flush = st_flush,
4063 .release = st_release,
b4d878e2 4064 .llseek = noop_llseek,
1da177e4
LT		 4065};
4066
26898afd
JM		 4067static int create_one_cdev(struct scsi_tape *tape, int mode, int rew)
4068{
4069 int i, error;
4070 dev_t cdev_devno;
4071 struct cdev *cdev;
4072 struct device *dev;
4073 struct st_modedef *STm = &(tape->modes[mode]);
4074 char name[10];
4075 int dev_num = tape->index;
4076
4077 cdev_devno = MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, rew));
4078
4079 cdev = cdev_alloc();
4080 if (!cdev) {
4081 pr_err("st%d: out of memory. Device not attached.\n", dev_num);
4082 error = -ENOMEM;
4083 goto out;
4084 }
4085 cdev->owner = THIS_MODULE;
4086 cdev->ops = &st_fops;
4087
4088 error = cdev_add(cdev, cdev_devno, 1);
4089 if (error) {
4090 pr_err("st%d: Can't add %s-rewind mode %d\n", dev_num,
4091 rew ? "non" : "auto", mode);
4092 pr_err("st%d: Device not attached.\n", dev_num);
4093 goto out_free;
4094 }
4095 STm->cdevs[rew] = cdev;
4096
4097 i = mode << (4 - ST_NBR_MODE_BITS);
4098 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4099 tape->disk->disk_name, st_formats[i]);
4100
4101 dev = device_create(&st_sysfs_class, &tape->device->sdev_gendev,
4102 cdev_devno, &tape->modes[mode], "%s", name);
4103 if (IS_ERR(dev)) {
4104 pr_err("st%d: device_create failed\n", dev_num);
4105 error = PTR_ERR(dev);
4106 goto out_free;
4107 }
4108
4109 STm->devs[rew] = dev;
4110
4111 return 0;
4112out_free:
4113 cdev_del(STm->cdevs[rew]);
4114 STm->cdevs[rew] = NULL;
4115out:
4116 return error;
4117}
4118
4119static int create_cdevs(struct scsi_tape *tape)
4120{
4121 int mode, error;
4122 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4123 error = create_one_cdev(tape, mode, 0);
4124 if (error)
4125 return error;
4126 error = create_one_cdev(tape, mode, 1);
4127 if (error)
4128 return error;
4129 }
4130
4131 return sysfs_create_link(&tape->device->sdev_gendev.kobj,
4132 &tape->modes[0].devs[0]->kobj, "tape");
4133}
4134
4135static void remove_cdevs(struct scsi_tape *tape)
4136{
4137 int mode, rew;
4138 sysfs_remove_link(&tape->device->sdev_gendev.kobj, "tape");
4139 for (mode = 0; mode < ST_NBR_MODES; mode++) {
4140 struct st_modedef *STm = &(tape->modes[mode]);
4141 for (rew = 0; rew < 2; rew++) {
4142 if (STm->cdevs[rew])
4143 cdev_del(STm->cdevs[rew]);
4144 if (STm->devs[rew])
4145 device_unregister(STm->devs[rew]);
4146 }
4147 }
4148}
4149
1da177e4
LT		 4150static int st_probe(struct device *dev)
4151{
4152 struct scsi_device *SDp = to_scsi_device(dev);
4153 struct gendisk *disk = NULL;
1da177e4
LT		 4154 struct scsi_tape *tpnt = NULL;
4155 struct st_modedef *STm;
4156 struct st_partstat *STps;
4157 struct st_buffer *buffer;
b98c52b5 4158 int i, error;
1da177e4 4159 char *stp;
1da177e4
LT		 4160
4161 if (SDp->type != TYPE_TAPE)
4162 return -ENODEV;
4163 if ((stp = st_incompatible(SDp))) {
3bf743e7 4164 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
b30d8bca
HR		 4165 sdev_printk(KERN_INFO, SDp,
4166 "st: The suggested driver is %s.\n", stp);
1da177e4
LT		 4167 return -ENODEV;
4168 }
4169
6fe8c1db 4170 scsi_autopm_get_device(SDp);
8a78362c 4171 i = queue_max_segments(SDp->request_queue);
1da177e4
LT		 4172 if (st_max_sg_segs < i)
4173 i = st_max_sg_segs;
f409d6cc 4174 buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
1da177e4 4175 if (buffer == NULL) {
b30d8bca
HR		 4176 sdev_printk(KERN_ERR, SDp,
4177 "st: Can't allocate new tape buffer. "
4178 "Device not attached.\n");
1da177e4
LT		 4179 goto out;
4180 }
4181
4182 disk = alloc_disk(1);
4183 if (!disk) {
b30d8bca
HR		 4184 sdev_printk(KERN_ERR, SDp,
4185 "st: out of memory. Device not attached.\n");
1da177e4
LT		 4186 goto out_buffer_free;
4187 }
4188
24669f75 4189 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
1da177e4 4190 if (tpnt == NULL) {
b30d8bca
HR		 4191 sdev_printk(KERN_ERR, SDp,
4192 "st: Can't allocate device descriptor.\n");
1da177e4
LT		 4193 goto out_put_disk;
4194 }
f03a5670 4195 kref_init(&tpnt->kref);
1da177e4 4196 tpnt->disk = disk;
1da177e4
LT		 4197 disk->private_data = &tpnt->driver;
4198 disk->queue = SDp->request_queue;
2b5bebcc
JL		 4199 /* SCSI tape doesn't register this gendisk via add_disk(). Manually
4200 * take queue reference that release_disk() expects. */
4201 if (!blk_get_queue(disk->queue))
4202 goto out_put_disk;
1da177e4 4203 tpnt->driver = &st_template;
1da177e4
LT		 4204
4205 tpnt->device = SDp;
4206 if (SDp->scsi_level <= 2)
4207 tpnt->tape_type = MT_ISSCSI1;
4208 else
4209 tpnt->tape_type = MT_ISSCSI2;
4210
4211 tpnt->buffer = buffer;
f03a5670 4212 tpnt->buffer->last_SRpnt = NULL;
1da177e4
LT		 4213
4214 tpnt->inited = 0;
4215 tpnt->dirty = 0;
4216 tpnt->in_use = 0;
4217 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
4218 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4219 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4220 tpnt->density = 0;
4221 tpnt->do_auto_lock = ST_AUTO_LOCK;
4222 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4223 tpnt->can_partitions = 0;
4224 tpnt->two_fm = ST_TWO_FM;
4225 tpnt->fast_mteom = ST_FAST_MTEOM;
4226 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
40f6b36c 4227 tpnt->sili = ST_SILI;
1da177e4 4228 tpnt->immediate = ST_NOWAIT;
c743e44f 4229 tpnt->immediate_filemark = 0;
1da177e4
LT		 4230 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
4231 tpnt->partition = 0;
4232 tpnt->new_partition = 0;
4233 tpnt->nbr_partitions = 0;
a02488ed 4234 blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
1da177e4
LT		 4235 tpnt->long_timeout = ST_LONG_TIMEOUT;
4236 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4237
1da177e4
LT		 4238 for (i = 0; i < ST_NBR_MODES; i++) {
4239 STm = &(tpnt->modes[i]);
4240 STm->defined = 0;
4241 STm->sysv = ST_SYSV;
4242 STm->defaults_for_writes = 0;
4243 STm->do_async_writes = ST_ASYNC_WRITES;
4244 STm->do_buffer_writes = ST_BUFFER_WRITES;
4245 STm->do_read_ahead = ST_READ_AHEAD;
4246 STm->default_compression = ST_DONT_TOUCH;
4247 STm->default_blksize = (-1); /* No forced size */
4248 STm->default_density = (-1); /* No forced density */
6c648d95 4249 STm->tape = tpnt;
1da177e4
LT		 4250 }
4251
4252 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4253 STps = &(tpnt->ps[i]);
4254 STps->rw = ST_IDLE;
4255 STps->eof = ST_NOEOF;
4256 STps->at_sm = 0;
4257 STps->last_block_valid = 0;
4258 STps->drv_block = (-1);
4259 STps->drv_file = (-1);
4260 }
4261
4262 tpnt->current_mode = 0;
4263 tpnt->modes[0].defined = 1;
4264
4265 tpnt->density_changed = tpnt->compression_changed =
4266 tpnt->blksize_changed = 0;
28f85009 4267 mutex_init(&tpnt->lock);
1da177e4 4268
b98c52b5 4269 idr_preload(GFP_KERNEL);
6c648d95 4270 spin_lock(&st_index_lock);
b98c52b5 4271 error = idr_alloc(&st_index_idr, tpnt, 0, ST_MAX_TAPES + 1, GFP_NOWAIT);
6c648d95 4272 spin_unlock(&st_index_lock);
b98c52b5
TH		 4273 idr_preload_end();
4274 if (error < 0) {
6c648d95 4275 pr_warn("st: idr allocation failed: %d\n", error);
2b5bebcc 4276 goto out_put_queue;
6c648d95 4277 }
b98c52b5
TH		 4278 tpnt->index = error;
4279 sprintf(disk->disk_name, "st%d", tpnt->index);
05545c92
SS		 4280 tpnt->stats = kzalloc(sizeof(struct scsi_tape_stats), GFP_KERNEL);
4281 if (tpnt->stats == NULL) {
4282 sdev_printk(KERN_ERR, SDp,
4283 "st: Can't allocate statistics.\n");
4284 goto out_idr_remove;
4285 }
6c648d95
JM		 4286
4287 dev_set_drvdata(dev, tpnt);
1da177e4 4288
1da177e4 4289
26898afd
JM		 4290 error = create_cdevs(tpnt);
4291 if (error)
4292 goto out_remove_devs;
46a243f7 4293 scsi_autopm_put_device(SDp);
1da177e4 4294
42252854 4295 sdev_printk(KERN_NOTICE, SDp,
8b1ea24c 4296 "Attached scsi tape %s\n", tape_name(tpnt));
42252854
KM		 4297 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4298 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4299 queue_dma_alignment(SDp->request_queue) + 1);
1da177e4
LT		 4300
4301 return 0;
4302
26898afd
JM		 4303out_remove_devs:
4304 remove_cdevs(tpnt);
05545c92
SS		 4305 kfree(tpnt->stats);
4306out_idr_remove:
6c648d95 4307 spin_lock(&st_index_lock);
b98c52b5 4308 idr_remove(&st_index_idr, tpnt->index);
6c648d95 4309 spin_unlock(&st_index_lock);
2b5bebcc
JL		 4310out_put_queue:
4311 blk_put_queue(disk->queue);
1da177e4
LT		 4312out_put_disk:
4313 put_disk(disk);
c9475cb0 4314 kfree(tpnt);
1da177e4
LT		 4315out_buffer_free:
4316 kfree(buffer);
4317out:
6fe8c1db 4318 scsi_autopm_put_device(SDp);
1da177e4
LT		 4319 return -ENODEV;
4320};
4321
4322
4323static int st_remove(struct device *dev)
4324{
6c648d95 4325 struct scsi_tape *tpnt = dev_get_drvdata(dev);
6c648d95
JM		 4326 int index = tpnt->index;
4327
4328 scsi_autopm_get_device(to_scsi_device(dev));
26898afd 4329 remove_cdevs(tpnt);
1da177e4 4330
6c648d95
JM		 4331 mutex_lock(&st_ref_mutex);
4332 kref_put(&tpnt->kref, scsi_tape_release);
4333 mutex_unlock(&st_ref_mutex);
4334 spin_lock(&st_index_lock);
4335 idr_remove(&st_index_idr, index);
4336 spin_unlock(&st_index_lock);
1da177e4
LT		 4337 return 0;
4338}
4339
f03a5670
KM		 4340/**
4341 * scsi_tape_release - Called to free the Scsi_Tape structure
4342 * @kref: pointer to embedded kref
4343 *
0b950672 4344 * st_ref_mutex must be held entering this routine. Because it is
f03a5670
KM		 4345 * called on last put, you should always use the scsi_tape_get()
4346 * scsi_tape_put() helpers which manipulate the semaphore directly
4347 * and never do a direct kref_put().
4348 **/
4349static void scsi_tape_release(struct kref *kref)
4350{
4351 struct scsi_tape *tpnt = to_scsi_tape(kref);
4352 struct gendisk *disk = tpnt->disk;
4353
4354 tpnt->device = NULL;
4355
4356 if (tpnt->buffer) {
f03a5670 4357 normalize_buffer(tpnt->buffer);
d0e1ae31 4358 kfree(tpnt->buffer->reserved_pages);
f03a5670
KM		 4359 kfree(tpnt->buffer);
4360 }
4361
4362 disk->private_data = NULL;
4363 put_disk(disk);
05545c92 4364 kfree(tpnt->stats);
f03a5670
KM		 4365 kfree(tpnt);
4366 return;
4367}
4368
af23782b
JM		 4369static struct class st_sysfs_class = {
4370 .name = "scsi_tape",
c69c6be5 4371 .dev_groups = st_dev_groups,
af23782b
JM		 4372};
4373
1da177e4
LT		 4374static int __init init_st(void)
4375{
13026a6b
JG		 4376 int err;
4377
1da177e4
LT		 4378 validate_options();
4379
13026a6b 4380 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
1da177e4
LT		 4381 verstr, st_fixed_buffer_size, st_max_sg_segs);
4382
2bec708a
LO		 4383 debugging = (debug_flag > 0) ? debug_flag : NO_DEBUG;
4384 if (debugging) {
4385 printk(KERN_INFO "st: Debugging enabled debug_flag = %d\n",
4386 debugging);
4387 }
4388
af23782b
JM		 4389 err = class_register(&st_sysfs_class);
4390 if (err) {
4391 pr_err("Unable register sysfs class for SCSI tapes\n");
4392 return err;
1da177e4
LT		 4393 }
4394
13026a6b
JG		 4395 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4396 ST_MAX_TAPE_ENTRIES, "st");
4397 if (err) {
4398 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4399 SCSI_TAPE_MAJOR);
4400 goto err_class;
1da177e4
LT		 4401 }
4402
13026a6b
JG		 4403 err = scsi_register_driver(&st_template.gendrv);
4404 if (err)
4405 goto err_chrdev;
4406
405ae7d3 4407 err = do_create_sysfs_files();
13026a6b
JG		 4408 if (err)
4409 goto err_scsidrv;
4410
4411 return 0;
4412
4413err_scsidrv:
4414 scsi_unregister_driver(&st_template.gendrv);
4415err_chrdev:
4416 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4417 ST_MAX_TAPE_ENTRIES);
4418err_class:
af23782b 4419 class_unregister(&st_sysfs_class);
13026a6b 4420 return err;
1da177e4
LT		 4421}
4422
4423static void __exit exit_st(void)
4424{
405ae7d3 4425 do_remove_sysfs_files();
1da177e4
LT		 4426 scsi_unregister_driver(&st_template.gendrv);
4427 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4428 ST_MAX_TAPE_ENTRIES);
af23782b 4429 class_unregister(&st_sysfs_class);
1da177e4
LT		 4430 printk(KERN_INFO "st: Unloaded.\n");
4431}
4432
4433module_init(init_st);
4434module_exit(exit_st);
4435
4436
4437/* The sysfs driver interface. Read-only at the moment */
4438static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4439{
4440 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4441}
4442static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4443
4444static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4445{
4446 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4447}
4448static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4449
4450static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4451{
4452 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4453}
4454static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4455
4456static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4457{
4458 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4459}
4460static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4461
405ae7d3 4462static int do_create_sysfs_files(void)
1da177e4 4463{
405ae7d3 4464 struct device_driver *sysfs = &st_template.gendrv;
13026a6b
JG		 4465 int err;
4466
405ae7d3 4467 err = driver_create_file(sysfs, &driver_attr_try_direct_io);
13026a6b
JG		 4468 if (err)
4469 return err;
405ae7d3 4470 err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
13026a6b
JG		 4471 if (err)
4472 goto err_try_direct_io;
405ae7d3 4473 err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
13026a6b
JG		 4474 if (err)
4475 goto err_attr_fixed_buf;
405ae7d3 4476 err = driver_create_file(sysfs, &driver_attr_version);
13026a6b
JG		 4477 if (err)
4478 goto err_attr_max_sg;
1da177e4 4479
13026a6b
JG		 4480 return 0;
4481
4482err_attr_max_sg:
405ae7d3 4483 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
13026a6b 4484err_attr_fixed_buf:
405ae7d3 4485 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
13026a6b 4486err_try_direct_io:
405ae7d3 4487 driver_remove_file(sysfs, &driver_attr_try_direct_io);
13026a6b 4488 return err;
1da177e4
LT		 4489}
4490
405ae7d3 4491static void do_remove_sysfs_files(void)
1da177e4 4492{
405ae7d3 4493 struct device_driver *sysfs = &st_template.gendrv;
1da177e4 4494
405ae7d3
RD		 4495 driver_remove_file(sysfs, &driver_attr_version);
4496 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4497 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4498 driver_remove_file(sysfs, &driver_attr_try_direct_io);
1da177e4
LT		 4499}
4500
1da177e4 4501/* The sysfs simple class interface */
ee959b00 4502static ssize_t
af23782b 4503defined_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4 4504{
7d15d6a4 4505 struct st_modedef *STm = dev_get_drvdata(dev);
1da177e4
LT		 4506 ssize_t l = 0;
4507
4508 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4509 return l;
4510}
c69c6be5 4511static DEVICE_ATTR_RO(defined);
1da177e4 4512
ee959b00 4513static ssize_t
af23782b
JM		 4514default_blksize_show(struct device *dev, struct device_attribute *attr,
4515 char *buf)
1da177e4 4516{
7d15d6a4 4517 struct st_modedef *STm = dev_get_drvdata(dev);
1da177e4
LT		 4518 ssize_t l = 0;
4519
4520 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4521 return l;
4522}
c69c6be5 4523static DEVICE_ATTR_RO(default_blksize);
1da177e4 4524
ee959b00 4525static ssize_t
af23782b
JM		 4526default_density_show(struct device *dev, struct device_attribute *attr,
4527 char *buf)
1da177e4 4528{
7d15d6a4 4529 struct st_modedef *STm = dev_get_drvdata(dev);
1da177e4
LT		 4530 ssize_t l = 0;
4531 char *fmt;
4532
4533 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4534 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4535 return l;
4536}
c69c6be5 4537static DEVICE_ATTR_RO(default_density);
1da177e4 4538
ee959b00 4539static ssize_t
af23782b
JM		 4540default_compression_show(struct device *dev, struct device_attribute *attr,
4541 char *buf)
1da177e4 4542{
7d15d6a4 4543 struct st_modedef *STm = dev_get_drvdata(dev);
1da177e4
LT		 4544 ssize_t l = 0;
4545
4546 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4547 return l;
4548}
c69c6be5 4549static DEVICE_ATTR_RO(default_compression);
1da177e4 4550
ee959b00 4551static ssize_t
af23782b 4552options_show(struct device *dev, struct device_attribute *attr, char *buf)
b174be02 4553{
7d15d6a4 4554 struct st_modedef *STm = dev_get_drvdata(dev);
6c648d95
JM		 4555 struct scsi_tape *STp = STm->tape;
4556 int options;
b174be02
KM		 4557 ssize_t l = 0;
4558
b174be02
KM		 4559 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4560 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4561 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4562 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4563 options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4564 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4565 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4566 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4567 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4568 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4569 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4570 options |= STm->sysv ? MT_ST_SYSV : 0;
4571 options |= STp->immediate ? MT_ST_NOWAIT : 0;
c743e44f 4572 options |= STp->immediate_filemark ? MT_ST_NOWAIT_EOF : 0;
b174be02
KM		 4573 options |= STp->sili ? MT_ST_SILI : 0;
4574
4575 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4576 return l;
4577}
c69c6be5
GKH		 4578static DEVICE_ATTR_RO(options);
4579
05545c92
SS		 4580/* Support for tape stats */
4581
4582/**
4583 * read_cnt_show - return read count - count of reads made from tape drive
4584 * @dev: struct device
4585 * @attr: attribute structure
4586 * @buf: buffer to return formatted data in
4587 */
4588static ssize_t read_cnt_show(struct device *dev,
4589 struct device_attribute *attr, char *buf)
4590{
4591 struct st_modedef *STm = dev_get_drvdata(dev);
4592
4593 return sprintf(buf, "%lld",
4594 (long long)atomic64_read(&STm->tape->stats->read_cnt));
4595}
4596static DEVICE_ATTR_RO(read_cnt);
4597
4598/**
4599 * read_byte_cnt_show - return read byte count - tape drives
4600 * may use blocks less than 512 bytes this gives the raw byte count of
4601 * of data read from the tape drive.
4602 * @dev: struct device
4603 * @attr: attribute structure
4604 * @buf: buffer to return formatted data in
4605 */
4606static ssize_t read_byte_cnt_show(struct device *dev,
4607 struct device_attribute *attr, char *buf)
4608{
4609 struct st_modedef *STm = dev_get_drvdata(dev);
4610
4611 return sprintf(buf, "%lld",
4612 (long long)atomic64_read(&STm->tape->stats->read_byte_cnt));
4613}
4614static DEVICE_ATTR_RO(read_byte_cnt);
4615
4616/**
4617 * read_us_show - return read us - overall time spent waiting on reads in ns.
4618 * @dev: struct device
4619 * @attr: attribute structure
4620 * @buf: buffer to return formatted data in
4621 */
4622static ssize_t read_ns_show(struct device *dev,
4623 struct device_attribute *attr, char *buf)
4624{
4625 struct st_modedef *STm = dev_get_drvdata(dev);
4626
4627 return sprintf(buf, "%lld",
4628 (long long)atomic64_read(&STm->tape->stats->tot_read_time));
4629}
4630static DEVICE_ATTR_RO(read_ns);
4631
4632/**
4633 * write_cnt_show - write count - number of user calls
4634 * to write(2) that have written data to tape.
4635 * @dev: struct device
4636 * @attr: attribute structure
4637 * @buf: buffer to return formatted data in
4638 */
4639static ssize_t write_cnt_show(struct device *dev,
4640 struct device_attribute *attr, char *buf)
4641{
4642 struct st_modedef *STm = dev_get_drvdata(dev);
4643
4644 return sprintf(buf, "%lld",
4645 (long long)atomic64_read(&STm->tape->stats->write_cnt));
4646}
4647static DEVICE_ATTR_RO(write_cnt);
4648
4649/**
4650 * write_byte_cnt_show - write byte count - raw count of
4651 * bytes written to tape.
4652 * @dev: struct device
4653 * @attr: attribute structure
4654 * @buf: buffer to return formatted data in
4655 */
4656static ssize_t write_byte_cnt_show(struct device *dev,
4657 struct device_attribute *attr, char *buf)
4658{
4659 struct st_modedef *STm = dev_get_drvdata(dev);
4660
4661 return sprintf(buf, "%lld",
4662 (long long)atomic64_read(&STm->tape->stats->write_byte_cnt));
4663}
4664static DEVICE_ATTR_RO(write_byte_cnt);
4665
4666/**
4667 * write_ns_show - write ns - number of nanoseconds waiting on write
4668 * requests to complete.
4669 * @dev: struct device
4670 * @attr: attribute structure
4671 * @buf: buffer to return formatted data in
4672 */
4673static ssize_t write_ns_show(struct device *dev,
4674 struct device_attribute *attr, char *buf)
4675{
4676 struct st_modedef *STm = dev_get_drvdata(dev);
4677
4678 return sprintf(buf, "%lld",
4679 (long long)atomic64_read(&STm->tape->stats->tot_write_time));
4680}
4681static DEVICE_ATTR_RO(write_ns);
4682
4683/**
4684 * in_flight_show - number of I/Os currently in flight -
4685 * in most cases this will be either 0 or 1. It may be higher if someone
4686 * has also issued other SCSI commands such as via an ioctl.
4687 * @dev: struct device
4688 * @attr: attribute structure
4689 * @buf: buffer to return formatted data in
4690 */
4691static ssize_t in_flight_show(struct device *dev,
4692 struct device_attribute *attr, char *buf)
4693{
4694 struct st_modedef *STm = dev_get_drvdata(dev);
4695
4696 return sprintf(buf, "%lld",
4697 (long long)atomic64_read(&STm->tape->stats->in_flight));
4698}
4699static DEVICE_ATTR_RO(in_flight);
4700
4701/**
4702 * io_ns_show - io wait ns - this is the number of ns spent
4703 * waiting on all I/O to complete. This includes tape movement commands
4704 * such as rewinding, seeking to end of file or tape, it also includes
4705 * read and write. To determine the time spent on tape movement
4706 * subtract the read and write ns from this value.
4707 * @dev: struct device
4708 * @attr: attribute structure
4709 * @buf: buffer to return formatted data in
4710 */
4711static ssize_t io_ns_show(struct device *dev,
4712 struct device_attribute *attr, char *buf)
4713{
4714 struct st_modedef *STm = dev_get_drvdata(dev);
4715
4716 return sprintf(buf, "%lld",
4717 (long long)atomic64_read(&STm->tape->stats->tot_io_time));
4718}
4719static DEVICE_ATTR_RO(io_ns);
4720
4721/**
4722 * other_cnt_show - other io count - this is the number of
4723 * I/O requests other than read and write requests.
4724 * Typically these are tape movement requests but will include driver
4725 * tape movement. This includes only requests issued by the st driver.
4726 * @dev: struct device
4727 * @attr: attribute structure
4728 * @buf: buffer to return formatted data in
4729 */
4730static ssize_t other_cnt_show(struct device *dev,
4731 struct device_attribute *attr, char *buf)
4732{
4733 struct st_modedef *STm = dev_get_drvdata(dev);
4734
4735 return sprintf(buf, "%lld",
4736 (long long)atomic64_read(&STm->tape->stats->other_cnt));
4737}
4738static DEVICE_ATTR_RO(other_cnt);
4739
4740/**
4741 * resid_cnt_show - A count of the number of times we get a residual
4742 * count - this should indicate someone issuing reads larger than the
4743 * block size on tape.
4744 * @dev: struct device
4745 * @attr: attribute structure
4746 * @buf: buffer to return formatted data in
4747 */
4748static ssize_t resid_cnt_show(struct device *dev,
4749 struct device_attribute *attr, char *buf)
4750{
4751 struct st_modedef *STm = dev_get_drvdata(dev);
4752
4753 return sprintf(buf, "%lld",
4754 (long long)atomic64_read(&STm->tape->stats->resid_cnt));
4755}
4756static DEVICE_ATTR_RO(resid_cnt);
4757
c69c6be5
GKH		 4758static struct attribute *st_dev_attrs[] = {
4759 &dev_attr_defined.attr,
4760 &dev_attr_default_blksize.attr,
4761 &dev_attr_default_density.attr,
4762 &dev_attr_default_compression.attr,
4763 &dev_attr_options.attr,
4764 NULL,
af23782b 4765};
05545c92
SS		 4766
4767static struct attribute *st_stats_attrs[] = {
4768 &dev_attr_read_cnt.attr,
4769 &dev_attr_read_byte_cnt.attr,
4770 &dev_attr_read_ns.attr,
4771 &dev_attr_write_cnt.attr,
4772 &dev_attr_write_byte_cnt.attr,
4773 &dev_attr_write_ns.attr,
4774 &dev_attr_in_flight.attr,
4775 &dev_attr_io_ns.attr,
4776 &dev_attr_other_cnt.attr,
4777 &dev_attr_resid_cnt.attr,
4778 NULL,
4779};
4780
4781static struct attribute_group stats_group = {
4782 .name = "stats",
4783 .attrs = st_stats_attrs,
4784};
4785
4786static struct attribute_group st_group = {
4787 .attrs = st_dev_attrs,
4788};
4789
4790static const struct attribute_group *st_dev_groups[] = {
4791 &st_group,
4792 &stats_group,
4793 NULL,
4794};
b174be02 4795
1da177e4 4796/* The following functions may be useful for a larger audience. */
6620742f
FT		 4797static int sgl_map_user_pages(struct st_buffer *STbp,
4798 const unsigned int max_pages, unsigned long uaddr,
4799 size_t count, int rw)
1da177e4 4800{
07542b83
JB		 4801 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4802 unsigned long start = uaddr >> PAGE_SHIFT;
4803 const int nr_pages = end - start;
1da177e4 4804 int res, i, j;
1da177e4 4805 struct page **pages;
6620742f 4806 struct rq_map_data *mdata = &STbp->map_data;
1da177e4 4807
1da177e4
LT		 4808 /* User attempted Overflow! */
4809 if ((uaddr + count) < uaddr)
4810 return -EINVAL;
4811
4812 /* Too big */
4813 if (nr_pages > max_pages)
4814 return -ENOMEM;
4815
4816 /* Hmm? */
4817 if (count == 0)
4818 return 0;
4819
4820 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4821 return -ENOMEM;
4822
4823 /* Try to fault in all of the necessary pages */
1da177e4 4824 /* rw==READ means read from drive, write into memory area */
7e339128 4825 res = get_user_pages_unlocked(
1da177e4
LT		 4826 current,
4827 current->mm,
4828 uaddr,
4829 nr_pages,
4830 rw == READ,
4831 0, /* don't force */
7e339128 4832 pages);
1da177e4
LT		 4833
4834 /* Errors and no page mapped should return here */
4835 if (res < nr_pages)
4836 goto out_unmap;
4837
4838 for (i=0; i < nr_pages; i++) {
4839 /* FIXME: flush superflous for rw==READ,
4840 * probably wrong function for rw==WRITE
4841 */
4842 flush_dcache_page(pages[i]);
4843 }
4844
6620742f 4845 mdata->offset = uaddr & ~PAGE_MASK;
6620742f 4846 STbp->mapped_pages = pages;
1da177e4 4847
1da177e4 4848 return nr_pages;
1da177e4
LT		 4849 out_unmap:
4850 if (res > 0) {
4851 for (j=0; j < res; j++)
4852 page_cache_release(pages[j]);
6bc733e9 4853 res = 0;
1da177e4
LT		 4854 }
4855 kfree(pages);
4856 return res;
4857}
4858
4859
4860/* And unmap them... */
6620742f
FT		 4861static int sgl_unmap_user_pages(struct st_buffer *STbp,
4862 const unsigned int nr_pages, int dirtied)
1da177e4
LT		 4863{
4864 int i;
4865
4866 for (i=0; i < nr_pages; i++) {
6620742f 4867 struct page *page = STbp->mapped_pages[i];
b5810039 4868
b5810039
NP		 4869 if (dirtied)
4870 SetPageDirty(page);
1da177e4
LT		 4871 /* FIXME: cache flush missing for rw==READ
4872 * FIXME: call the correct reference counting function
4873 */
b5810039 4874 page_cache_release(page);
1da177e4 4875 }
6620742f
FT		 4876 kfree(STbp->mapped_pages);
4877 STbp->mapped_pages = NULL;
1da177e4
LT		 4878
4879 return 0;
4880}
Linux kernel - Deliverables
This page took 1.128397 seconds and 5 git commands to generate.