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