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