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