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