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