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