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