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