projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] seperate max_sectors from max_hw_sectors
[GitHub/mt8127/android_kernel_alcatel_ttab.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>
38#include <linux/devfs_fs_kernel.h>
39#include <linux/cdev.h>
40#include <linux/delay.h>
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 *);
196static int st_init_command(struct scsi_cmnd *);
197
198static void do_create_driverfs_files(void);
199static void do_remove_driverfs_files(void);
200static void do_create_class_files(struct scsi_tape *, int, int);
201
202static struct scsi_driver st_template = {
203 .owner = THIS_MODULE,
204 .gendrv = {
205 .name = "st",
206 .probe = st_probe,
207 .remove = st_remove,
208 },
209 .init_command = st_init_command,
210};
211
212static int st_compression(struct scsi_tape *, int);
213
214static int find_partition(struct scsi_tape *);
215static int switch_partition(struct scsi_tape *);
216
217static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
218
f03a5670
KM		 219static void scsi_tape_release(struct kref *);
220
221#define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
222
223static DECLARE_MUTEX(st_ref_sem);
224
1da177e4
LT		 225\f
226#include "osst_detect.h"
227#ifndef SIGS_FROM_OSST
228#define SIGS_FROM_OSST \
229 {"OnStream", "SC-", "", "osst"}, \
230 {"OnStream", "DI-", "", "osst"}, \
231 {"OnStream", "DP-", "", "osst"}, \
232 {"OnStream", "USB", "", "osst"}, \
233 {"OnStream", "FW-", "", "osst"}
234#endif
235
f03a5670
KM		 236static struct scsi_tape *scsi_tape_get(int dev)
237{
238 struct scsi_tape *STp = NULL;
239
240 down(&st_ref_sem);
241 write_lock(&st_dev_arr_lock);
242
243 if (dev < st_dev_max && scsi_tapes != NULL)
244 STp = scsi_tapes[dev];
245 if (!STp) goto out;
246
247 kref_get(&STp->kref);
248
249 if (!STp->device)
250 goto out_put;
251
252 if (scsi_device_get(STp->device))
253 goto out_put;
254
255 goto out;
256
257out_put:
258 kref_put(&STp->kref, scsi_tape_release);
259 STp = NULL;
260out:
261 write_unlock(&st_dev_arr_lock);
262 up(&st_ref_sem);
263 return STp;
264}
265
266static void scsi_tape_put(struct scsi_tape *STp)
267{
268 struct scsi_device *sdev = STp->device;
269
270 down(&st_ref_sem);
271 kref_put(&STp->kref, scsi_tape_release);
272 scsi_device_put(sdev);
273 up(&st_ref_sem);
274}
275
1da177e4
LT		 276struct st_reject_data {
277 char *vendor;
278 char *model;
279 char *rev;
280 char *driver_hint; /* Name of the correct driver, NULL if unknown */
281};
282
283static struct st_reject_data reject_list[] = {
284 /* {"XXX", "Yy-", "", NULL}, example */
285 SIGS_FROM_OSST,
286 {NULL, }};
287
288/* If the device signature is on the list of incompatible drives, the
289 function returns a pointer to the name of the correct driver (if known) */
290static char * st_incompatible(struct scsi_device* SDp)
291{
292 struct st_reject_data *rp;
293
294 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
295 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
296 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
297 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
298 if (rp->driver_hint)
299 return rp->driver_hint;
300 else
301 return "unknown";
302 }
303 return NULL;
304}
305\f
306
307static inline char *tape_name(struct scsi_tape *tape)
308{
309 return tape->disk->disk_name;
310}
311
312
8b05b773 313static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
1da177e4
LT		 314{
315 const u8 *ucp;
8b05b773 316 const u8 *sense = SRpnt->sense;
1da177e4 317
8b05b773
MC		 318 s->have_sense = scsi_normalize_sense(SRpnt->sense,
319 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
1da177e4
LT		 320 s->flags = 0;
321
322 if (s->have_sense) {
323 s->deferred = 0;
324 s->remainder_valid =
325 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
326 switch (sense[0] & 0x7f) {
327 case 0x71:
328 s->deferred = 1;
329 case 0x70:
330 s->fixed_format = 1;
331 s->flags = sense[2] & 0xe0;
332 break;
333 case 0x73:
334 s->deferred = 1;
335 case 0x72:
336 s->fixed_format = 0;
337 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
338 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
339 break;
340 }
341 }
342}
343
344
345/* Convert the result to success code */
8b05b773 346static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
1da177e4 347{
8b05b773 348 int result = SRpnt->result;
1da177e4
LT		 349 u8 scode;
350 DEB(const char *stp;)
351 char *name = tape_name(STp);
352 struct st_cmdstatus *cmdstatp;
353
354 if (!result)
355 return 0;
356
357 cmdstatp = &STp->buffer->cmdstat;
f03a5670 358 st_analyze_sense(SRpnt, cmdstatp);
1da177e4
LT		 359
360 if (cmdstatp->have_sense)
361 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
362 else
363 scode = 0;
364
365 DEB(
366 if (debugging) {
8b05b773 367 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
1da177e4 368 name, result,
8b05b773
MC		 369 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
370 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
1da177e4 371 if (cmdstatp->have_sense)
8b05b773 372 __scsi_print_sense("st", SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
1da177e4
LT		 373 } ) /* end DEB */
374 if (!debugging) { /* Abnormal conditions for tape */
375 if (!cmdstatp->have_sense)
376 printk(KERN_WARNING
377 "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
378 name, result, suggestion(result),
379 driver_byte(result) & DRIVER_MASK, host_byte(result));
380 else if (cmdstatp->have_sense &&
381 scode != NO_SENSE &&
382 scode != RECOVERED_ERROR &&
383 /* scode != UNIT_ATTENTION && */
384 scode != BLANK_CHECK &&
385 scode != VOLUME_OVERFLOW &&
8b05b773
MC		 386 SRpnt->cmd[0] != MODE_SENSE &&
387 SRpnt->cmd[0] != TEST_UNIT_READY) {
1da177e4 388 printk(KERN_WARNING "%s: Error with sense data: ", name);
8b05b773
MC		 389 __scsi_print_sense("st", SRpnt->sense,
390 SCSI_SENSE_BUFFERSIZE);
1da177e4
LT		 391 }
392 }
393
394 if (cmdstatp->fixed_format &&
395 STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */
396 if (STp->cln_sense_value)
8b05b773 397 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
1da177e4
LT		 398 STp->cln_sense_mask) == STp->cln_sense_value);
399 else
8b05b773 400 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
1da177e4
LT		 401 STp->cln_sense_mask) != 0);
402 }
403 if (cmdstatp->have_sense &&
404 cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
405 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
406
407 STp->pos_unknown |= STp->device->was_reset;
408
409 if (cmdstatp->have_sense &&
410 scode == RECOVERED_ERROR
411#if ST_RECOVERED_WRITE_FATAL
8b05b773
MC		 412 && SRpnt->cmd[0] != WRITE_6
413 && SRpnt->cmd[0] != WRITE_FILEMARKS
1da177e4
LT		 414#endif
415 ) {
416 STp->recover_count++;
417 STp->recover_reg++;
418
419 DEB(
420 if (debugging) {
8b05b773 421 if (SRpnt->cmd[0] == READ_6)
1da177e4 422 stp = "read";
8b05b773 423 else if (SRpnt->cmd[0] == WRITE_6)
1da177e4
LT		 424 stp = "write";
425 else
426 stp = "ioctl";
427 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
428 STp->recover_count);
429 } ) /* end DEB */
430
431 if (cmdstatp->flags == 0)
432 return 0;
433 }
434 return (-EIO);
435}
436
437
438/* Wakeup from interrupt */
8b05b773 439static void st_sleep_done(void *data, char *sense, int result, int resid)
1da177e4 440{
8b05b773
MC		 441 struct st_request *SRpnt = data;
442 struct scsi_tape *STp = SRpnt->stp;
1da177e4 443
8b05b773
MC		 444 memcpy(SRpnt->sense, sense, SCSI_SENSE_BUFFERSIZE);
445 (STp->buffer)->cmdstat.midlevel_result = SRpnt->result = result;
1da177e4
LT		 446 DEB( STp->write_pending = 0; )
447
8b05b773
MC		 448 if (SRpnt->waiting)
449 complete(SRpnt->waiting);
450}
451
452static struct st_request *st_allocate_request(void)
453{
454 return kzalloc(sizeof(struct st_request), GFP_KERNEL);
455}
456
457static void st_release_request(struct st_request *streq)
458{
459 kfree(streq);
1da177e4
LT		 460}
461
462/* Do the scsi command. Waits until command performed if do_wait is true.
463 Otherwise write_behind_check() is used to check that the command
464 has finished. */
8b05b773
MC		 465static struct st_request *
466st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
1da177e4
LT		 467 int bytes, int direction, int timeout, int retries, int do_wait)
468{
f03a5670 469 struct completion *waiting;
1da177e4 470
f03a5670
KM		 471 /* if async, make sure there's no command outstanding */
472 if (!do_wait && ((STp->buffer)->last_SRpnt)) {
473 printk(KERN_ERR "%s: Async command already active.\n",
474 tape_name(STp));
475 if (signal_pending(current))
476 (STp->buffer)->syscall_result = (-EINTR);
477 else
478 (STp->buffer)->syscall_result = (-EBUSY);
479 return NULL;
480 }
481
1da177e4 482 if (SRpnt == NULL) {
8b05b773 483 SRpnt = st_allocate_request();
1da177e4
LT		 484 if (SRpnt == NULL) {
485 DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n",
486 tape_name(STp)); );
487 if (signal_pending(current))
488 (STp->buffer)->syscall_result = (-EINTR);
489 else
490 (STp->buffer)->syscall_result = (-EBUSY);
491 return NULL;
492 }
8b05b773 493 SRpnt->stp = STp;
1da177e4
LT		 494 }
495
f03a5670
KM		 496 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
497 which IO is outstanding. It's nulled out when the IO completes. */
498 if (!do_wait)
499 (STp->buffer)->last_SRpnt = SRpnt;
500
501 waiting = &STp->wait;
502 init_completion(waiting);
8b05b773 503 SRpnt->waiting = waiting;
1da177e4 504
8b05b773
MC		 505 if (!STp->buffer->do_dio)
506 buf_to_sg(STp->buffer, bytes);
1da177e4 507
8b05b773
MC		 508 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
509 STp->buffer->cmdstat.have_sense = 0;
510 STp->buffer->syscall_result = 0;
511
512 if (scsi_execute_async(STp->device, cmd, direction,
513 &((STp->buffer)->sg[0]), bytes, (STp->buffer)->sg_segs,
514 timeout, retries, SRpnt, st_sleep_done, GFP_KERNEL))
515 /* could not allocate the buffer or request was too large */
516 (STp->buffer)->syscall_result = (-EBUSY);
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() */
1452static void release_buffering(struct scsi_tape *STp)
1453{
1454 struct st_buffer *STbp;
1455
1456 STbp = STp->buffer;
1457 if (STbp->do_dio) {
1458 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, 0);
1459 STbp->do_dio = 0;
1460 }
1461}
1462
1463
1464/* Write command */
1465static ssize_t
1466st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1467{
1468 ssize_t total;
1469 ssize_t i, do_count, blks, transfer;
1470 ssize_t retval;
1471 int undone, retry_eot = 0, scode;
1472 int async_write;
1473 unsigned char cmd[MAX_COMMAND_SIZE];
1474 const char __user *b_point;
8b05b773 1475 struct st_request *SRpnt = NULL;
1da177e4
LT		 1476 struct scsi_tape *STp = filp->private_data;
1477 struct st_modedef *STm;
1478 struct st_partstat *STps;
1479 struct st_buffer *STbp;
1480 char *name = tape_name(STp);
1481
1482 if (down_interruptible(&STp->lock))
1483 return -ERESTARTSYS;
1484
1485 retval = rw_checks(STp, filp, count);
1486 if (retval || count == 0)
1487 goto out;
1488
1489 /* Write must be integral number of blocks */
1490 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1491 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1492 name);
1493 retval = (-EINVAL);
1494 goto out;
1495 }
1496
1497 STm = &(STp->modes[STp->current_mode]);
1498 STps = &(STp->ps[STp->partition]);
1499
1500 if (STp->write_prot) {
1501 retval = (-EACCES);
1502 goto out;
1503 }
1504
1505
1506 if (STps->rw == ST_READING) {
1507 retval = flush_buffer(STp, 0);
1508 if (retval)
1509 goto out;
1510 STps->rw = ST_WRITING;
1511 } else if (STps->rw != ST_WRITING &&
1512 STps->drv_file == 0 && STps->drv_block == 0) {
1513 if ((retval = set_mode_densblk(STp, STm)) < 0)
1514 goto out;
1515 if (STm->default_compression != ST_DONT_TOUCH &&
1516 !(STp->compression_changed)) {
1517 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1518 printk(KERN_WARNING "%s: Can't set default compression.\n",
1519 name);
1520 if (modes_defined) {
1521 retval = (-EINVAL);
1522 goto out;
1523 }
1524 }
1525 }
1526 }
1527
1528 STbp = STp->buffer;
1529 i = write_behind_check(STp);
1530 if (i) {
1531 if (i == -ENOSPC)
1532 STps->eof = ST_EOM_OK;
1533 else
1534 STps->eof = ST_EOM_ERROR;
1535 }
1536
1537 if (STps->eof == ST_EOM_OK) {
1538 STps->eof = ST_EOD_1; /* allow next write */
1539 retval = (-ENOSPC);
1540 goto out;
1541 }
1542 else if (STps->eof == ST_EOM_ERROR) {
1543 retval = (-EIO);
1544 goto out;
1545 }
1546
1547 /* Check the buffer readability in cases where copy_user might catch
1548 the problems after some tape movement. */
1549 if (STp->block_size != 0 &&
1550 !STbp->do_dio &&
1551 (copy_from_user(&i, buf, 1) != 0 ||
1552 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1553 retval = (-EFAULT);
1554 goto out;
1555 }
1556
1557 retval = setup_buffering(STp, buf, count, 0);
1558 if (retval)
1559 goto out;
1560
1561 total = count;
1562
1563 memset(cmd, 0, MAX_COMMAND_SIZE);
1564 cmd[0] = WRITE_6;
1565 cmd[1] = (STp->block_size != 0);
1566
1567 STps->rw = ST_WRITING;
1568
1569 b_point = buf;
1570 while (count > 0 && !retry_eot) {
1571
1572 if (STbp->do_dio) {
1573 do_count = count;
1574 }
1575 else {
1576 if (STp->block_size == 0)
1577 do_count = count;
1578 else {
1579 do_count = STbp->buffer_blocks * STp->block_size -
1580 STbp->buffer_bytes;
1581 if (do_count > count)
1582 do_count = count;
1583 }
1584
1585 i = append_to_buffer(b_point, STbp, do_count);
1586 if (i) {
1587 retval = i;
1588 goto out;
1589 }
1590 }
1591 count -= do_count;
1592 b_point += do_count;
1593
1594 async_write = STp->block_size == 0 && !STbp->do_dio &&
1595 STm->do_async_writes && STps->eof < ST_EOM_OK;
1596
1597 if (STp->block_size != 0 && STm->do_buffer_writes &&
1598 !(STp->try_dio && try_wdio) && STps->eof < ST_EOM_OK &&
1599 STbp->buffer_bytes < STbp->buffer_size) {
1600 STp->dirty = 1;
1601 /* Don't write a buffer that is not full enough. */
1602 if (!async_write && count == 0)
1603 break;
1604 }
1605
1606 retry_write:
1607 if (STp->block_size == 0)
1608 blks = transfer = do_count;
1609 else {
1610 if (!STbp->do_dio)
1611 blks = STbp->buffer_bytes;
1612 else
1613 blks = do_count;
1614 blks /= STp->block_size;
1615 transfer = blks * STp->block_size;
1616 }
1617 cmd[2] = blks >> 16;
1618 cmd[3] = blks >> 8;
1619 cmd[4] = blks;
1620
1621 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1622 STp->device->timeout, MAX_WRITE_RETRIES, !async_write);
1623 if (!SRpnt) {
1624 retval = STbp->syscall_result;
1625 goto out;
1626 }
8b05b773 1627 if (async_write && !STbp->syscall_result) {
1da177e4
LT		 1628 STbp->writing = transfer;
1629 STp->dirty = !(STbp->writing ==
1630 STbp->buffer_bytes);
1631 SRpnt = NULL; /* Prevent releasing this request! */
1632 DEB( STp->write_pending = 1; )
1633 break;
1634 }
1635
1636 if (STbp->syscall_result != 0) {
1637 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1638
1639 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1640 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1641 scode = cmdstatp->sense_hdr.sense_key;
1642 if (cmdstatp->remainder_valid)
1643 undone = (int)cmdstatp->uremainder64;
1644 else if (STp->block_size == 0 &&
1645 scode == VOLUME_OVERFLOW)
1646 undone = transfer;
1647 else
1648 undone = 0;
1649 if (STp->block_size != 0)
1650 undone *= STp->block_size;
1651 if (undone <= do_count) {
1652 /* Only data from this write is not written */
1653 count += undone;
1654 do_count -= undone;
1655 if (STp->block_size)
1656 blks = (transfer - undone) / STp->block_size;
1657 STps->eof = ST_EOM_OK;
1658 /* Continue in fixed block mode if all written
1659 in this request but still something left to write
1660 (retval left to zero)
1661 */
1662 if (STp->block_size == 0 ||
1663 undone > 0 || count == 0)
1664 retval = (-ENOSPC); /* EOM within current request */
1665 DEBC(printk(ST_DEB_MSG
1666 "%s: EOM with %d bytes unwritten.\n",
1667 name, (int)count));
1668 } else {
1669 /* EOT within data buffered earlier (possible only
1670 in fixed block mode without direct i/o) */
1671 if (!retry_eot && !cmdstatp->deferred &&
1672 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1673 move_buffer_data(STp->buffer, transfer - undone);
1674 retry_eot = 1;
1675 if (STps->drv_block >= 0) {
1676 STps->drv_block += (transfer - undone) /
1677 STp->block_size;
1678 }
1679 STps->eof = ST_EOM_OK;
1680 DEBC(printk(ST_DEB_MSG
1681 "%s: Retry write of %d bytes at EOM.\n",
1682 name, STp->buffer->buffer_bytes));
1683 goto retry_write;
1684 }
1685 else {
1686 /* Either error within data buffered by driver or
1687 failed retry */
1688 count -= do_count;
1689 blks = do_count = 0;
1690 STps->eof = ST_EOM_ERROR;
1691 STps->drv_block = (-1); /* Too cautious? */
1692 retval = (-EIO); /* EOM for old data */
1693 DEBC(printk(ST_DEB_MSG
1694 "%s: EOM with lost data.\n",
1695 name));
1696 }
1697 }
1698 } else {
1699 count += do_count;
1700 STps->drv_block = (-1); /* Too cautious? */
8b05b773 1701 retval = STbp->syscall_result;
1da177e4
LT		 1702 }
1703
1704 }
1705
1706 if (STps->drv_block >= 0) {
1707 if (STp->block_size == 0)
1708 STps->drv_block += (do_count > 0);
1709 else
1710 STps->drv_block += blks;
1711 }
1712
1713 STbp->buffer_bytes = 0;
1714 STp->dirty = 0;
1715
1716 if (retval || retry_eot) {
1717 if (count < total)
1718 retval = total - count;
1719 goto out;
1720 }
1721 }
1722
1723 if (STps->eof == ST_EOD_1)
1724 STps->eof = ST_EOM_OK;
1725 else if (STps->eof != ST_EOM_OK)
1726 STps->eof = ST_NOEOF;
1727 retval = total - count;
1728
1729 out:
1730 if (SRpnt != NULL)
8b05b773 1731 st_release_request(SRpnt);
1da177e4
LT		 1732 release_buffering(STp);
1733 up(&STp->lock);
1734
1735 return retval;
1736}
1737\f
1738/* Read data from the tape. Returns zero in the normal case, one if the
1739 eof status has changed, and the negative error code in case of a
1740 fatal error. Otherwise updates the buffer and the eof state.
1741
1742 Does release user buffer mapping if it is set.
1743*/
1744static long read_tape(struct scsi_tape *STp, long count,
8b05b773 1745 struct st_request ** aSRpnt)
1da177e4
LT		 1746{
1747 int transfer, blks, bytes;
1748 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 1749 struct st_request *SRpnt;
1da177e4
LT		 1750 struct st_modedef *STm;
1751 struct st_partstat *STps;
1752 struct st_buffer *STbp;
1753 int retval = 0;
1754 char *name = tape_name(STp);
1755
1756 if (count == 0)
1757 return 0;
1758
1759 STm = &(STp->modes[STp->current_mode]);
1760 STps = &(STp->ps[STp->partition]);
1761 if (STps->eof == ST_FM_HIT)
1762 return 1;
1763 STbp = STp->buffer;
1764
1765 if (STp->block_size == 0)
1766 blks = bytes = count;
1767 else {
1768 if (!(STp->try_dio && try_rdio) && STm->do_read_ahead) {
1769 blks = (STp->buffer)->buffer_blocks;
1770 bytes = blks * STp->block_size;
1771 } else {
1772 bytes = count;
1773 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1774 bytes = (STp->buffer)->buffer_size;
1775 blks = bytes / STp->block_size;
1776 bytes = blks * STp->block_size;
1777 }
1778 }
1779
1780 memset(cmd, 0, MAX_COMMAND_SIZE);
1781 cmd[0] = READ_6;
1782 cmd[1] = (STp->block_size != 0);
1783 cmd[2] = blks >> 16;
1784 cmd[3] = blks >> 8;
1785 cmd[4] = blks;
1786
1787 SRpnt = *aSRpnt;
1788 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1789 STp->device->timeout, MAX_RETRIES, 1);
1790 release_buffering(STp);
1791 *aSRpnt = SRpnt;
1792 if (!SRpnt)
1793 return STbp->syscall_result;
1794
1795 STbp->read_pointer = 0;
1796 STps->at_sm = 0;
1797
1798 /* Something to check */
1799 if (STbp->syscall_result) {
1800 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1801
1802 retval = 1;
1803 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1804 name,
8b05b773
MC		 1805 SRpnt->sense[0], SRpnt->sense[1],
1806 SRpnt->sense[2], SRpnt->sense[3],
1807 SRpnt->sense[4], SRpnt->sense[5],
1808 SRpnt->sense[6], SRpnt->sense[7]));
1da177e4
LT		 1809 if (cmdstatp->have_sense) {
1810
1811 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1812 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1813
1814 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1815 /* Compute the residual count */
1816 if (cmdstatp->remainder_valid)
1817 transfer = (int)cmdstatp->uremainder64;
1818 else
1819 transfer = 0;
1820 if (STp->block_size == 0 &&
1821 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1822 transfer = bytes;
1823
1824 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
1825 if (STp->block_size == 0) {
1826 if (transfer <= 0) {
1827 if (transfer < 0)
1828 printk(KERN_NOTICE
1829 "%s: Failed to read %d byte block with %d byte transfer.\n",
1830 name, bytes - transfer, bytes);
1831 if (STps->drv_block >= 0)
1832 STps->drv_block += 1;
1833 STbp->buffer_bytes = 0;
1834 return (-ENOMEM);
1835 }
1836 STbp->buffer_bytes = bytes - transfer;
1837 } else {
8b05b773 1838 st_release_request(SRpnt);
1da177e4
LT		 1839 SRpnt = *aSRpnt = NULL;
1840 if (transfer == blks) { /* We did not get anything, error */
1841 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1842 if (STps->drv_block >= 0)
1843 STps->drv_block += blks - transfer + 1;
1844 st_int_ioctl(STp, MTBSR, 1);
1845 return (-EIO);
1846 }
1847 /* We have some data, deliver it */
1848 STbp->buffer_bytes = (blks - transfer) *
1849 STp->block_size;
1850 DEBC(printk(ST_DEB_MSG
1851 "%s: ILI but enough data received %ld %d.\n",
1852 name, count, STbp->buffer_bytes));
1853 if (STps->drv_block >= 0)
1854 STps->drv_block += 1;
1855 if (st_int_ioctl(STp, MTBSR, 1))
1856 return (-EIO);
1857 }
1858 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
1859 if (STps->eof != ST_FM_HIT)
1860 STps->eof = ST_FM_HIT;
1861 else
1862 STps->eof = ST_EOD_2;
1863 if (STp->block_size == 0)
1864 STbp->buffer_bytes = 0;
1865 else
1866 STbp->buffer_bytes =
1867 bytes - transfer * STp->block_size;
1868 DEBC(printk(ST_DEB_MSG
1869 "%s: EOF detected (%d bytes read).\n",
1870 name, STbp->buffer_bytes));
1871 } else if (cmdstatp->flags & SENSE_EOM) {
1872 if (STps->eof == ST_FM)
1873 STps->eof = ST_EOD_1;
1874 else
1875 STps->eof = ST_EOM_OK;
1876 if (STp->block_size == 0)
1877 STbp->buffer_bytes = bytes - transfer;
1878 else
1879 STbp->buffer_bytes =
1880 bytes - transfer * STp->block_size;
1881
1882 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1883 name, STbp->buffer_bytes));
1884 }
1885 }
1886 /* end of EOF, EOM, ILI test */
1887 else { /* nonzero sense key */
1888 DEBC(printk(ST_DEB_MSG
1889 "%s: Tape error while reading.\n", name));
1890 STps->drv_block = (-1);
1891 if (STps->eof == ST_FM &&
1892 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1893 DEBC(printk(ST_DEB_MSG
1894 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1895 name));
1896 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1897 } else /* Some other extended sense code */
1898 retval = (-EIO);
1899 }
1900
1901 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
1902 STbp->buffer_bytes = 0;
1903 }
1904 /* End of extended sense test */
1905 else { /* Non-extended sense */
1906 retval = STbp->syscall_result;
1907 }
1908
1909 }
1910 /* End of error handling */
1911 else /* Read successful */
1912 STbp->buffer_bytes = bytes;
1913
1914 if (STps->drv_block >= 0) {
1915 if (STp->block_size == 0)
1916 STps->drv_block++;
1917 else
1918 STps->drv_block += STbp->buffer_bytes / STp->block_size;
1919 }
1920 return retval;
1921}
1922\f
1923
1924/* Read command */
1925static ssize_t
1926st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
1927{
1928 ssize_t total;
1929 ssize_t retval = 0;
1930 ssize_t i, transfer;
1931 int special, do_dio = 0;
8b05b773 1932 struct st_request *SRpnt = NULL;
1da177e4
LT		 1933 struct scsi_tape *STp = filp->private_data;
1934 struct st_modedef *STm;
1935 struct st_partstat *STps;
1936 struct st_buffer *STbp = STp->buffer;
1937 DEB( char *name = tape_name(STp); )
1938
1939 if (down_interruptible(&STp->lock))
1940 return -ERESTARTSYS;
1941
1942 retval = rw_checks(STp, filp, count);
1943 if (retval || count == 0)
1944 goto out;
1945
1946 STm = &(STp->modes[STp->current_mode]);
1947 if (!(STm->do_read_ahead) && STp->block_size != 0 &&
1948 (count % STp->block_size) != 0) {
1949 retval = (-EINVAL); /* Read must be integral number of blocks */
1950 goto out;
1951 }
1952
1953 STps = &(STp->ps[STp->partition]);
1954 if (STps->rw == ST_WRITING) {
1955 retval = flush_buffer(STp, 0);
1956 if (retval)
1957 goto out;
1958 STps->rw = ST_READING;
1959 }
1960 DEB(
1961 if (debugging && STps->eof != ST_NOEOF)
1962 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
1963 STps->eof, STbp->buffer_bytes);
1964 ) /* end DEB */
1965
1966 retval = setup_buffering(STp, buf, count, 1);
1967 if (retval)
1968 goto out;
1969 do_dio = STbp->do_dio;
1970
1971 if (STbp->buffer_bytes == 0 &&
1972 STps->eof >= ST_EOD_1) {
1973 if (STps->eof < ST_EOD) {
1974 STps->eof += 1;
1975 retval = 0;
1976 goto out;
1977 }
1978 retval = (-EIO); /* EOM or Blank Check */
1979 goto out;
1980 }
1981
1982 if (do_dio) {
1983 /* Check the buffer writability before any tape movement. Don't alter
1984 buffer data. */
1985 if (copy_from_user(&i, buf, 1) != 0 ||
1986 copy_to_user(buf, &i, 1) != 0 ||
1987 copy_from_user(&i, buf + count - 1, 1) != 0 ||
1988 copy_to_user(buf + count - 1, &i, 1) != 0) {
1989 retval = (-EFAULT);
1990 goto out;
1991 }
1992 }
1993
1994 STps->rw = ST_READING;
1995
1996
1997 /* Loop until enough data in buffer or a special condition found */
1998 for (total = 0, special = 0; total < count && !special;) {
1999
2000 /* Get new data if the buffer is empty */
2001 if (STbp->buffer_bytes == 0) {
2002 special = read_tape(STp, count - total, &SRpnt);
2003 if (special < 0) { /* No need to continue read */
2004 retval = special;
2005 goto out;
2006 }
2007 }
2008
2009 /* Move the data from driver buffer to user buffer */
2010 if (STbp->buffer_bytes > 0) {
2011 DEB(
2012 if (debugging && STps->eof != ST_NOEOF)
2013 printk(ST_DEB_MSG
2014 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2015 STps->eof, STbp->buffer_bytes,
2016 (int)(count - total));
2017 ) /* end DEB */
2018 transfer = STbp->buffer_bytes < count - total ?
2019 STbp->buffer_bytes : count - total;
2020 if (!do_dio) {
2021 i = from_buffer(STbp, buf, transfer);
2022 if (i) {
2023 retval = i;
2024 goto out;
2025 }
2026 }
2027 buf += transfer;
2028 total += transfer;
2029 }
2030
2031 if (STp->block_size == 0)
2032 break; /* Read only one variable length block */
2033
2034 } /* for (total = 0, special = 0;
2035 total < count && !special; ) */
2036
2037 /* Change the eof state if no data from tape or buffer */
2038 if (total == 0) {
2039 if (STps->eof == ST_FM_HIT) {
2040 STps->eof = ST_FM;
2041 STps->drv_block = 0;
2042 if (STps->drv_file >= 0)
2043 STps->drv_file++;
2044 } else if (STps->eof == ST_EOD_1) {
2045 STps->eof = ST_EOD_2;
2046 STps->drv_block = 0;
2047 if (STps->drv_file >= 0)
2048 STps->drv_file++;
2049 } else if (STps->eof == ST_EOD_2)
2050 STps->eof = ST_EOD;
2051 } else if (STps->eof == ST_FM)
2052 STps->eof = ST_NOEOF;
2053 retval = total;
2054
2055 out:
2056 if (SRpnt != NULL) {
8b05b773 2057 st_release_request(SRpnt);
1da177e4
LT		 2058 SRpnt = NULL;
2059 }
2060 if (do_dio) {
2061 release_buffering(STp);
2062 STbp->buffer_bytes = 0;
2063 }
2064 up(&STp->lock);
2065
2066 return retval;
2067}
2068\f
2069
2070
2071DEB(
2072/* Set the driver options */
2073static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2074{
2075 if (debugging) {
2076 printk(KERN_INFO
2077 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2078 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2079 STm->do_read_ahead);
2080 printk(KERN_INFO
2081 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2082 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2083 printk(KERN_INFO
2084 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2085 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2086 STp->scsi2_logical);
2087 printk(KERN_INFO
2088 "%s: sysv: %d nowait: %d\n", name, STm->sysv, STp->immediate);
2089 printk(KERN_INFO "%s: debugging: %d\n",
2090 name, debugging);
2091 }
2092}
2093 )
2094
2095
2096static int st_set_options(struct scsi_tape *STp, long options)
2097{
2098 int value;
2099 long code;
2100 struct st_modedef *STm;
2101 char *name = tape_name(STp);
2102 struct cdev *cd0, *cd1;
2103
2104 STm = &(STp->modes[STp->current_mode]);
2105 if (!STm->defined) {
2106 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2107 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2108 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2109 modes_defined = 1;
2110 DEBC(printk(ST_DEB_MSG
2111 "%s: Initialized mode %d definition from mode 0\n",
2112 name, STp->current_mode));
2113 }
2114
2115 code = options & MT_ST_OPTIONS;
2116 if (code == MT_ST_BOOLEANS) {
2117 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2118 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2119 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2120 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2121 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2122 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2123 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2124 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2125 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2126 if ((STp->device)->scsi_level >= SCSI_2)
2127 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2128 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2129 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2130 STm->sysv = (options & MT_ST_SYSV) != 0;
2131 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2132 st_log_options(STp, STm, name); )
2133 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2134 value = (code == MT_ST_SETBOOLEANS);
2135 if ((options & MT_ST_BUFFER_WRITES) != 0)
2136 STm->do_buffer_writes = value;
2137 if ((options & MT_ST_ASYNC_WRITES) != 0)
2138 STm->do_async_writes = value;
2139 if ((options & MT_ST_DEF_WRITES) != 0)
2140 STm->defaults_for_writes = value;
2141 if ((options & MT_ST_READ_AHEAD) != 0)
2142 STm->do_read_ahead = value;
2143 if ((options & MT_ST_TWO_FM) != 0)
2144 STp->two_fm = value;
2145 if ((options & MT_ST_FAST_MTEOM) != 0)
2146 STp->fast_mteom = value;
2147 if ((options & MT_ST_AUTO_LOCK) != 0)
2148 STp->do_auto_lock = value;
2149 if ((options & MT_ST_CAN_BSR) != 0)
2150 STp->can_bsr = value;
2151 if ((options & MT_ST_NO_BLKLIMS) != 0)
2152 STp->omit_blklims = value;
2153 if ((STp->device)->scsi_level >= SCSI_2 &&
2154 (options & MT_ST_CAN_PARTITIONS) != 0)
2155 STp->can_partitions = value;
2156 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2157 STp->scsi2_logical = value;
2158 if ((options & MT_ST_NOWAIT) != 0)
2159 STp->immediate = value;
2160 if ((options & MT_ST_SYSV) != 0)
2161 STm->sysv = value;
2162 DEB(
2163 if ((options & MT_ST_DEBUGGING) != 0)
2164 debugging = value;
2165 st_log_options(STp, STm, name); )
2166 } else if (code == MT_ST_WRITE_THRESHOLD) {
2167 /* Retained for compatibility */
2168 } else if (code == MT_ST_DEF_BLKSIZE) {
2169 value = (options & ~MT_ST_OPTIONS);
2170 if (value == ~MT_ST_OPTIONS) {
2171 STm->default_blksize = (-1);
2172 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2173 } else {
2174 STm->default_blksize = value;
2175 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2176 name, STm->default_blksize));
2177 if (STp->ready == ST_READY) {
2178 STp->blksize_changed = 0;
2179 set_mode_densblk(STp, STm);
2180 }
2181 }
2182 } else if (code == MT_ST_TIMEOUTS) {
2183 value = (options & ~MT_ST_OPTIONS);
2184 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2185 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2186 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2187 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2188 } else {
2189 STp->device->timeout = value * HZ;
2190 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2191 name, value) );
2192 }
2193 } else if (code == MT_ST_SET_CLN) {
2194 value = (options & ~MT_ST_OPTIONS) & 0xff;
2195 if (value != 0 &&
2196 value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2197 return (-EINVAL);
2198 STp->cln_mode = value;
2199 STp->cln_sense_mask = (options >> 8) & 0xff;
2200 STp->cln_sense_value = (options >> 16) & 0xff;
2201 printk(KERN_INFO
2202 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2203 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2204 } else if (code == MT_ST_DEF_OPTIONS) {
2205 code = (options & ~MT_ST_CLEAR_DEFAULT);
2206 value = (options & MT_ST_CLEAR_DEFAULT);
2207 if (code == MT_ST_DEF_DENSITY) {
2208 if (value == MT_ST_CLEAR_DEFAULT) {
2209 STm->default_density = (-1);
2210 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2211 name));
2212 } else {
2213 STm->default_density = value & 0xff;
2214 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2215 name, STm->default_density));
2216 if (STp->ready == ST_READY) {
2217 STp->density_changed = 0;
2218 set_mode_densblk(STp, STm);
2219 }
2220 }
2221 } else if (code == MT_ST_DEF_DRVBUFFER) {
2222 if (value == MT_ST_CLEAR_DEFAULT) {
2223 STp->default_drvbuffer = 0xff;
2224 DEBC( printk(KERN_INFO
2225 "%s: Drive buffer default disabled.\n", name));
2226 } else {
2227 STp->default_drvbuffer = value & 7;
2228 DEBC( printk(KERN_INFO
2229 "%s: Drive buffer default set to %x\n",
2230 name, STp->default_drvbuffer));
2231 if (STp->ready == ST_READY)
2232 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2233 }
2234 } else if (code == MT_ST_DEF_COMPRESSION) {
2235 if (value == MT_ST_CLEAR_DEFAULT) {
2236 STm->default_compression = ST_DONT_TOUCH;
2237 DEBC( printk(KERN_INFO
2238 "%s: Compression default disabled.\n", name));
2239 } else {
2240 if ((value & 0xff00) != 0) {
2241 STp->c_algo = (value & 0xff00) >> 8;
2242 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2243 name, STp->c_algo));
2244 }
2245 if ((value & 0xff) != 0xff) {
2246 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2247 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2248 name, (value & 1)));
2249 if (STp->ready == ST_READY) {
2250 STp->compression_changed = 0;
2251 st_compression(STp, (STm->default_compression == ST_YES));
2252 }
2253 }
2254 }
2255 }
2256 } else
2257 return (-EIO);
2258
2259 return 0;
2260}
2261\f
2262#define MODE_HEADER_LENGTH 4
2263
2264/* Mode header and page byte offsets */
2265#define MH_OFF_DATA_LENGTH 0
2266#define MH_OFF_MEDIUM_TYPE 1
2267#define MH_OFF_DEV_SPECIFIC 2
2268#define MH_OFF_BDESCS_LENGTH 3
2269#define MP_OFF_PAGE_NBR 0
2270#define MP_OFF_PAGE_LENGTH 1
2271
2272/* Mode header and page bit masks */
2273#define MH_BIT_WP 0x80
2274#define MP_MSK_PAGE_NBR 0x3f
2275
2276/* Don't return block descriptors */
2277#define MODE_SENSE_OMIT_BDESCS 0x08
2278
2279#define MODE_SELECT_PAGE_FORMAT 0x10
2280
2281/* Read a mode page into the tape buffer. The block descriptors are included
2282 if incl_block_descs is true. The page control is ored to the page number
2283 parameter, if necessary. */
2284static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2285{
2286 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 2287 struct st_request *SRpnt = NULL;
1da177e4
LT		 2288
2289 memset(cmd, 0, MAX_COMMAND_SIZE);
2290 cmd[0] = MODE_SENSE;
2291 if (omit_block_descs)
2292 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2293 cmd[2] = page;
2294 cmd[4] = 255;
2295
2296 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2297 STp->device->timeout, 0, 1);
2298 if (SRpnt == NULL)
2299 return (STp->buffer)->syscall_result;
2300
8b05b773 2301 st_release_request(SRpnt);
1da177e4
LT		 2302
2303 return (STp->buffer)->syscall_result;
2304}
2305
2306
2307/* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2308 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2309static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2310{
2311 int pgo;
2312 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 2313 struct st_request *SRpnt = NULL;
1da177e4
LT		 2314
2315 memset(cmd, 0, MAX_COMMAND_SIZE);
2316 cmd[0] = MODE_SELECT;
2317 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2318 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2319 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2320
2321 /* Clear reserved fields */
2322 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2323 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2324 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2325 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2326
2327 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE,
2328 (slow ? STp->long_timeout : STp->device->timeout), 0, 1);
2329 if (SRpnt == NULL)
2330 return (STp->buffer)->syscall_result;
2331
8b05b773 2332 st_release_request(SRpnt);
1da177e4
LT		 2333
2334 return (STp->buffer)->syscall_result;
2335}
2336
2337
2338#define COMPRESSION_PAGE 0x0f
2339#define COMPRESSION_PAGE_LENGTH 16
2340
2341#define CP_OFF_DCE_DCC 2
2342#define CP_OFF_C_ALGO 7
2343
2344#define DCE_MASK 0x80
2345#define DCC_MASK 0x40
2346#define RED_MASK 0x60
2347
2348
2349/* Control the compression with mode page 15. Algorithm not changed if zero.
2350
2351 The block descriptors are read and written because Sony SDT-7000 does not
2352 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2353 Including block descriptors should not cause any harm to other drives. */
2354
2355static int st_compression(struct scsi_tape * STp, int state)
2356{
2357 int retval;
2358 int mpoffs; /* Offset to mode page start */
2359 unsigned char *b_data = (STp->buffer)->b_data;
2360 DEB( char *name = tape_name(STp); )
2361
2362 if (STp->ready != ST_READY)
2363 return (-EIO);
2364
2365 /* Read the current page contents */
2366 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2367 if (retval) {
2368 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2369 name));
2370 return (-EIO);
2371 }
2372
2373 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2374 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2375 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2376
2377 /* Check if compression can be changed */
2378 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2379 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2380 return (-EIO);
2381 }
2382
2383 /* Do the change */
2384 if (state) {
2385 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2386 if (STp->c_algo != 0)
2387 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2388 }
2389 else {
2390 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2391 if (STp->c_algo != 0)
2392 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2393 }
2394
2395 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2396 if (retval) {
2397 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2398 return (-EIO);
2399 }
2400 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2401 name, state));
2402
2403 STp->compression_changed = 1;
2404 return 0;
2405}
2406
2407
2408/* Process the load and unload commands (does unload if the load code is zero) */
2409static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2410{
2411 int retval = (-EIO), timeout;
2412 DEB( char *name = tape_name(STp); )
2413 unsigned char cmd[MAX_COMMAND_SIZE];
2414 struct st_partstat *STps;
8b05b773 2415 struct st_request *SRpnt;
1da177e4
LT		 2416
2417 if (STp->ready != ST_READY && !load_code) {
2418 if (STp->ready == ST_NO_TAPE)
2419 return (-ENOMEDIUM);
2420 else
2421 return (-EIO);
2422 }
2423
2424 memset(cmd, 0, MAX_COMMAND_SIZE);
2425 cmd[0] = START_STOP;
2426 if (load_code)
2427 cmd[4] |= 1;
2428 /*
2429 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2430 */
2431 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2432 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2433 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2434 name, (cmd[4]) ? "" : "un",
2435 load_code - MT_ST_HPLOADER_OFFSET));
2436 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2437 }
2438 if (STp->immediate) {
2439 cmd[1] = 1; /* Don't wait for completion */
2440 timeout = STp->device->timeout;
2441 }
2442 else
2443 timeout = STp->long_timeout;
2444
2445 DEBC(
2446 if (!load_code)
2447 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2448 else
2449 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2450 );
2451
2452 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2453 timeout, MAX_RETRIES, 1);
2454 if (!SRpnt)
2455 return (STp->buffer)->syscall_result;
2456
2457 retval = (STp->buffer)->syscall_result;
8b05b773 2458 st_release_request(SRpnt);
1da177e4
LT		 2459
2460 if (!retval) { /* SCSI command successful */
2461
2462 if (!load_code) {
2463 STp->rew_at_close = 0;
2464 STp->ready = ST_NO_TAPE;
2465 }
2466 else {
2467 STp->rew_at_close = STp->autorew_dev;
2468 retval = check_tape(STp, filp);
2469 if (retval > 0)
2470 retval = 0;
2471 }
2472 }
2473 else {
2474 STps = &(STp->ps[STp->partition]);
2475 STps->drv_file = STps->drv_block = (-1);
2476 }
2477
2478 return retval;
2479}
2480\f
2481#if DEBUG
2482#define ST_DEB_FORWARD 0
2483#define ST_DEB_BACKWARD 1
2484static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2485{
2486 s32 sc;
2487
2488 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2489 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2490 if (direction)
2491 sc = -sc;
2492 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2493 direction ? "backward" : "forward", sc, units);
2494}
2495#endif
2496
2497
2498/* Internal ioctl function */
2499static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2500{
2501 int timeout;
2502 long ltmp;
2503 int ioctl_result;
2504 int chg_eof = 1;
2505 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 2506 struct st_request *SRpnt;
1da177e4
LT		 2507 struct st_partstat *STps;
2508 int fileno, blkno, at_sm, undone;
2509 int datalen = 0, direction = DMA_NONE;
2510 char *name = tape_name(STp);
2511
2512 WARN_ON(STp->buffer->do_dio != 0);
2513 if (STp->ready != ST_READY) {
2514 if (STp->ready == ST_NO_TAPE)
2515 return (-ENOMEDIUM);
2516 else
2517 return (-EIO);
2518 }
2519 timeout = STp->long_timeout;
2520 STps = &(STp->ps[STp->partition]);
2521 fileno = STps->drv_file;
2522 blkno = STps->drv_block;
2523 at_sm = STps->at_sm;
2524
2525 memset(cmd, 0, MAX_COMMAND_SIZE);
2526 switch (cmd_in) {
2527 case MTFSFM:
2528 chg_eof = 0; /* Changed from the FSF after this */
2529 case MTFSF:
2530 cmd[0] = SPACE;
2531 cmd[1] = 0x01; /* Space FileMarks */
2532 cmd[2] = (arg >> 16);
2533 cmd[3] = (arg >> 8);
2534 cmd[4] = arg;
2535 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2536 if (fileno >= 0)
2537 fileno += arg;
2538 blkno = 0;
2539 at_sm &= (arg == 0);
2540 break;
2541 case MTBSFM:
2542 chg_eof = 0; /* Changed from the FSF after this */
2543 case MTBSF:
2544 cmd[0] = SPACE;
2545 cmd[1] = 0x01; /* Space FileMarks */
2546 ltmp = (-arg);
2547 cmd[2] = (ltmp >> 16);
2548 cmd[3] = (ltmp >> 8);
2549 cmd[4] = ltmp;
2550 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2551 if (fileno >= 0)
2552 fileno -= arg;
2553 blkno = (-1); /* We can't know the block number */
2554 at_sm &= (arg == 0);
2555 break;
2556 case MTFSR:
2557 cmd[0] = SPACE;
2558 cmd[1] = 0x00; /* Space Blocks */
2559 cmd[2] = (arg >> 16);
2560 cmd[3] = (arg >> 8);
2561 cmd[4] = arg;
2562 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2563 if (blkno >= 0)
2564 blkno += arg;
2565 at_sm &= (arg == 0);
2566 break;
2567 case MTBSR:
2568 cmd[0] = SPACE;
2569 cmd[1] = 0x00; /* Space Blocks */
2570 ltmp = (-arg);
2571 cmd[2] = (ltmp >> 16);
2572 cmd[3] = (ltmp >> 8);
2573 cmd[4] = ltmp;
2574 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2575 if (blkno >= 0)
2576 blkno -= arg;
2577 at_sm &= (arg == 0);
2578 break;
2579 case MTFSS:
2580 cmd[0] = SPACE;
2581 cmd[1] = 0x04; /* Space Setmarks */
2582 cmd[2] = (arg >> 16);
2583 cmd[3] = (arg >> 8);
2584 cmd[4] = arg;
2585 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2586 if (arg != 0) {
2587 blkno = fileno = (-1);
2588 at_sm = 1;
2589 }
2590 break;
2591 case MTBSS:
2592 cmd[0] = SPACE;
2593 cmd[1] = 0x04; /* Space Setmarks */
2594 ltmp = (-arg);
2595 cmd[2] = (ltmp >> 16);
2596 cmd[3] = (ltmp >> 8);
2597 cmd[4] = ltmp;
2598 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2599 if (arg != 0) {
2600 blkno = fileno = (-1);
2601 at_sm = 1;
2602 }
2603 break;
2604 case MTWEOF:
2605 case MTWSM:
2606 if (STp->write_prot)
2607 return (-EACCES);
2608 cmd[0] = WRITE_FILEMARKS;
2609 if (cmd_in == MTWSM)
2610 cmd[1] = 2;
2611 cmd[2] = (arg >> 16);
2612 cmd[3] = (arg >> 8);
2613 cmd[4] = arg;
2614 timeout = STp->device->timeout;
2615 DEBC(
2616 if (cmd_in == MTWEOF)
2617 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2618 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2619 else
2620 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2621 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2622 )
2623 if (fileno >= 0)
2624 fileno += arg;
2625 blkno = 0;
2626 at_sm = (cmd_in == MTWSM);
2627 break;
2628 case MTREW:
2629 cmd[0] = REZERO_UNIT;
2630 if (STp->immediate) {
2631 cmd[1] = 1; /* Don't wait for completion */
2632 timeout = STp->device->timeout;
2633 }
2634 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2635 fileno = blkno = at_sm = 0;
2636 break;
2637 case MTNOP:
2638 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2639 return 0; /* Should do something ? */
2640 break;
2641 case MTRETEN:
2642 cmd[0] = START_STOP;
2643 if (STp->immediate) {
2644 cmd[1] = 1; /* Don't wait for completion */
2645 timeout = STp->device->timeout;
2646 }
2647 cmd[4] = 3;
2648 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2649 fileno = blkno = at_sm = 0;
2650 break;
2651 case MTEOM:
2652 if (!STp->fast_mteom) {
2653 /* space to the end of tape */
2654 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2655 fileno = STps->drv_file;
2656 if (STps->eof >= ST_EOD_1)
2657 return 0;
2658 /* The next lines would hide the number of spaced FileMarks
2659 That's why I inserted the previous lines. I had no luck
2660 with detecting EOM with FSF, so we go now to EOM.
2661 Joerg Weule */
2662 } else
2663 fileno = (-1);
2664 cmd[0] = SPACE;
2665 cmd[1] = 3;
2666 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2667 name));
2668 blkno = -1;
2669 at_sm = 0;
2670 break;
2671 case MTERASE:
2672 if (STp->write_prot)
2673 return (-EACCES);
2674 cmd[0] = ERASE;
2675 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2676 if (STp->immediate) {
2677 cmd[1] |= 2; /* Don't wait for completion */
2678 timeout = STp->device->timeout;
2679 }
2680 else
2681 timeout = STp->long_timeout * 8;
2682
2683 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2684 fileno = blkno = at_sm = 0;
2685 break;
2686 case MTSETBLK: /* Set block length */
2687 case MTSETDENSITY: /* Set tape density */
2688 case MTSETDRVBUFFER: /* Set drive buffering */
2689 case SET_DENS_AND_BLK: /* Set density and block size */
2690 chg_eof = 0;
2691 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2692 return (-EIO); /* Not allowed if data in buffer */
2693 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2694 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2695 STp->max_block > 0 &&
2696 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2697 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2698 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2699 return (-EINVAL);
2700 }
2701 cmd[0] = MODE_SELECT;
2702 if ((STp->use_pf & USE_PF))
2703 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2704 cmd[4] = datalen = 12;
2705 direction = DMA_TO_DEVICE;
2706
2707 memset((STp->buffer)->b_data, 0, 12);
2708 if (cmd_in == MTSETDRVBUFFER)
2709 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2710 else
2711 (STp->buffer)->b_data[2] =
2712 STp->drv_buffer << 4;
2713 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2714 if (cmd_in == MTSETDENSITY) {
2715 (STp->buffer)->b_data[4] = arg;
2716 STp->density_changed = 1; /* At least we tried ;-) */
2717 } else if (cmd_in == SET_DENS_AND_BLK)
2718 (STp->buffer)->b_data[4] = arg >> 24;
2719 else
2720 (STp->buffer)->b_data[4] = STp->density;
2721 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2722 ltmp = arg & MT_ST_BLKSIZE_MASK;
2723 if (cmd_in == MTSETBLK)
2724 STp->blksize_changed = 1; /* At least we tried ;-) */
2725 } else
2726 ltmp = STp->block_size;
2727 (STp->buffer)->b_data[9] = (ltmp >> 16);
2728 (STp->buffer)->b_data[10] = (ltmp >> 8);
2729 (STp->buffer)->b_data[11] = ltmp;
2730 timeout = STp->device->timeout;
2731 DEBC(
2732 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2733 printk(ST_DEB_MSG
2734 "%s: Setting block size to %d bytes.\n", name,
2735 (STp->buffer)->b_data[9] * 65536 +
2736 (STp->buffer)->b_data[10] * 256 +
2737 (STp->buffer)->b_data[11]);
2738 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2739 printk(ST_DEB_MSG
2740 "%s: Setting density code to %x.\n", name,
2741 (STp->buffer)->b_data[4]);
2742 if (cmd_in == MTSETDRVBUFFER)
2743 printk(ST_DEB_MSG
2744 "%s: Setting drive buffer code to %d.\n", name,
2745 ((STp->buffer)->b_data[2] >> 4) & 7);
2746 )
2747 break;
2748 default:
2749 return (-ENOSYS);
2750 }
2751
2752 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2753 timeout, MAX_RETRIES, 1);
2754 if (!SRpnt)
2755 return (STp->buffer)->syscall_result;
2756
2757 ioctl_result = (STp->buffer)->syscall_result;
2758
2759 if (!ioctl_result) { /* SCSI command successful */
8b05b773 2760 st_release_request(SRpnt);
1da177e4
LT		 2761 SRpnt = NULL;
2762 STps->drv_block = blkno;
2763 STps->drv_file = fileno;
2764 STps->at_sm = at_sm;
2765
2766 if (cmd_in == MTBSFM)
2767 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2768 else if (cmd_in == MTFSFM)
2769 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2770
2771 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2772 int old_block_size = STp->block_size;
2773 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2774 if (STp->block_size != 0) {
2775 if (old_block_size == 0)
2776 normalize_buffer(STp->buffer);
2777 (STp->buffer)->buffer_blocks =
2778 (STp->buffer)->buffer_size / STp->block_size;
2779 }
2780 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2781 if (cmd_in == SET_DENS_AND_BLK)
2782 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2783 } else if (cmd_in == MTSETDRVBUFFER)
2784 STp->drv_buffer = (arg & 7);
2785 else if (cmd_in == MTSETDENSITY)
2786 STp->density = arg;
2787
2788 if (cmd_in == MTEOM)
2789 STps->eof = ST_EOD;
2790 else if (cmd_in == MTFSF)
2791 STps->eof = ST_FM;
2792 else if (chg_eof)
2793 STps->eof = ST_NOEOF;
2794
2795 if (cmd_in == MTWEOF)
2796 STps->rw = ST_IDLE;
2797 } else { /* SCSI command was not completely successful. Don't return
2798 from this block without releasing the SCSI command block! */
2799 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2800
2801 if (cmdstatp->flags & SENSE_EOM) {
2802 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2803 cmd_in != MTBSR && cmd_in != MTBSS)
2804 STps->eof = ST_EOM_OK;
2805 STps->drv_block = 0;
2806 }
2807
2808 if (cmdstatp->remainder_valid)
2809 undone = (int)cmdstatp->uremainder64;
2810 else
2811 undone = 0;
2812
2813 if (cmd_in == MTWEOF &&
2814 cmdstatp->have_sense &&
2815 (cmdstatp->flags & SENSE_EOM) &&
2816 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2817 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
2818 undone == 0) {
2819 ioctl_result = 0; /* EOF written succesfully at EOM */
2820 if (fileno >= 0)
2821 fileno++;
2822 STps->drv_file = fileno;
2823 STps->eof = ST_NOEOF;
2824 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2825 if (fileno >= 0)
2826 STps->drv_file = fileno - undone;
2827 else
2828 STps->drv_file = fileno;
2829 STps->drv_block = -1;
2830 STps->eof = ST_NOEOF;
2831 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2832 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2833 undone = (-undone);
2834 if (STps->drv_file >= 0)
2835 STps->drv_file = fileno + undone;
2836 STps->drv_block = 0;
2837 STps->eof = ST_NOEOF;
2838 } else if (cmd_in == MTFSR) {
2839 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2840 if (STps->drv_file >= 0)
2841 STps->drv_file++;
2842 STps->drv_block = 0;
2843 STps->eof = ST_FM;
2844 } else {
2845 if (blkno >= undone)
2846 STps->drv_block = blkno - undone;
2847 else
2848 STps->drv_block = (-1);
2849 STps->eof = ST_NOEOF;
2850 }
2851 } else if (cmd_in == MTBSR) {
2852 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2853 STps->drv_file--;
2854 STps->drv_block = (-1);
2855 } else {
2856 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2857 undone = (-undone);
2858 if (STps->drv_block >= 0)
2859 STps->drv_block = blkno + undone;
2860 }
2861 STps->eof = ST_NOEOF;
2862 } else if (cmd_in == MTEOM) {
2863 STps->drv_file = (-1);
2864 STps->drv_block = (-1);
2865 STps->eof = ST_EOD;
2866 } else if (cmd_in == MTSETBLK ||
2867 cmd_in == MTSETDENSITY ||
2868 cmd_in == MTSETDRVBUFFER ||
2869 cmd_in == SET_DENS_AND_BLK) {
2870 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2871 !(STp->use_pf & PF_TESTED)) {
2872 /* Try the other possible state of Page Format if not
2873 already tried */
2874 STp->use_pf = !STp->use_pf | PF_TESTED;
8b05b773 2875 st_release_request(SRpnt);
1da177e4
LT		 2876 SRpnt = NULL;
2877 return st_int_ioctl(STp, cmd_in, arg);
2878 }
2879 } else if (chg_eof)
2880 STps->eof = ST_NOEOF;
2881
2882 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2883 STps->eof = ST_EOD;
2884
8b05b773 2885 st_release_request(SRpnt);
1da177e4
LT		 2886 SRpnt = NULL;
2887 }
2888
2889 return ioctl_result;
2890}
2891\f
2892
2893/* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2894 structure. */
2895
2896static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2897 int logical)
2898{
2899 int result;
2900 unsigned char scmd[MAX_COMMAND_SIZE];
8b05b773 2901 struct st_request *SRpnt;
1da177e4
LT		 2902 DEB( char *name = tape_name(STp); )
2903
2904 if (STp->ready != ST_READY)
2905 return (-EIO);
2906
2907 memset(scmd, 0, MAX_COMMAND_SIZE);
2908 if ((STp->device)->scsi_level < SCSI_2) {
2909 scmd[0] = QFA_REQUEST_BLOCK;
2910 scmd[4] = 3;
2911 } else {
2912 scmd[0] = READ_POSITION;
2913 if (!logical && !STp->scsi2_logical)
2914 scmd[1] = 1;
2915 }
2916 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
2917 STp->device->timeout, MAX_READY_RETRIES, 1);
2918 if (!SRpnt)
2919 return (STp->buffer)->syscall_result;
2920
2921 if ((STp->buffer)->syscall_result != 0 ||
2922 (STp->device->scsi_level >= SCSI_2 &&
2923 ((STp->buffer)->b_data[0] & 4) != 0)) {
2924 *block = *partition = 0;
2925 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
2926 result = (-EIO);
2927 } else {
2928 result = 0;
2929 if ((STp->device)->scsi_level < SCSI_2) {
2930 *block = ((STp->buffer)->b_data[0] << 16)
2931 + ((STp->buffer)->b_data[1] << 8)
2932 + (STp->buffer)->b_data[2];
2933 *partition = 0;
2934 } else {
2935 *block = ((STp->buffer)->b_data[4] << 24)
2936 + ((STp->buffer)->b_data[5] << 16)
2937 + ((STp->buffer)->b_data[6] << 8)
2938 + (STp->buffer)->b_data[7];
2939 *partition = (STp->buffer)->b_data[1];
2940 if (((STp->buffer)->b_data[0] & 0x80) &&
2941 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
2942 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
2943 }
2944 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
2945 *block, *partition));
2946 }
8b05b773 2947 st_release_request(SRpnt);
1da177e4
LT		 2948 SRpnt = NULL;
2949
2950 return result;
2951}
2952
2953
2954/* Set the tape block and partition. Negative partition means that only the
2955 block should be set in vendor specific way. */
2956static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
2957 int logical)
2958{
2959 struct st_partstat *STps;
2960 int result, p;
2961 unsigned int blk;
2962 int timeout;
2963 unsigned char scmd[MAX_COMMAND_SIZE];
8b05b773 2964 struct st_request *SRpnt;
1da177e4
LT		 2965 DEB( char *name = tape_name(STp); )
2966
2967 if (STp->ready != ST_READY)
2968 return (-EIO);
2969 timeout = STp->long_timeout;
2970 STps = &(STp->ps[STp->partition]);
2971
2972 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
2973 name, block, partition));
2974 DEB(if (partition < 0)
2975 return (-EIO); )
2976
2977 /* Update the location at the partition we are leaving */
2978 if ((!STp->can_partitions && partition != 0) ||
2979 partition >= ST_NBR_PARTITIONS)
2980 return (-EINVAL);
2981 if (partition != STp->partition) {
2982 if (get_location(STp, &blk, &p, 1))
2983 STps->last_block_valid = 0;
2984 else {
2985 STps->last_block_valid = 1;
2986 STps->last_block_visited = blk;
2987 DEBC(printk(ST_DEB_MSG
2988 "%s: Visited block %d for partition %d saved.\n",
2989 name, blk, STp->partition));
2990 }
2991 }
2992
2993 memset(scmd, 0, MAX_COMMAND_SIZE);
2994 if ((STp->device)->scsi_level < SCSI_2) {
2995 scmd[0] = QFA_SEEK_BLOCK;
2996 scmd[2] = (block >> 16);
2997 scmd[3] = (block >> 8);
2998 scmd[4] = block;
2999 scmd[5] = 0;
3000 } else {
3001 scmd[0] = SEEK_10;
3002 scmd[3] = (block >> 24);
3003 scmd[4] = (block >> 16);
3004 scmd[5] = (block >> 8);
3005 scmd[6] = block;
3006 if (!logical && !STp->scsi2_logical)
3007 scmd[1] = 4;
3008 if (STp->partition != partition) {
3009 scmd[1] |= 2;
3010 scmd[8] = partition;
3011 DEBC(printk(ST_DEB_MSG
3012 "%s: Trying to change partition from %d to %d\n",
3013 name, STp->partition, partition));
3014 }
3015 }
3016 if (STp->immediate) {
3017 scmd[1] |= 1; /* Don't wait for completion */
3018 timeout = STp->device->timeout;
3019 }
3020
3021 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3022 timeout, MAX_READY_RETRIES, 1);
3023 if (!SRpnt)
3024 return (STp->buffer)->syscall_result;
3025
3026 STps->drv_block = STps->drv_file = (-1);
3027 STps->eof = ST_NOEOF;
3028 if ((STp->buffer)->syscall_result != 0) {
3029 result = (-EIO);
3030 if (STp->can_partitions &&
3031 (STp->device)->scsi_level >= SCSI_2 &&
3032 (p = find_partition(STp)) >= 0)
3033 STp->partition = p;
3034 } else {
3035 if (STp->can_partitions) {
3036 STp->partition = partition;
3037 STps = &(STp->ps[partition]);
3038 if (!STps->last_block_valid ||
3039 STps->last_block_visited != block) {
3040 STps->at_sm = 0;
3041 STps->rw = ST_IDLE;
3042 }
3043 } else
3044 STps->at_sm = 0;
3045 if (block == 0)
3046 STps->drv_block = STps->drv_file = 0;
3047 result = 0;
3048 }
3049
8b05b773 3050 st_release_request(SRpnt);
1da177e4
LT		 3051 SRpnt = NULL;
3052
3053 return result;
3054}
3055
3056
3057/* Find the current partition number for the drive status. Called from open and
3058 returns either partition number of negative error code. */
3059static int find_partition(struct scsi_tape *STp)
3060{
3061 int i, partition;
3062 unsigned int block;
3063
3064 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3065 return i;
3066 if (partition >= ST_NBR_PARTITIONS)
3067 return (-EIO);
3068 return partition;
3069}
3070
3071
3072/* Change the partition if necessary */
3073static int switch_partition(struct scsi_tape *STp)
3074{
3075 struct st_partstat *STps;
3076
3077 if (STp->partition == STp->new_partition)
3078 return 0;
3079 STps = &(STp->ps[STp->new_partition]);
3080 if (!STps->last_block_valid)
3081 STps->last_block_visited = 0;
3082 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3083}
3084\f
3085/* Functions for reading and writing the medium partition mode page. */
3086
3087#define PART_PAGE 0x11
3088#define PART_PAGE_FIXED_LENGTH 8
3089
3090#define PP_OFF_MAX_ADD_PARTS 2
3091#define PP_OFF_NBR_ADD_PARTS 3
3092#define PP_OFF_FLAGS 4
3093#define PP_OFF_PART_UNITS 6
3094#define PP_OFF_RESERVED 7
3095
3096#define PP_BIT_IDP 0x20
3097#define PP_MSK_PSUM_MB 0x10
3098
3099/* Get the number of partitions on the tape. As a side effect reads the
3100 mode page into the tape buffer. */
3101static int nbr_partitions(struct scsi_tape *STp)
3102{
3103 int result;
3104 DEB( char *name = tape_name(STp); )
3105
3106 if (STp->ready != ST_READY)
3107 return (-EIO);
3108
3109 result = read_mode_page(STp, PART_PAGE, 1);
3110
3111 if (result) {
3112 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3113 name));
3114 result = (-EIO);
3115 } else {
3116 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3117 PP_OFF_NBR_ADD_PARTS] + 1;
3118 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3119 }
3120
3121 return result;
3122}
3123
3124
3125/* Partition the tape into two partitions if size > 0 or one partition if
3126 size == 0.
3127
3128 The block descriptors are read and written because Sony SDT-7000 does not
3129 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3130
3131 My HP C1533A drive returns only one partition size field. This is used to
3132 set the size of partition 1. There is no size field for the default partition.
3133 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3134 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3135 The following algorithm is used to accommodate both drives: if the number of
3136 partition size fields is greater than the maximum number of additional partitions
3137 in the mode page, the second field is used. Otherwise the first field is used.
3138
3139 For Seagate DDS drives the page length must be 8 when no partitions is defined
3140 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3141 is acceptable also to some other old drives and enforced if the first partition
3142 size field is used for the first additional partition size.
3143 */
3144static int partition_tape(struct scsi_tape *STp, int size)
3145{
3146 char *name = tape_name(STp);
3147 int result;
3148 int pgo, psd_cnt, psdo;
3149 unsigned char *bp;
3150
3151 result = read_mode_page(STp, PART_PAGE, 0);
3152 if (result) {
3153 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3154 return result;
3155 }
3156 /* The mode page is in the buffer. Let's modify it and write it. */
3157 bp = (STp->buffer)->b_data;
3158 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3159 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3160 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3161
3162 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3163 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3164 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3165 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3166 psdo += 2;
3167 }
3168 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3169
3170 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3171 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3172 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3173
3174 if (size <= 0) {
3175 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3176 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3177 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3178 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3179 name));
3180 } else {
3181 bp[psdo] = (size >> 8) & 0xff;
3182 bp[psdo + 1] = size & 0xff;
3183 bp[pgo + 3] = 1;
3184 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3185 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3186 DEBC(printk(ST_DEB_MSG
3187 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3188 name, size));
3189 }
3190 bp[pgo + PP_OFF_PART_UNITS] = 0;
3191 bp[pgo + PP_OFF_RESERVED] = 0;
3192 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3193
3194 result = write_mode_page(STp, PART_PAGE, 1);
3195 if (result) {
3196 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3197 result = (-EIO);
3198 }
3199
3200 return result;
3201}
3202\f
3203
3204
3205/* The ioctl command */
3206static int st_ioctl(struct inode *inode, struct file *file,
3207 unsigned int cmd_in, unsigned long arg)
3208{
3209 int i, cmd_nr, cmd_type, bt;
3210 int retval = 0;
3211 unsigned int blk;
3212 struct scsi_tape *STp = file->private_data;
3213 struct st_modedef *STm;
3214 struct st_partstat *STps;
3215 char *name = tape_name(STp);
3216 void __user *p = (void __user *)arg;
3217
3218 if (down_interruptible(&STp->lock))
3219 return -ERESTARTSYS;
3220
3221 DEB(
3222 if (debugging && !STp->in_use) {
3223 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3224 retval = (-EIO);
3225 goto out;
3226 } ) /* end DEB */
3227
3228 STm = &(STp->modes[STp->current_mode]);
3229 STps = &(STp->ps[STp->partition]);
3230
3231 /*
3232 * If we are in the middle of error recovery, don't let anyone
3233 * else try and use this device. Also, if error recovery fails, it
3234 * may try and take the device offline, in which case all further
3235 * access to the device is prohibited.
3236 */
3237 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p, file);
3238 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3239 goto out;
3240 retval = 0;
3241
3242 cmd_type = _IOC_TYPE(cmd_in);
3243 cmd_nr = _IOC_NR(cmd_in);
3244
3245 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3246 struct mtop mtc;
3247
3248 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3249 retval = (-EINVAL);
3250 goto out;
3251 }
3252
3253 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3254 if (i) {
3255 retval = (-EFAULT);
3256 goto out;
3257 }
3258
3259 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3260 printk(KERN_WARNING
3261 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3262 retval = (-EPERM);
3263 goto out;
3264 }
3265 if (!STm->defined &&
3266 (mtc.mt_op != MTSETDRVBUFFER &&
3267 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3268 retval = (-ENXIO);
3269 goto out;
3270 }
3271
3272 if (!STp->pos_unknown) {
3273
3274 if (STps->eof == ST_FM_HIT) {
3275 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3276 mtc.mt_op == MTEOM) {
3277 mtc.mt_count -= 1;
3278 if (STps->drv_file >= 0)
3279 STps->drv_file += 1;
3280 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3281 mtc.mt_count += 1;
3282 if (STps->drv_file >= 0)
3283 STps->drv_file += 1;
3284 }
3285 }
3286
3287 if (mtc.mt_op == MTSEEK) {
3288 /* Old position must be restored if partition will be
3289 changed */
3290 i = !STp->can_partitions ||
3291 (STp->new_partition != STp->partition);
3292 } else {
3293 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3294 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3295 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3296 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3297 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3298 mtc.mt_op == MTCOMPRESSION;
3299 }
3300 i = flush_buffer(STp, i);
3301 if (i < 0) {
3302 retval = i;
3303 goto out;
3304 }
3305 if (STps->rw == ST_WRITING &&
3306 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3307 mtc.mt_op == MTSEEK ||
3308 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3309 i = st_int_ioctl(STp, MTWEOF, 1);
3310 if (i < 0) {
3311 retval = i;
3312 goto out;
3313 }
3314 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3315 mtc.mt_count++;
3316 STps->rw = ST_IDLE;
3317 }
3318
3319 } else {
3320 /*
3321 * If there was a bus reset, block further access
3322 * to this device. If the user wants to rewind the tape,
3323 * then reset the flag and allow access again.
3324 */
3325 if (mtc.mt_op != MTREW &&
3326 mtc.mt_op != MTOFFL &&
3327 mtc.mt_op != MTRETEN &&
3328 mtc.mt_op != MTERASE &&
3329 mtc.mt_op != MTSEEK &&
3330 mtc.mt_op != MTEOM) {
3331 retval = (-EIO);
3332 goto out;
3333 }
3334 reset_state(STp);
3335 /* remove this when the midlevel properly clears was_reset */
3336 STp->device->was_reset = 0;
3337 }
3338
3339 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3340 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3341 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3342 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3343
3344 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3345 do_door_lock(STp, 0); /* Ignore result! */
3346
3347 if (mtc.mt_op == MTSETDRVBUFFER &&
3348 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3349 retval = st_set_options(STp, mtc.mt_count);
3350 goto out;
3351 }
3352
3353 if (mtc.mt_op == MTSETPART) {
3354 if (!STp->can_partitions ||
3355 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3356 retval = (-EINVAL);
3357 goto out;
3358 }
3359 if (mtc.mt_count >= STp->nbr_partitions &&
3360 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3361 retval = (-EIO);
3362 goto out;
3363 }
3364 if (mtc.mt_count >= STp->nbr_partitions) {
3365 retval = (-EINVAL);
3366 goto out;
3367 }
3368 STp->new_partition = mtc.mt_count;
3369 retval = 0;
3370 goto out;
3371 }
3372
3373 if (mtc.mt_op == MTMKPART) {
3374 if (!STp->can_partitions) {
3375 retval = (-EINVAL);
3376 goto out;
3377 }
3378 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3379 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3380 retval = i;
3381 goto out;
3382 }
3383 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3384 STp->ps[i].rw = ST_IDLE;
3385 STp->ps[i].at_sm = 0;
3386 STp->ps[i].last_block_valid = 0;
3387 }
3388 STp->partition = STp->new_partition = 0;
3389 STp->nbr_partitions = 1; /* Bad guess ?-) */
3390 STps->drv_block = STps->drv_file = 0;
3391 retval = 0;
3392 goto out;
3393 }
3394
3395 if (mtc.mt_op == MTSEEK) {
3396 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3397 if (!STp->can_partitions)
3398 STp->ps[0].rw = ST_IDLE;
3399 retval = i;
3400 goto out;
3401 }
3402
3403 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3404 retval = do_load_unload(STp, file, 0);
3405 goto out;
3406 }
3407
3408 if (mtc.mt_op == MTLOAD) {
3409 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3410 goto out;
3411 }
3412
3413 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3414 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3415 goto out;
3416 }
3417
3418 if (STp->can_partitions && STp->ready == ST_READY &&
3419 (i = switch_partition(STp)) < 0) {
3420 retval = i;
3421 goto out;
3422 }
3423
3424 if (mtc.mt_op == MTCOMPRESSION)
3425 retval = st_compression(STp, (mtc.mt_count & 1));
3426 else
3427 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3428 goto out;
3429 }
3430 if (!STm->defined) {
3431 retval = (-ENXIO);
3432 goto out;
3433 }
3434
3435 if ((i = flush_buffer(STp, 0)) < 0) {
3436 retval = i;
3437 goto out;
3438 }
3439 if (STp->can_partitions &&
3440 (i = switch_partition(STp)) < 0) {
3441 retval = i;
3442 goto out;
3443 }
3444
3445 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3446 struct mtget mt_status;
3447
3448 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3449 retval = (-EINVAL);
3450 goto out;
3451 }
3452
3453 mt_status.mt_type = STp->tape_type;
3454 mt_status.mt_dsreg =
3455 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3456 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3457 mt_status.mt_blkno = STps->drv_block;
3458 mt_status.mt_fileno = STps->drv_file;
3459 if (STp->block_size != 0) {
3460 if (STps->rw == ST_WRITING)
3461 mt_status.mt_blkno +=
3462 (STp->buffer)->buffer_bytes / STp->block_size;
3463 else if (STps->rw == ST_READING)
3464 mt_status.mt_blkno -=
3465 ((STp->buffer)->buffer_bytes +
3466 STp->block_size - 1) / STp->block_size;
3467 }
3468
3469 mt_status.mt_gstat = 0;
3470 if (STp->drv_write_prot)
3471 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3472 if (mt_status.mt_blkno == 0) {
3473 if (mt_status.mt_fileno == 0)
3474 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3475 else
3476 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3477 }
3478 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3479 mt_status.mt_resid = STp->partition;
3480 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3481 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3482 else if (STps->eof >= ST_EOM_OK)
3483 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3484 if (STp->density == 1)
3485 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3486 else if (STp->density == 2)
3487 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3488 else if (STp->density == 3)
3489 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3490 if (STp->ready == ST_READY)
3491 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3492 if (STp->ready == ST_NO_TAPE)
3493 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3494 if (STps->at_sm)
3495 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3496 if (STm->do_async_writes ||
3497 (STm->do_buffer_writes && STp->block_size != 0) ||
3498 STp->drv_buffer != 0)
3499 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3500 if (STp->cleaning_req)
3501 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3502
3503 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3504 if (i) {
3505 retval = (-EFAULT);
3506 goto out;
3507 }
3508
3509 STp->recover_reg = 0; /* Clear after read */
3510 retval = 0;
3511 goto out;
3512 } /* End of MTIOCGET */
3513 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3514 struct mtpos mt_pos;
3515 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3516 retval = (-EINVAL);
3517 goto out;
3518 }
3519 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3520 retval = i;
3521 goto out;
3522 }
3523 mt_pos.mt_blkno = blk;
3524 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3525 if (i)
3526 retval = (-EFAULT);
3527 goto out;
3528 }
3529 up(&STp->lock);
3530 switch (cmd_in) {
3531 case SCSI_IOCTL_GET_IDLUN:
3532 case SCSI_IOCTL_GET_BUS_NUMBER:
3533 break;
3534 default:
16c4b3e2
KM		 3535 if ((cmd_in == SG_IO ||
3536 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3537 cmd_in == CDROM_SEND_PACKET) &&
3538 !capable(CAP_SYS_RAWIO))
1da177e4
LT		 3539 i = -EPERM;
3540 else
3541 i = scsi_cmd_ioctl(file, STp->disk, cmd_in, p);
3542 if (i != -ENOTTY)
3543 return i;
3544 break;
3545 }
16c4b3e2
KM		 3546 retval = scsi_ioctl(STp->device, cmd_in, p);
3547 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3548 STp->rew_at_close = 0;
3549 STp->ready = ST_NO_TAPE;
3550 }
3551 return retval;
1da177e4
LT		 3552
3553 out:
3554 up(&STp->lock);
3555 return retval;
3556}
3557
3558#ifdef CONFIG_COMPAT
3559static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3560{
3561 struct scsi_tape *STp = file->private_data;
3562 struct scsi_device *sdev = STp->device;
3563 int ret = -ENOIOCTLCMD;
3564 if (sdev->host->hostt->compat_ioctl) {
3565
3566 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3567
3568 }
3569 return ret;
3570}
3571#endif
3572
3573\f
3574
3575/* Try to allocate a new tape buffer. Calling function must not hold
3576 dev_arr_lock. */
3577static struct st_buffer *
3578 new_tape_buffer(int from_initialization, int need_dma, int max_sg)
3579{
8b05b773 3580 int i, got = 0;
c53033f6 3581 gfp_t priority;
1da177e4
LT		 3582 struct st_buffer *tb;
3583
3584 if (from_initialization)
3585 priority = GFP_ATOMIC;
3586 else
3587 priority = GFP_KERNEL;
3588
3589 i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3590 max_sg * sizeof(struct st_buf_fragment);
3591 tb = kmalloc(i, priority);
3592 if (!tb) {
3593 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3594 return NULL;
3595 }
3596 memset(tb, 0, i);
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
3925 tmp_da = kmalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
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
3932 memset(tmp_da, 0, tmp_dev_max * sizeof(struct scsi_tape *));
3933 if (scsi_tapes != NULL) {
3934 memcpy(tmp_da, scsi_tapes,
3935 st_dev_max * sizeof(struct scsi_tape *));
3936 kfree(scsi_tapes);
3937 }
3938 scsi_tapes = tmp_da;
3939
3940 st_dev_max = tmp_dev_max;
3941 }
3942
3943 for (i = 0; i < st_dev_max; i++)
3944 if (scsi_tapes[i] == NULL)
3945 break;
3946 if (i >= st_dev_max)
3947 panic("scsi_devices corrupt (st)");
3948
3949 tpnt = kmalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
3950 if (tpnt == NULL) {
3951 write_unlock(&st_dev_arr_lock);
3952 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
3953 goto out_put_disk;
3954 }
3955 memset(tpnt, 0, sizeof(struct scsi_tape));
f03a5670 3956 kref_init(&tpnt->kref);
1da177e4
LT		 3957 tpnt->disk = disk;
3958 sprintf(disk->disk_name, "st%d", i);
3959 disk->private_data = &tpnt->driver;
3960 disk->queue = SDp->request_queue;
3961 tpnt->driver = &st_template;
3962 scsi_tapes[i] = tpnt;
3963 dev_num = i;
3964
3965 tpnt->device = SDp;
3966 if (SDp->scsi_level <= 2)
3967 tpnt->tape_type = MT_ISSCSI1;
3968 else
3969 tpnt->tape_type = MT_ISSCSI2;
3970
3971 tpnt->buffer = buffer;
f03a5670 3972 tpnt->buffer->last_SRpnt = NULL;
1da177e4
LT		 3973
3974 tpnt->inited = 0;
3975 tpnt->dirty = 0;
3976 tpnt->in_use = 0;
3977 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
3978 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
3979 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
3980 tpnt->density = 0;
3981 tpnt->do_auto_lock = ST_AUTO_LOCK;
3982 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
3983 tpnt->can_partitions = 0;
3984 tpnt->two_fm = ST_TWO_FM;
3985 tpnt->fast_mteom = ST_FAST_MTEOM;
3986 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
3987 tpnt->immediate = ST_NOWAIT;
3988 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
3989 tpnt->partition = 0;
3990 tpnt->new_partition = 0;
3991 tpnt->nbr_partitions = 0;
3992 tpnt->device->timeout = ST_TIMEOUT;
3993 tpnt->long_timeout = ST_LONG_TIMEOUT;
3994 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
3995
1da177e4
LT		 3996 for (i = 0; i < ST_NBR_MODES; i++) {
3997 STm = &(tpnt->modes[i]);
3998 STm->defined = 0;
3999 STm->sysv = ST_SYSV;
4000 STm->defaults_for_writes = 0;
4001 STm->do_async_writes = ST_ASYNC_WRITES;
4002 STm->do_buffer_writes = ST_BUFFER_WRITES;
4003 STm->do_read_ahead = ST_READ_AHEAD;
4004 STm->default_compression = ST_DONT_TOUCH;
4005 STm->default_blksize = (-1); /* No forced size */
4006 STm->default_density = (-1); /* No forced density */
4007 }
4008
4009 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4010 STps = &(tpnt->ps[i]);
4011 STps->rw = ST_IDLE;
4012 STps->eof = ST_NOEOF;
4013 STps->at_sm = 0;
4014 STps->last_block_valid = 0;
4015 STps->drv_block = (-1);
4016 STps->drv_file = (-1);
4017 }
4018
4019 tpnt->current_mode = 0;
4020 tpnt->modes[0].defined = 1;
4021
4022 tpnt->density_changed = tpnt->compression_changed =
4023 tpnt->blksize_changed = 0;
4024 init_MUTEX(&tpnt->lock);
4025
4026 st_nr_dev++;
4027 write_unlock(&st_dev_arr_lock);
4028
4029 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4030 STm = &(tpnt->modes[mode]);
4031 for (j=0; j < 2; j++) {
4032 cdev = cdev_alloc();
4033 if (!cdev) {
4034 printk(KERN_ERR
4035 "st%d: out of memory. Device not attached.\n",
4036 dev_num);
4037 goto out_free_tape;
4038 }
4039 cdev->owner = THIS_MODULE;
4040 cdev->ops = &st_fops;
4041
4042 error = cdev_add(cdev,
4043 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4044 1);
4045 if (error) {
4046 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4047 dev_num, j ? "non" : "auto", mode);
4048 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4049 goto out_free_tape;
4050 }
4051 STm->cdevs[j] = cdev;
4052
4053 }
4054 do_create_class_files(tpnt, dev_num, mode);
4055 }
4056
4057 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4058 /* Make sure that the minor numbers corresponding to the four
4059 first modes always get the same names */
4060 i = mode << (4 - ST_NBR_MODE_BITS);
4061 /* Rewind entry */
4062 devfs_mk_cdev(MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, 0)),
4063 S_IFCHR | S_IRUGO | S_IWUGO,
4064 "%s/mt%s", SDp->devfs_name, st_formats[i]);
4065 /* No-rewind entry */
4066 devfs_mk_cdev(MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, 1)),
4067 S_IFCHR | S_IRUGO | S_IWUGO,
4068 "%s/mt%sn", SDp->devfs_name, st_formats[i]);
4069 }
4070 disk->number = devfs_register_tape(SDp->devfs_name);
4071
9ccfc756
JB		 4072 sdev_printk(KERN_WARNING, SDp,
4073 "Attached scsi tape %s", tape_name(tpnt));
8b05b773 4074 printk(KERN_WARNING "%s: try direct i/o: %s (alignment %d B)\n",
1da177e4 4075 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
8b05b773 4076 queue_dma_alignment(SDp->request_queue) + 1);
1da177e4
LT		 4077
4078 return 0;
4079
4080out_free_tape:
4081 for (mode=0; mode < ST_NBR_MODES; mode++) {
4082 STm = &(tpnt->modes[mode]);
4083 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4084 "tape");
4085 for (j=0; j < 2; j++) {
4086 if (STm->cdevs[j]) {
4087 if (cdev == STm->cdevs[j])
4088 cdev = NULL;
d253878b
GKH		 4089 class_device_destroy(st_sysfs_class,
4090 MKDEV(SCSI_TAPE_MAJOR,
4091 TAPE_MINOR(i, mode, j)));
1da177e4
LT		 4092 cdev_del(STm->cdevs[j]);
4093 }
4094 }
4095 }
4096 if (cdev)
4097 cdev_del(cdev);
4098 write_lock(&st_dev_arr_lock);
4099 scsi_tapes[dev_num] = NULL;
4100 st_nr_dev--;
4101 write_unlock(&st_dev_arr_lock);
4102out_put_disk:
4103 put_disk(disk);
c9475cb0 4104 kfree(tpnt);
1da177e4
LT		 4105out_buffer_free:
4106 kfree(buffer);
4107out:
4108 return -ENODEV;
4109};
4110
4111
4112static int st_remove(struct device *dev)
4113{
4114 struct scsi_device *SDp = to_scsi_device(dev);
4115 struct scsi_tape *tpnt;
4116 int i, j, mode;
4117
4118 write_lock(&st_dev_arr_lock);
4119 for (i = 0; i < st_dev_max; i++) {
4120 tpnt = scsi_tapes[i];
4121 if (tpnt != NULL && tpnt->device == SDp) {
4122 scsi_tapes[i] = NULL;
4123 st_nr_dev--;
4124 write_unlock(&st_dev_arr_lock);
4125 devfs_unregister_tape(tpnt->disk->number);
4126 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4127 "tape");
4128 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4129 j = mode << (4 - ST_NBR_MODE_BITS);
4130 devfs_remove("%s/mt%s", SDp->devfs_name, st_formats[j]);
4131 devfs_remove("%s/mt%sn", SDp->devfs_name, st_formats[j]);
4132 for (j=0; j < 2; j++) {
d253878b
GKH		 4133 class_device_destroy(st_sysfs_class,
4134 MKDEV(SCSI_TAPE_MAJOR,
4135 TAPE_MINOR(i, mode, j)));
1da177e4
LT		 4136 cdev_del(tpnt->modes[mode].cdevs[j]);
4137 tpnt->modes[mode].cdevs[j] = NULL;
4138 }
4139 }
1da177e4 4140
f03a5670
KM		 4141 down(&st_ref_sem);
4142 kref_put(&tpnt->kref, scsi_tape_release);
4143 up(&st_ref_sem);
1da177e4
LT		 4144 return 0;
4145 }
4146 }
4147
4148 write_unlock(&st_dev_arr_lock);
4149 return 0;
4150}
4151
f03a5670
KM		 4152/**
4153 * scsi_tape_release - Called to free the Scsi_Tape structure
4154 * @kref: pointer to embedded kref
4155 *
4156 * st_ref_sem must be held entering this routine. Because it is
4157 * called on last put, you should always use the scsi_tape_get()
4158 * scsi_tape_put() helpers which manipulate the semaphore directly
4159 * and never do a direct kref_put().
4160 **/
4161static void scsi_tape_release(struct kref *kref)
4162{
4163 struct scsi_tape *tpnt = to_scsi_tape(kref);
4164 struct gendisk *disk = tpnt->disk;
4165
4166 tpnt->device = NULL;
4167
4168 if (tpnt->buffer) {
4169 tpnt->buffer->orig_frp_segs = 0;
4170 normalize_buffer(tpnt->buffer);
4171 kfree(tpnt->buffer);
4172 }
4173
4174 disk->private_data = NULL;
4175 put_disk(disk);
4176 kfree(tpnt);
4177 return;
4178}
4179
1da177e4
LT		 4180static void st_intr(struct scsi_cmnd *SCpnt)
4181{
0d95716d
MC		 4182 /*
4183 * The caller should be checking the request's errors
4184 * value.
4185 */
4186 scsi_io_completion(SCpnt, SCpnt->bufflen, 0);
1da177e4
LT		 4187}
4188
4189/*
4190 * st_init_command: only called via the scsi_cmd_ioctl (block SG_IO)
4191 * interface for REQ_BLOCK_PC commands.
4192 */
4193static int st_init_command(struct scsi_cmnd *SCpnt)
4194{
4195 struct request *rq;
4196
4197 if (!(SCpnt->request->flags & REQ_BLOCK_PC))
4198 return 0;
4199
4200 rq = SCpnt->request;
4201 if (sizeof(rq->cmd) > sizeof(SCpnt->cmnd))
4202 return 0;
4203
4204 memcpy(SCpnt->cmnd, rq->cmd, sizeof(SCpnt->cmnd));
186d330e 4205 SCpnt->cmd_len = rq->cmd_len;
1da177e4
LT		 4206
4207 if (rq_data_dir(rq) == WRITE)
4208 SCpnt->sc_data_direction = DMA_TO_DEVICE;
4209 else if (rq->data_len)
4210 SCpnt->sc_data_direction = DMA_FROM_DEVICE;
4211 else
4212 SCpnt->sc_data_direction = DMA_NONE;
4213
4214 SCpnt->timeout_per_command = rq->timeout;
4215 SCpnt->transfersize = rq->data_len;
4216 SCpnt->done = st_intr;
4217 return 1;
4218}
4219
4220static int __init init_st(void)
4221{
4222 validate_options();
4223
4224 printk(KERN_INFO
4225 "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4226 verstr, st_fixed_buffer_size, st_max_sg_segs);
4227
d253878b 4228 st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
1da177e4
LT		 4229 if (IS_ERR(st_sysfs_class)) {
4230 st_sysfs_class = NULL;
4231 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4232 return 1;
4233 }
4234
4235 if (!register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4236 ST_MAX_TAPE_ENTRIES, "st")) {
4237 if (scsi_register_driver(&st_template.gendrv) == 0) {
4238 do_create_driverfs_files();
4239 return 0;
4240 }
1da177e4 4241 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
1da177e4
LT		 4242 ST_MAX_TAPE_ENTRIES);
4243 }
c2c96f46 4244 class_destroy(st_sysfs_class);
1da177e4
LT		 4245
4246 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n", SCSI_TAPE_MAJOR);
4247 return 1;
4248}
4249
4250static void __exit exit_st(void)
4251{
1da177e4
LT		 4252 do_remove_driverfs_files();
4253 scsi_unregister_driver(&st_template.gendrv);
4254 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4255 ST_MAX_TAPE_ENTRIES);
c2c96f46 4256 class_destroy(st_sysfs_class);
1da177e4
LT		 4257 kfree(scsi_tapes);
4258 printk(KERN_INFO "st: Unloaded.\n");
4259}
4260
4261module_init(init_st);
4262module_exit(exit_st);
4263
4264
4265/* The sysfs driver interface. Read-only at the moment */
4266static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4267{
4268 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4269}
4270static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4271
4272static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4273{
4274 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4275}
4276static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4277
4278static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4279{
4280 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4281}
4282static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4283
4284static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4285{
4286 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4287}
4288static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4289
4290static void do_create_driverfs_files(void)
4291{
4292 struct device_driver *driverfs = &st_template.gendrv;
4293
4294 driver_create_file(driverfs, &driver_attr_try_direct_io);
4295 driver_create_file(driverfs, &driver_attr_fixed_buffer_size);
4296 driver_create_file(driverfs, &driver_attr_max_sg_segs);
4297 driver_create_file(driverfs, &driver_attr_version);
4298}
4299
4300static void do_remove_driverfs_files(void)
4301{
4302 struct device_driver *driverfs = &st_template.gendrv;
4303
4304 driver_remove_file(driverfs, &driver_attr_version);
4305 driver_remove_file(driverfs, &driver_attr_max_sg_segs);
4306 driver_remove_file(driverfs, &driver_attr_fixed_buffer_size);
4307 driver_remove_file(driverfs, &driver_attr_try_direct_io);
4308}
4309
4310
4311/* The sysfs simple class interface */
4312static ssize_t st_defined_show(struct class_device *class_dev, char *buf)
4313{
4314 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4315 ssize_t l = 0;
4316
4317 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4318 return l;
4319}
4320
4321CLASS_DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4322
4323static ssize_t st_defblk_show(struct class_device *class_dev, char *buf)
4324{
4325 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4326 ssize_t l = 0;
4327
4328 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4329 return l;
4330}
4331
4332CLASS_DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4333
4334static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf)
4335{
4336 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4337 ssize_t l = 0;
4338 char *fmt;
4339
4340 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4341 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4342 return l;
4343}
4344
4345CLASS_DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4346
4347static ssize_t st_defcompression_show(struct class_device *class_dev, char *buf)
4348{
4349 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4350 ssize_t l = 0;
4351
4352 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4353 return l;
4354}
4355
4356CLASS_DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4357
4358static void do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4359{
4360 int i, rew, error;
4361 char name[10];
4362 struct class_device *st_class_member;
4363
4364 if (!st_sysfs_class)
4365 return;
4366
4367 for (rew=0; rew < 2; rew++) {
4368 /* Make sure that the minor numbers corresponding to the four
4369 first modes always get the same names */
4370 i = mode << (4 - ST_NBR_MODE_BITS);
4371 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4372 STp->disk->disk_name, st_formats[i]);
4373 st_class_member =
53f46542 4374 class_device_create(st_sysfs_class, NULL,
d253878b
GKH		 4375 MKDEV(SCSI_TAPE_MAJOR,
4376 TAPE_MINOR(dev_num, mode, rew)),
4377 &STp->device->sdev_gendev, "%s", name);
1da177e4 4378 if (IS_ERR(st_class_member)) {
d253878b 4379 printk(KERN_WARNING "st%d: class_device_create failed\n",
1da177e4
LT		 4380 dev_num);
4381 goto out;
4382 }
4383 class_set_devdata(st_class_member, &STp->modes[mode]);
4384
4385 class_device_create_file(st_class_member,
4386 &class_device_attr_defined);
4387 class_device_create_file(st_class_member,
4388 &class_device_attr_default_blksize);
4389 class_device_create_file(st_class_member,
4390 &class_device_attr_default_density);
4391 class_device_create_file(st_class_member,
4392 &class_device_attr_default_compression);
4393 if (mode == 0 && rew == 0) {
4394 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4395 &st_class_member->kobj,
4396 "tape");
4397 if (error) {
4398 printk(KERN_ERR
4399 "st%d: Can't create sysfs link from SCSI device.\n",
4400 dev_num);
4401 }
4402 }
4403 }
4404 out:
4405 return;
4406}
4407
1da177e4
LT		 4408/* The following functions may be useful for a larger audience. */
4409static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4410 unsigned long uaddr, size_t count, int rw)
4411{
07542b83
JB		 4412 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4413 unsigned long start = uaddr >> PAGE_SHIFT;
4414 const int nr_pages = end - start;
1da177e4 4415 int res, i, j;
1da177e4
LT		 4416 struct page **pages;
4417
1da177e4
LT		 4418 /* User attempted Overflow! */
4419 if ((uaddr + count) < uaddr)
4420 return -EINVAL;
4421
4422 /* Too big */
4423 if (nr_pages > max_pages)
4424 return -ENOMEM;
4425
4426 /* Hmm? */
4427 if (count == 0)
4428 return 0;
4429
4430 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4431 return -ENOMEM;
4432
4433 /* Try to fault in all of the necessary pages */
4434 down_read(&current->mm->mmap_sem);
4435 /* rw==READ means read from drive, write into memory area */
4436 res = get_user_pages(
4437 current,
4438 current->mm,
4439 uaddr,
4440 nr_pages,
4441 rw == READ,
4442 0, /* don't force */
4443 pages,
4444 NULL);
4445 up_read(&current->mm->mmap_sem);
4446
4447 /* Errors and no page mapped should return here */
4448 if (res < nr_pages)
4449 goto out_unmap;
4450
4451 for (i=0; i < nr_pages; i++) {
4452 /* FIXME: flush superflous for rw==READ,
4453 * probably wrong function for rw==WRITE
4454 */
4455 flush_dcache_page(pages[i]);
4456 }
4457
4458 /* Populate the scatter/gather list */
4459 sgl[0].page = pages[0];
4460 sgl[0].offset = uaddr & ~PAGE_MASK;
4461 if (nr_pages > 1) {
4462 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4463 count -= sgl[0].length;
4464 for (i=1; i < nr_pages ; i++) {
4465 sgl[i].offset = 0;
4466 sgl[i].page = pages[i];
4467 sgl[i].length = count < PAGE_SIZE ? count : PAGE_SIZE;
4468 count -= PAGE_SIZE;
4469 }
4470 }
4471 else {
4472 sgl[0].length = count;
4473 }
4474
4475 kfree(pages);
4476 return nr_pages;
4477
4478 out_unmap:
4479 if (res > 0) {
4480 for (j=0; j < res; j++)
4481 page_cache_release(pages[j]);
6bc733e9 4482 res = 0;
1da177e4
LT		 4483 }
4484 kfree(pages);
4485 return res;
4486}
4487
4488
4489/* And unmap them... */
4490static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4491 int dirtied)
4492{
4493 int i;
4494
4495 for (i=0; i < nr_pages; i++) {
b5810039
NP		 4496 struct page *page = sgl[i].page;
4497
b5810039
NP		 4498 if (dirtied)
4499 SetPageDirty(page);
1da177e4
LT		 4500 /* FIXME: cache flush missing for rw==READ
4501 * FIXME: call the correct reference counting function
4502 */
b5810039 4503 page_cache_release(page);
1da177e4
LT		 4504 }
4505
4506 return 0;
4507}
kernel source for telekom puls (alcatel/mediatek)