This source file includes following definitions.
- st_chk_result
- st_sleep_done
- write_behind_check
- back_over_eof
- flush_write_buffer
- flush_buffer
- scsi_tape_open
- scsi_tape_close
- st_write
- st_read
- st_set_options
- st_int_ioctl
- st_ioctl
- st_setup
- st_attach
- st_detect
- st_init
- st_detach
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 #include <linux/fs.h>
18 #include <linux/kernel.h>
19 #include <linux/sched.h>
20 #include <linux/mm.h>
21 #include <linux/string.h>
22 #include <linux/errno.h>
23 #include <linux/mtio.h>
24 #include <linux/ioctl.h>
25 #include <linux/fcntl.h>
26 #include <asm/segment.h>
27 #include <asm/system.h>
28
29 #define MAJOR_NR SCSI_TAPE_MAJOR
30 #include "../block/blk.h"
31 #include "scsi.h"
32 #include "hosts.h"
33 #include "scsi_ioctl.h"
34 #include "st.h"
35 #include "constants.h"
36
37
38
39
40
41
42
43
44
45 #define ST_TWO_FM 0
46
47 #define ST_FAST_MTEOM 0
48
49 #define ST_BUFFER_WRITES 1
50
51 #define ST_ASYNC_WRITES 1
52
53 #define ST_READ_AHEAD 1
54
55 #define ST_BLOCK_SIZE 1024
56
57 #define ST_MAX_BUFFERS (2 + ST_EXTRA_DEVS)
58
59 #define ST_BUFFER_BLOCKS 32
60
61 #define ST_WRITE_THRESHOLD_BLOCKS 30
62
63 #define ST_BUFFER_SIZE (ST_BUFFER_BLOCKS * ST_BLOCK_SIZE)
64 #define ST_WRITE_THRESHOLD (ST_WRITE_THRESHOLD_BLOCKS * ST_BLOCK_SIZE)
65
66
67
68 #if ST_BUFFER_SIZE >= (2 << 24 - 1)
69 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
70 #endif
71
72 #ifdef DEBUG
73 static int debugging = 1;
74 #endif
75
76 #define MAX_RETRIES 0
77 #define MAX_WRITE_RETRIES 0
78 #define MAX_READY_RETRIES 5
79 #define NO_TAPE NOT_READY
80
81 #define ST_TIMEOUT 90000
82 #define ST_LONG_TIMEOUT 200000
83
84 static int st_nbr_buffers;
85 static ST_buffer **st_buffers;
86 static int st_buffer_size = ST_BUFFER_SIZE;
87 static int st_write_threshold = ST_WRITE_THRESHOLD;
88 static int st_max_buffers = ST_MAX_BUFFERS;
89
90 static Scsi_Tape * scsi_tapes;
91
92 static void st_init(void);
93 static int st_attach(Scsi_Device *);
94 static int st_detect(Scsi_Device *);
95 static void st_detach(Scsi_Device *);
96
97 struct Scsi_Device_Template st_template = {NULL, "tape", "st", TYPE_TAPE,
98 SCSI_TAPE_MAJOR, 0, 0, 0, 0,
99 st_detect, st_init,
100 NULL, st_attach, st_detach};
101
102 static int st_int_ioctl(struct inode * inode,struct file * file,
103 unsigned int cmd_in, unsigned long arg);
104
105
106
107
108
109 static int
110 st_chk_result(Scsi_Cmnd * SCpnt)
111 {
112 int dev = SCpnt->request.dev;
113 int result = SCpnt->result;
114 unsigned char * sense = SCpnt->sense_buffer, scode;
115 char *stp;
116
117 if (!result )
118 return 0;
119 #ifdef DEBUG
120 if (debugging) {
121 printk("st%d: Error: %x, cmd: %x %x %x %x %x %x Len: %d\n", dev, result,
122 SCpnt->cmnd[0], SCpnt->cmnd[1], SCpnt->cmnd[2],
123 SCpnt->cmnd[3], SCpnt->cmnd[4], SCpnt->cmnd[5],
124 SCpnt->request_bufflen);
125 if (driver_byte(result) & DRIVER_SENSE)
126 print_sense("st", SCpnt);
127 } else
128 #endif
129 scode = sense[2] & 0x0f;
130 if (!(driver_byte(result) & DRIVER_SENSE) ||
131 ((sense[0] & 0x70) == 0x70 &&
132 scode != NO_SENSE &&
133 scode != RECOVERED_ERROR &&
134 scode != UNIT_ATTENTION &&
135 scode != BLANK_CHECK &&
136 scode != VOLUME_OVERFLOW)) {
137 printk("st%d: Error %x. ", dev, result);
138 if (driver_byte(result) & DRIVER_SENSE)
139 print_sense("st", SCpnt);
140 else
141 printk("\n");
142 }
143
144 if ((sense[0] & 0x70) == 0x70 &&
145 scode == RECOVERED_ERROR
146 #ifdef ST_RECOVERED_WRITE_FATAL
147 && SCpnt->cmnd[0] != WRITE_6
148 && SCpnt->cmnd[0] != WRITE_FILEMARKS
149 #endif
150 ) {
151 scsi_tapes[dev].recover_count++;
152 scsi_tapes[dev].mt_status->mt_erreg += (1 << MT_ST_SOFTERR_SHIFT);
153 if (SCpnt->cmnd[0] == READ_6)
154 stp = "read";
155 else if (SCpnt->cmnd[0] == WRITE_6)
156 stp = "write";
157 else
158 stp = "ioctl";
159 printk("st%d: Recovered %s error (%d).\n", dev, stp,
160 scsi_tapes[dev].recover_count);
161 return 0;
162 }
163 return (-EIO);
164 }
165
166
167
168 static void
169 st_sleep_done (Scsi_Cmnd * SCpnt)
170 {
171 int st_nbr, remainder;
172 Scsi_Tape * STp;
173
174 if ((st_nbr = SCpnt->request.dev) < st_template.nr_dev && st_nbr >= 0) {
175 STp = &(scsi_tapes[st_nbr]);
176 if ((STp->buffer)->writing &&
177 (SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
178 (SCpnt->sense_buffer[2] & 0x40)) {
179
180 if ((SCpnt->sense_buffer[0] & 0x80) != 0)
181 remainder = (SCpnt->sense_buffer[3] << 24) |
182 (SCpnt->sense_buffer[4] << 16) |
183 (SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
184 else
185 remainder = 0;
186 if ((SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW ||
187 remainder > 0)
188 (STp->buffer)->last_result = SCpnt->result;
189 else
190 (STp->buffer)->last_result = INT_MAX;
191 }
192 else
193 (STp->buffer)->last_result = SCpnt->result;
194 (STp->buffer)->last_result_fatal = st_chk_result(SCpnt);
195 if ((STp->buffer)->writing)
196 SCpnt->request.dev = -1;
197 else
198 SCpnt->request.dev = 0xffff;
199 if ((STp->buffer)->writing <= 0)
200 wake_up( &(STp->waiting) );
201 }
202 #ifdef DEBUG
203 else if (debugging)
204 printk("st?: Illegal interrupt device %x\n", st_nbr);
205 #endif
206 }
207
208
209
210 static void
211 write_behind_check(int dev)
212 {
213 Scsi_Tape * STp;
214 ST_buffer * STbuffer;
215 unsigned long flags;
216
217 STp = &(scsi_tapes[dev]);
218 STbuffer = STp->buffer;
219
220 save_flags(flags);
221 cli();
222 if (STbuffer->last_result < 0) {
223 STbuffer->writing = (- STbuffer->writing);
224 sleep_on( &(STp->waiting) );
225 STbuffer->writing = (- STbuffer->writing);
226 }
227 restore_flags(flags);
228
229 if (STbuffer->writing < STbuffer->buffer_bytes)
230 memcpy(STbuffer->b_data,
231 STbuffer->b_data + STbuffer->writing,
232 STbuffer->buffer_bytes - STbuffer->writing);
233 STbuffer->buffer_bytes -= STbuffer->writing;
234 if (STp->drv_block >= 0) {
235 if (STp->block_size == 0)
236 STp->drv_block++;
237 else
238 STp->drv_block += STbuffer->writing / STp->block_size;
239 }
240 STbuffer->writing = 0;
241
242 return;
243 }
244
245
246
247
248 static int
249 back_over_eof(int dev)
250 {
251 Scsi_Cmnd *SCpnt;
252 Scsi_Tape *STp = &(scsi_tapes[dev]);
253 unsigned char cmd[10];
254
255 cmd[0] = SPACE;
256 cmd[1] = 0x01;
257 cmd[2] = cmd[3] = cmd[4] = 0xff;
258 cmd[5] = 0;
259
260 SCpnt = allocate_device(NULL, STp->device, 1);
261 SCpnt->sense_buffer[0] = 0;
262 SCpnt->request.dev = dev;
263 scsi_do_cmd(SCpnt,
264 (void *) cmd, (void *) (STp->buffer)->b_data, 0,
265 st_sleep_done, ST_TIMEOUT, MAX_RETRIES);
266
267 if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
268 SCpnt->request.dev = -1;
269 if ((STp->buffer)->last_result != 0) {
270 printk("st%d: Backing over filemark failed.\n", dev);
271 if ((STp->mt_status)->mt_fileno >= 0)
272 (STp->mt_status)->mt_fileno += 1;
273 (STp->mt_status)->mt_blkno = 0;
274 }
275
276 return (STp->buffer)->last_result_fatal;
277 }
278
279
280
281 static int
282 flush_write_buffer(int dev)
283 {
284 int offset, transfer, blks;
285 int result;
286 unsigned char cmd[10];
287 Scsi_Cmnd *SCpnt;
288 Scsi_Tape *STp = &(scsi_tapes[dev]);
289
290 if ((STp->buffer)->writing) {
291 write_behind_check(dev);
292 if ((STp->buffer)->last_result_fatal) {
293 #ifdef DEBUG
294 if (debugging)
295 printk("st%d: Async write error (flush) %x.\n", dev,
296 (STp->buffer)->last_result);
297 #endif
298 if ((STp->buffer)->last_result == INT_MAX)
299 return (-ENOSPC);
300 return (-EIO);
301 }
302 }
303
304 result = 0;
305 if (STp->dirty == 1) {
306 SCpnt = allocate_device(NULL, STp->device, 1);
307
308 offset = (STp->buffer)->buffer_bytes;
309 transfer = ((offset + STp->block_size - 1) /
310 STp->block_size) * STp->block_size;
311 #ifdef DEBUG
312 if (debugging)
313 printk("st%d: Flushing %d bytes.\n", dev, transfer);
314 #endif
315 memset((STp->buffer)->b_data + offset, 0, transfer - offset);
316
317 SCpnt->sense_buffer[0] = 0;
318 memset(cmd, 0, 10);
319 cmd[0] = WRITE_6;
320 cmd[1] = 1;
321 blks = transfer / STp->block_size;
322 cmd[2] = blks >> 16;
323 cmd[3] = blks >> 8;
324 cmd[4] = blks;
325 SCpnt->request.dev = dev;
326 scsi_do_cmd (SCpnt,
327 (void *) cmd, (STp->buffer)->b_data, transfer,
328 st_sleep_done, ST_TIMEOUT, MAX_WRITE_RETRIES);
329
330 if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
331
332 if ((STp->buffer)->last_result_fatal != 0) {
333 printk("st%d: Error on flush.\n", dev);
334 if ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
335 (SCpnt->sense_buffer[2] & 0x40) &&
336 (SCpnt->sense_buffer[2] & 0x0f) != VOLUME_OVERFLOW) {
337 STp->dirty = 0;
338 (STp->buffer)->buffer_bytes = 0;
339 result = (-ENOSPC);
340 }
341 else
342 result = (-EIO);
343 STp->drv_block = (-1);
344 }
345 else {
346 if (STp->drv_block >= 0)
347 STp->drv_block += blks;
348 STp->dirty = 0;
349 (STp->buffer)->buffer_bytes = 0;
350 }
351 SCpnt->request.dev = -1;
352 }
353 return result;
354 }
355
356
357
358
359 static int
360 flush_buffer(struct inode * inode, struct file * filp, int seek_next)
361 {
362 int dev;
363 int backspace, result;
364 Scsi_Tape * STp;
365 ST_buffer * STbuffer;
366
367 dev = MINOR(inode->i_rdev) & 127;
368 STp = &(scsi_tapes[dev]);
369 STbuffer = STp->buffer;
370
371 if (STp->ready != ST_READY)
372 return 0;
373
374 if (STp->rw == ST_WRITING)
375 return flush_write_buffer(dev);
376
377 if (STp->block_size == 0)
378 return 0;
379
380 backspace = ((STp->buffer)->buffer_bytes +
381 (STp->buffer)->read_pointer) / STp->block_size -
382 ((STp->buffer)->read_pointer + STp->block_size - 1) /
383 STp->block_size;
384 (STp->buffer)->buffer_bytes = 0;
385 (STp->buffer)->read_pointer = 0;
386 result = 0;
387 if (!seek_next) {
388 if ((STp->eof == ST_FM) && !STp->eof_hit) {
389 result = back_over_eof(dev);
390 if (!result) {
391 STp->eof = ST_NOEOF;
392 STp->eof_hit = 0;
393 }
394 }
395 if (!result && backspace > 0)
396 result = st_int_ioctl(inode, filp, MTBSR, backspace);
397 }
398 return result;
399
400 }
401
402
403
404 static int
405 scsi_tape_open(struct inode * inode, struct file * filp)
406 {
407 int dev;
408 unsigned short flags;
409 int i;
410 unsigned char cmd[10];
411 Scsi_Cmnd * SCpnt;
412 Scsi_Tape * STp;
413
414 dev = MINOR(inode->i_rdev) & 127;
415 if (dev >= st_template.dev_max || !scsi_tapes[dev].device)
416 return (-ENXIO);
417 STp = &(scsi_tapes[dev]);
418 if (STp->in_use) {
419 printk("st%d: Device already in use.\n", dev);
420 return (-EBUSY);
421 }
422
423
424 for (i=0; i < st_nbr_buffers; i++)
425 if (!st_buffers[i]->in_use)
426 break;
427 if (i >= st_nbr_buffers) {
428 printk("st%d: No free buffers.\n", dev);
429 return (-EBUSY);
430 }
431 STp->buffer = st_buffers[i];
432 (STp->buffer)->in_use = 1;
433 (STp->buffer)->writing = 0;
434 STp->in_use = 1;
435
436 flags = filp->f_flags;
437 STp->write_prot = ((flags & O_ACCMODE) == O_RDONLY);
438
439 STp->dirty = 0;
440 STp->rw = ST_IDLE;
441 STp->ready = ST_READY;
442 if (STp->eof != ST_EOD)
443 STp->eof = ST_NOEOF;
444 STp->eof_hit = 0;
445 STp->recover_count = 0;
446
447 SCpnt = allocate_device(NULL, STp->device, 1);
448 if (!SCpnt) {
449 printk("st%d: Tape request not allocated", dev);
450 return (-EBUSY);
451 }
452
453 SCpnt->sense_buffer[0]=0;
454 memset ((void *) &cmd[0], 0, 10);
455 cmd[0] = TEST_UNIT_READY;
456 SCpnt->request.dev = dev;
457 scsi_do_cmd(SCpnt,
458 (void *) cmd, (void *) (STp->buffer)->b_data,
459 0, st_sleep_done, ST_LONG_TIMEOUT,
460 MAX_READY_RETRIES);
461
462 if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
463
464 if ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
465 (SCpnt->sense_buffer[2] & 0x0f) == UNIT_ATTENTION) {
466 (STp->mt_status)->mt_fileno = 0 ;
467 SCpnt->sense_buffer[0]=0;
468 memset ((void *) &cmd[0], 0, 10);
469 cmd[0] = TEST_UNIT_READY;
470 SCpnt->request.dev = dev;
471 scsi_do_cmd(SCpnt,
472 (void *) cmd, (void *) (STp->buffer)->b_data,
473 0, st_sleep_done, ST_LONG_TIMEOUT,
474 MAX_READY_RETRIES);
475
476 if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
477 (STp->mt_status)->mt_fileno = STp->drv_block = 0;
478 STp->eof = ST_NOEOF;
479 }
480
481 if ((STp->buffer)->last_result_fatal != 0) {
482 if ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
483 (SCpnt->sense_buffer[2] & 0x0f) == NO_TAPE) {
484 (STp->mt_status)->mt_fileno = STp->drv_block = 0 ;
485 printk("st%d: No tape.\n", dev);
486 STp->ready = ST_NO_TAPE;
487 } else {
488 (STp->mt_status)->mt_fileno = STp->drv_block = (-1);
489 STp->ready = ST_NOT_READY;
490 }
491 SCpnt->request.dev = -1;
492 (STp->buffer)->in_use = 0;
493 STp->buffer = NULL;
494 STp->density = 0;
495 STp->write_prot = 0;
496 STp->block_size = 0;
497 STp->eof = ST_NOEOF;
498 (STp->mt_status)->mt_fileno = STp->drv_block = 0;
499 if (scsi_tapes[dev].device->host->hostt->usage_count)
500 (*scsi_tapes[dev].device->host->hostt->usage_count)++;
501 return 0;
502 }
503
504 SCpnt->sense_buffer[0]=0;
505 memset ((void *) &cmd[0], 0, 10);
506 cmd[0] = READ_BLOCK_LIMITS;
507 SCpnt->request.dev = dev;
508 scsi_do_cmd(SCpnt,
509 (void *) cmd, (void *) (STp->buffer)->b_data,
510 6, st_sleep_done, ST_TIMEOUT, MAX_READY_RETRIES);
511
512 if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
513
514 if (!SCpnt->result && !SCpnt->sense_buffer[0]) {
515 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
516 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
517 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
518 (STp->buffer)->b_data[5];
519 #ifdef DEBUG
520 if (debugging)
521 printk("st%d: Block limits %d - %d bytes.\n", dev, STp->min_block,
522 STp->max_block);
523 #endif
524 }
525 else {
526 STp->min_block = STp->max_block = (-1);
527 #ifdef DEBUG
528 if (debugging)
529 printk("st%d: Can't read block limits.\n", dev);
530 #endif
531 }
532
533 SCpnt->sense_buffer[0]=0;
534 memset ((void *) &cmd[0], 0, 10);
535 cmd[0] = MODE_SENSE;
536 cmd[4] = 12;
537 SCpnt->request.dev = dev;
538 scsi_do_cmd(SCpnt,
539 (void *) cmd, (void *) (STp->buffer)->b_data,
540 12, st_sleep_done, ST_TIMEOUT, MAX_READY_RETRIES);
541
542 if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
543
544 if ((STp->buffer)->last_result_fatal != 0) {
545 #ifdef DEBUG
546 if (debugging)
547 printk("st%d: No Mode Sense.\n", dev);
548 #endif
549 (STp->buffer)->b_data[2] =
550 (STp->buffer)->b_data[3] = 0;
551 }
552 SCpnt->request.dev = -1;
553
554 #ifdef DEBUG
555 if (debugging)
556 printk("st%d: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n", dev,
557 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
558 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]);
559 #endif
560
561 if ((STp->buffer)->b_data[3] >= 8) {
562 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
563 STp->density = (STp->buffer)->b_data[4];
564 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
565 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
566 #ifdef DEBUG
567 if (debugging)
568 printk("st%d: Density %x, tape length: %x, drv buffer: %d\n",
569 dev, STp->density, (STp->buffer)->b_data[5] * 65536 +
570 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
571 STp->drv_buffer);
572 #endif
573 if (STp->block_size > st_buffer_size) {
574 printk("st%d: Blocksize %d too large for buffer.\n", dev,
575 STp->block_size);
576 (STp->buffer)->in_use = 0;
577 STp->in_use = 0;
578 return (-EIO);
579 }
580
581 }
582 else
583 STp->block_size = 512;
584
585 if (STp->block_size > 0) {
586 (STp->buffer)->buffer_blocks = st_buffer_size / STp->block_size;
587 (STp->buffer)->buffer_size =
588 (STp->buffer)->buffer_blocks * STp->block_size;
589 }
590 else {
591 (STp->buffer)->buffer_blocks = 1;
592 (STp->buffer)->buffer_size = st_buffer_size;
593 }
594 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
595
596 #ifdef DEBUG
597 if (debugging)
598 printk("st%d: Block size: %d, buffer size: %d (%d blocks).\n", dev,
599 STp->block_size, (STp->buffer)->buffer_size,
600 (STp->buffer)->buffer_blocks);
601 #endif
602
603 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
604 if (STp->drv_write_prot) {
605 STp->write_prot = 1;
606 #ifdef DEBUG
607 if (debugging)
608 printk( "st%d: Write protected\n", dev);
609 #endif
610 }
611
612 if (scsi_tapes[dev].device->host->hostt->usage_count)
613 (*scsi_tapes[dev].device->host->hostt->usage_count)++;
614
615 return 0;
616 }
617
618
619
620 static void
621 scsi_tape_close(struct inode * inode, struct file * filp)
622 {
623 int dev;
624 int result;
625 int rewind;
626 static unsigned char cmd[10];
627 Scsi_Cmnd * SCpnt;
628 Scsi_Tape * STp;
629
630 dev = MINOR(inode->i_rdev);
631 rewind = (dev & 0x80) == 0;
632 dev = dev & 127;
633 STp = &(scsi_tapes[dev]);
634
635 if ( STp->rw == ST_WRITING) {
636
637 result = flush_write_buffer(dev);
638
639 #ifdef DEBUG
640 if (debugging)
641 printk("st%d: File length %ld bytes.\n", dev, (long)(filp->f_pos));
642 #endif
643
644 if (result == 0 || result == (-ENOSPC)) {
645 SCpnt = allocate_device(NULL, STp->device, 1);
646
647 SCpnt->sense_buffer[0] = 0;
648 memset(cmd, 0, 10);
649 cmd[0] = WRITE_FILEMARKS;
650 cmd[4] = 1 + STp->two_fm;
651 SCpnt->request.dev = dev;
652 scsi_do_cmd( SCpnt,
653 (void *) cmd, (void *) (STp->buffer)->b_data,
654 0, st_sleep_done, ST_TIMEOUT, MAX_WRITE_RETRIES);
655
656 if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
657
658 if ((STp->buffer)->last_result_fatal != 0) {
659 SCpnt->request.dev = -1;
660 printk("st%d: Error on write filemark.\n", dev);
661 }
662 else {
663 SCpnt->request.dev = -1;
664 if ((STp->mt_status)->mt_fileno >= 0)
665 (STp->mt_status)->mt_fileno++ ;
666 STp->drv_block = 0;
667 if (STp->two_fm)
668 back_over_eof(dev);
669 }
670
671 }
672
673 #ifdef DEBUG
674 if (debugging)
675 printk("st%d: Buffer flushed, %d EOF(s) written\n", dev, cmd[4]);
676 #endif
677 }
678 else if (!rewind) {
679 #ifndef ST_IN_FILE_POS
680 if ((STp->eof == ST_FM) && !STp->eof_hit)
681 back_over_eof(dev);
682 #else
683 flush_buffer(inode, filp, 0);
684 #endif
685 }
686
687 if (rewind)
688 st_int_ioctl(inode, filp, MTREW, 1);
689
690 if (STp->buffer != NULL)
691 (STp->buffer)->in_use = 0;
692 STp->in_use = 0;
693
694 if (scsi_tapes[dev].device->host->hostt->usage_count)
695 (*scsi_tapes[dev].device->host->hostt->usage_count)--;
696
697 return;
698 }
699
700
701
702 static int
703 st_write(struct inode * inode, struct file * filp, char * buf, int count)
704 {
705 int dev;
706 int total, do_count, blks, retval, transfer;
707 int write_threshold;
708 int doing_write = 0;
709 static unsigned char cmd[10];
710 char *b_point;
711 Scsi_Cmnd * SCpnt;
712 Scsi_Tape * STp;
713
714 dev = MINOR(inode->i_rdev) & 127;
715 STp = &(scsi_tapes[dev]);
716 if (STp->ready != ST_READY)
717 return (-EIO);
718 #ifdef DEBUG
719 if (!STp->in_use) {
720 printk("st%d: Incorrect device.\n", dev);
721 return (-EIO);
722 }
723 #endif
724
725 if (STp->write_prot)
726 return (-EACCES);
727
728 if (STp->block_size == 0 && count > st_buffer_size)
729 return (-EOVERFLOW);
730
731 if (STp->rw == ST_READING) {
732 retval = flush_buffer(inode, filp, 0);
733 if (retval)
734 return retval;
735 STp->rw = ST_WRITING;
736 }
737
738 if (STp->moves_after_eof < 255)
739 STp->moves_after_eof++;
740
741 if ((STp->buffer)->writing) {
742 write_behind_check(dev);
743 if ((STp->buffer)->last_result_fatal) {
744 #ifdef DEBUG
745 if (debugging)
746 printk("st%d: Async write error (write) %x.\n", dev,
747 (STp->buffer)->last_result);
748 #endif
749 if ((STp->buffer)->last_result == INT_MAX) {
750 retval = (-ENOSPC);
751 STp->eof = ST_EOM_OK;
752 }
753 else
754 retval = (-EIO);
755 return retval;
756 }
757 }
758
759 if (STp->eof == ST_EOM_OK)
760 return (-ENOSPC);
761 else if (STp->eof == ST_EOM_ERROR)
762 return (-EIO);
763
764 if (!STp->do_buffer_writes) {
765 if (STp->block_size != 0 && (count % STp->block_size) != 0)
766 return (-EIO);
767 write_threshold = 1;
768 }
769 else
770 write_threshold = (STp->buffer)->buffer_size;
771 if (!STp->do_async_writes)
772 write_threshold--;
773
774 SCpnt = allocate_device(NULL, STp->device, 1);
775
776 total = count;
777
778 memset(cmd, 0, 10);
779 cmd[0] = WRITE_6;
780 cmd[1] = (STp->block_size != 0);
781
782 STp->rw = ST_WRITING;
783
784 b_point = buf;
785 while((STp->block_size == 0 && !STp->do_async_writes && count > 0) ||
786 (STp->block_size != 0 &&
787 (STp->buffer)->buffer_bytes + count > write_threshold))
788 {
789 doing_write = 1;
790 if (STp->block_size == 0)
791 do_count = count;
792 else {
793 do_count = (STp->buffer)->buffer_size - (STp->buffer)->buffer_bytes;
794 if (do_count > count)
795 do_count = count;
796 }
797 memcpy_fromfs((STp->buffer)->b_data +
798 (STp->buffer)->buffer_bytes, b_point, do_count);
799
800 if (STp->block_size == 0)
801 blks = transfer = do_count;
802 else {
803 blks = ((STp->buffer)->buffer_bytes + do_count) /
804 STp->block_size;
805 transfer = blks * STp->block_size;
806 }
807 cmd[2] = blks >> 16;
808 cmd[3] = blks >> 8;
809 cmd[4] = blks;
810 SCpnt->sense_buffer[0] = 0;
811 SCpnt->request.dev = dev;
812 scsi_do_cmd (SCpnt,
813 (void *) cmd, (STp->buffer)->b_data, transfer,
814 st_sleep_done, ST_TIMEOUT, MAX_WRITE_RETRIES);
815
816 if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
817
818 if ((STp->buffer)->last_result_fatal != 0) {
819 #ifdef DEBUG
820 if (debugging)
821 printk("st%d: Error on write:\n", dev);
822 #endif
823 if ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
824 (SCpnt->sense_buffer[2] & 0x40)) {
825 if (STp->block_size != 0 && (SCpnt->sense_buffer[0] & 0x80) != 0)
826 transfer = (SCpnt->sense_buffer[3] << 24) |
827 (SCpnt->sense_buffer[4] << 16) |
828 (SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
829 else if (STp->block_size == 0 &&
830 (SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW)
831 transfer = do_count;
832 else
833 transfer = 0;
834 if (STp->block_size != 0)
835 transfer *= STp->block_size;
836 if (transfer <= do_count) {
837 filp->f_pos += do_count - transfer;
838 count -= do_count - transfer;
839 if (STp->drv_block >= 0) {
840 if (STp->block_size == 0 && transfer < do_count)
841 STp->drv_block++;
842 else if (STp->block_size != 0)
843 STp->drv_block += (do_count - transfer) / STp->block_size;
844 }
845 STp->eof = ST_EOM_OK;
846 retval = (-ENOSPC);
847 #ifdef DEBUG
848 if (debugging)
849 printk("st%d: EOM with %d bytes unwritten.\n",
850 dev, transfer);
851 #endif
852 }
853 else {
854 STp->eof = ST_EOM_ERROR;
855 STp->drv_block = (-1);
856 retval = (-EIO);
857 #ifdef DEBUG
858 if (debugging)
859 printk("st%d: EOM with lost data.\n", dev);
860 #endif
861 }
862 }
863 else {
864 STp->drv_block = (-1);
865 retval = (-EIO);
866 }
867
868 SCpnt->request.dev = -1;
869 (STp->buffer)->buffer_bytes = 0;
870 STp->dirty = 0;
871 if (count < total)
872 return total - count;
873 else
874 return retval;
875 }
876 filp->f_pos += do_count;
877 b_point += do_count;
878 count -= do_count;
879 if (STp->drv_block >= 0) {
880 if (STp->block_size == 0)
881 STp->drv_block++;
882 else
883 STp->drv_block += blks;
884 }
885 (STp->buffer)->buffer_bytes = 0;
886 STp->dirty = 0;
887 }
888 if (count != 0) {
889 STp->dirty = 1;
890 memcpy_fromfs((STp->buffer)->b_data +
891 (STp->buffer)->buffer_bytes,b_point,count);
892 filp->f_pos += count;
893 (STp->buffer)->buffer_bytes += count;
894 count = 0;
895 }
896
897 if (doing_write && (STp->buffer)->last_result_fatal != 0) {
898 SCpnt->request.dev = -1;
899 return (STp->buffer)->last_result_fatal;
900 }
901
902 if (STp->do_async_writes &&
903 ((STp->buffer)->buffer_bytes >= STp->write_threshold ||
904 STp->block_size == 0) ) {
905
906 if (STp->block_size == 0)
907 (STp->buffer)->writing = (STp->buffer)->buffer_bytes;
908 else
909 (STp->buffer)->writing = ((STp->buffer)->buffer_bytes /
910 STp->block_size) * STp->block_size;
911 STp->dirty = !((STp->buffer)->writing ==
912 (STp->buffer)->buffer_bytes);
913
914 if (STp->block_size == 0)
915 blks = (STp->buffer)->writing;
916 else
917 blks = (STp->buffer)->writing / STp->block_size;
918 cmd[2] = blks >> 16;
919 cmd[3] = blks >> 8;
920 cmd[4] = blks;
921 SCpnt->result = (STp->buffer)->last_result = -1;
922 SCpnt->sense_buffer[0] = 0;
923 SCpnt->request.dev = dev;
924 scsi_do_cmd (SCpnt,
925 (void *) cmd, (STp->buffer)->b_data,
926 (STp->buffer)->writing,
927 st_sleep_done, ST_TIMEOUT, MAX_WRITE_RETRIES);
928 }
929 else
930 SCpnt->request.dev = -1;
931
932 STp->at_sm &= (total != 0);
933 return( total);
934 }
935
936
937
938 static int
939 st_read(struct inode * inode, struct file * filp, char * buf, int count)
940 {
941 int dev;
942 int total;
943 int transfer, blks, bytes;
944 static unsigned char cmd[10];
945 Scsi_Cmnd * SCpnt;
946 Scsi_Tape * STp;
947
948 dev = MINOR(inode->i_rdev) & 127;
949 STp = &(scsi_tapes[dev]);
950 if (STp->ready != ST_READY)
951 return (-EIO);
952 #ifdef DEBUG
953 if (!STp->in_use) {
954 printk("st%d: Incorrect device.\n", dev);
955 return (-EIO);
956 }
957 #endif
958
959 if (STp->block_size == 0 && count > st_buffer_size)
960 return (-EOVERFLOW);
961
962 if (!(STp->do_read_ahead) && STp->block_size != 0 &&
963 (count % STp->block_size) != 0)
964 return (-EIO);
965
966 if (STp->rw == ST_WRITING) {
967 transfer = flush_buffer(inode, filp, 0);
968 if (transfer)
969 return transfer;
970 STp->rw = ST_READING;
971 }
972 if (STp->moves_after_eof < 255)
973 STp->moves_after_eof++;
974
975 #ifdef DEBUG
976 if (debugging && STp->eof != ST_NOEOF)
977 printk("st%d: EOF flag up. Bytes %d\n", dev,
978 (STp->buffer)->buffer_bytes);
979 #endif
980 if (((STp->buffer)->buffer_bytes == 0) &&
981 (STp->eof == ST_EOM_OK || STp->eof == ST_EOD))
982 return (-EIO);
983
984 STp->rw = ST_READING;
985
986 SCpnt = allocate_device(NULL, STp->device, 1);
987
988 for (total = 0; total < count; ) {
989
990 if ((STp->buffer)->buffer_bytes == 0 &&
991 STp->eof == ST_NOEOF) {
992
993 memset(cmd, 0, 10);
994 cmd[0] = READ_6;
995 cmd[1] = (STp->block_size != 0);
996 if (STp->block_size == 0)
997 blks = bytes = count;
998 else {
999 if (STp->do_read_ahead) {
1000 blks = (STp->buffer)->buffer_blocks;
1001 bytes = blks * STp->block_size;
1002 }
1003 else {
1004 bytes = count;
1005 if (bytes > st_buffer_size)
1006 bytes = st_buffer_size;
1007 blks = bytes / STp->block_size;
1008 bytes = blks * STp->block_size;
1009 }
1010 }
1011 cmd[2] = blks >> 16;
1012 cmd[3] = blks >> 8;
1013 cmd[4] = blks;
1014
1015 SCpnt->sense_buffer[0] = 0;
1016 SCpnt->request.dev = dev;
1017 scsi_do_cmd (SCpnt,
1018 (void *) cmd, (STp->buffer)->b_data,
1019 (STp->buffer)->buffer_size,
1020 st_sleep_done, ST_TIMEOUT, MAX_RETRIES);
1021
1022 if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
1023
1024 (STp->buffer)->read_pointer = 0;
1025 STp->eof_hit = 0;
1026 STp->at_sm = 0;
1027
1028 if ((STp->buffer)->last_result_fatal) {
1029 #ifdef DEBUG
1030 if (debugging)
1031 printk("st%d: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n", dev,
1032 SCpnt->sense_buffer[0], SCpnt->sense_buffer[1],
1033 SCpnt->sense_buffer[2], SCpnt->sense_buffer[3],
1034 SCpnt->sense_buffer[4], SCpnt->sense_buffer[5],
1035 SCpnt->sense_buffer[6], SCpnt->sense_buffer[7]);
1036 #endif
1037 if ((SCpnt->sense_buffer[0] & 0x70) == 0x70) {
1038
1039 if ((SCpnt->sense_buffer[2] & 0xe0) != 0) {
1040
1041 if ((SCpnt->sense_buffer[0] & 0x80) != 0)
1042 transfer = (SCpnt->sense_buffer[3] << 24) |
1043 (SCpnt->sense_buffer[4] << 16) |
1044 (SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
1045 else
1046 transfer = 0;
1047 if (STp->block_size == 0 &&
1048 (SCpnt->sense_buffer[2] & 0x0f) == MEDIUM_ERROR)
1049 transfer = bytes;
1050
1051 if (SCpnt->sense_buffer[2] & 0x20) {
1052 if (STp->block_size == 0) {
1053 if (transfer <= 0)
1054 transfer = 0;
1055 (STp->buffer)->buffer_bytes = bytes - transfer;
1056 }
1057 else {
1058 printk("st%d: Incorrect block size.\n", dev);
1059 SCpnt->request.dev = -1;
1060 return (-EIO);
1061 }
1062 }
1063 else if (SCpnt->sense_buffer[2] & 0x40) {
1064 STp->eof = ST_EOM_OK;
1065 if (STp->block_size == 0)
1066 (STp->buffer)->buffer_bytes = bytes - transfer;
1067 else
1068 (STp->buffer)->buffer_bytes =
1069 bytes - transfer * STp->block_size;
1070 #ifdef DEBUG
1071 if (debugging)
1072 printk("st%d: EOM detected (%d bytes read).\n", dev,
1073 (STp->buffer)->buffer_bytes);
1074 #endif
1075 }
1076 else if (SCpnt->sense_buffer[2] & 0x80) {
1077 STp->eof = ST_FM;
1078 if (STp->block_size == 0)
1079 (STp->buffer)->buffer_bytes = 0;
1080 else
1081 (STp->buffer)->buffer_bytes =
1082 bytes - transfer * STp->block_size;
1083 #ifdef DEBUG
1084 if (debugging)
1085 printk(
1086 "st%d: EOF detected (%d bytes read, transferred %d bytes).\n",
1087 dev, (STp->buffer)->buffer_bytes, total);
1088 #endif
1089 }
1090 }
1091 else {
1092 #ifdef DEBUG
1093 if (debugging)
1094 printk("st%d: Tape error while reading.\n", dev);
1095 #endif
1096 SCpnt->request.dev = -1;
1097 STp->drv_block = (-1);
1098 if (total)
1099 return total;
1100 else if (STp->moves_after_eof == 1 &&
1101 (SCpnt->sense_buffer[2] & 0x0f) == BLANK_CHECK) {
1102 #ifdef DEBUG
1103 if (debugging)
1104 printk("st%d: Zero returned for first BLANK CHECK after EOF.\n",
1105 dev);
1106 #endif
1107 STp->eof = ST_EOD;
1108 return 0;
1109 }
1110 else
1111 return -EIO;
1112 }
1113 }
1114 else {
1115 transfer = (STp->buffer)->last_result_fatal;
1116 SCpnt->request.dev = -1;
1117 return transfer;
1118 }
1119 }
1120 else
1121 (STp->buffer)->buffer_bytes = bytes;
1122
1123 if (STp->drv_block >= 0) {
1124 if (STp->block_size == 0)
1125 STp->drv_block++;
1126 else
1127 STp->drv_block += (STp->buffer)->buffer_bytes / STp->block_size;
1128 }
1129
1130 }
1131
1132
1133 if ((STp->buffer)->buffer_bytes > 0) {
1134 #ifdef DEBUG
1135 if (debugging && STp->eof != ST_NOEOF)
1136 printk("st%d: EOF up. Left %d, needed %d.\n", dev,
1137 (STp->buffer)->buffer_bytes, count - total);
1138 #endif
1139 transfer = (STp->buffer)->buffer_bytes < count - total ?
1140 (STp->buffer)->buffer_bytes : count - total;
1141 memcpy_tofs(buf, (STp->buffer)->b_data +
1142 (STp->buffer)->read_pointer,transfer);
1143 filp->f_pos += transfer;
1144 buf += transfer;
1145 total += transfer;
1146 (STp->buffer)->buffer_bytes -= transfer;
1147 (STp->buffer)->read_pointer += transfer;
1148 }
1149 else if (STp->eof != ST_NOEOF) {
1150 STp->eof_hit = 1;
1151 SCpnt->request.dev = -1;
1152 if (total == 0 && STp->eof == ST_FM) {
1153 STp->eof = ST_NOEOF;
1154 STp->drv_block = 0;
1155 if (STp->moves_after_eof > 1)
1156 STp->moves_after_eof = 0;
1157 if ((STp->mt_status)->mt_fileno >= 0)
1158 (STp->mt_status)->mt_fileno++;
1159 }
1160 if (total == 0 && STp->eof == ST_EOM_OK)
1161 return (-EIO);
1162 return total;
1163 }
1164
1165 if (STp->block_size == 0)
1166 count = total;
1167
1168 }
1169
1170 SCpnt->request.dev = -1;
1171
1172 return total;
1173 }
1174
1175
1176
1177
1178 static int
1179 st_set_options(struct inode * inode, long options)
1180 {
1181 int dev, value;
1182 Scsi_Tape *STp;
1183
1184 dev = MINOR(inode->i_rdev) & 127;
1185 STp = &(scsi_tapes[dev]);
1186 if ((options & MT_ST_OPTIONS) == MT_ST_BOOLEANS) {
1187 STp->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
1188 STp->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
1189 STp->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
1190 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
1191 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
1192 #ifdef DEBUG
1193 debugging = (options & MT_ST_DEBUGGING) != 0;
1194 printk(
1195 "st%d: options: buffer writes: %d, async writes: %d, read ahead: %d\n",
1196 dev, STp->do_buffer_writes, STp->do_async_writes,
1197 STp->do_read_ahead);
1198 printk(" two FMs: %d, fast mteom: %d debugging: %d\n",
1199 STp->two_fm, STp->fast_mteom, debugging);
1200 #endif
1201 }
1202 else if ((options & MT_ST_OPTIONS) == MT_ST_WRITE_THRESHOLD) {
1203 value = (options & ~MT_ST_OPTIONS) * ST_BLOCK_SIZE;
1204 if (value < 1 || value > st_buffer_size) {
1205 printk("st: Write threshold %d too small or too large.\n",
1206 value);
1207 return (-EIO);
1208 }
1209 STp->write_threshold = value;
1210 #ifdef DEBUG
1211 printk("st%d: Write threshold set to %d bytes.\n", dev,
1212 STp->write_threshold);
1213 #endif
1214 }
1215 else
1216 return (-EIO);
1217
1218 return 0;
1219 }
1220
1221
1222
1223 static int
1224 st_int_ioctl(struct inode * inode,struct file * file,
1225 unsigned int cmd_in, unsigned long arg)
1226 {
1227 int dev = MINOR(inode->i_rdev);
1228 int timeout = ST_LONG_TIMEOUT;
1229 long ltmp;
1230 int ioctl_result;
1231 unsigned char cmd[10];
1232 Scsi_Cmnd * SCpnt;
1233 Scsi_Tape * STp;
1234 int fileno, blkno, at_sm, undone, datalen;
1235
1236 dev = dev & 127;
1237 STp = &(scsi_tapes[dev]);
1238 if (STp->ready != ST_READY)
1239 return (-EIO);
1240 fileno = (STp->mt_status)->mt_fileno ;
1241 blkno = STp->drv_block;
1242 at_sm = STp->at_sm;
1243
1244 memset(cmd, 0, 10);
1245 datalen = 0;
1246 switch (cmd_in) {
1247 case MTFSF:
1248 case MTFSFM:
1249 cmd[0] = SPACE;
1250 cmd[1] = 0x01;
1251 cmd[2] = (arg >> 16);
1252 cmd[3] = (arg >> 8);
1253 cmd[4] = arg;
1254 #ifdef DEBUG
1255 if (debugging)
1256 printk("st%d: Spacing tape forward over %d filemarks.\n", dev,
1257 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
1258 #endif
1259 if (fileno >= 0)
1260 fileno += arg;
1261 blkno = 0;
1262 at_sm &= (arg != 0);
1263 break;
1264 case MTBSF:
1265 case MTBSFM:
1266 cmd[0] = SPACE;
1267 cmd[1] = 0x01;
1268 ltmp = (-arg);
1269 cmd[2] = (ltmp >> 16);
1270 cmd[3] = (ltmp >> 8);
1271 cmd[4] = ltmp;
1272 #ifdef DEBUG
1273 if (debugging) {
1274 if (cmd[2] & 0x80)
1275 ltmp = 0xff000000;
1276 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
1277 printk("st%d: Spacing tape backward over %ld filemarks.\n", dev, (-ltmp));
1278 }
1279 #endif
1280 if (fileno >= 0)
1281 fileno -= arg;
1282 blkno = (-1);
1283 at_sm &= (arg != 0);
1284 break;
1285 case MTFSR:
1286 cmd[0] = SPACE;
1287 cmd[1] = 0x00;
1288 cmd[2] = (arg >> 16);
1289 cmd[3] = (arg >> 8);
1290 cmd[4] = arg;
1291 #ifdef DEBUG
1292 if (debugging)
1293 printk("st%d: Spacing tape forward %d blocks.\n", dev,
1294 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
1295 #endif
1296 if (blkno >= 0)
1297 blkno += arg;
1298 at_sm &= (arg != 0);
1299 break;
1300 case MTBSR:
1301 cmd[0] = SPACE;
1302 cmd[1] = 0x00;
1303 ltmp = (-arg);
1304 cmd[2] = (ltmp >> 16);
1305 cmd[3] = (ltmp >> 8);
1306 cmd[4] = ltmp;
1307 #ifdef DEBUG
1308 if (debugging) {
1309 if (cmd[2] & 0x80)
1310 ltmp = 0xff000000;
1311 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
1312 printk("st%d: Spacing tape backward %ld blocks.\n", dev, (-ltmp));
1313 }
1314 #endif
1315 if (blkno >= 0)
1316 blkno -= arg;
1317 at_sm &= (arg != 0);
1318 break;
1319 case MTFSS:
1320 cmd[0] = SPACE;
1321 cmd[1] = 0x04;
1322 cmd[2] = (arg >> 16);
1323 cmd[3] = (arg >> 8);
1324 cmd[4] = arg;
1325 #ifdef DEBUG
1326 if (debugging)
1327 printk("st%d: Spacing tape forward %d setmarks.\n", dev,
1328 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
1329 #endif
1330 if (arg != 0) {
1331 blkno = fileno = (-1);
1332 at_sm = 1;
1333 }
1334 break;
1335 case MTBSS:
1336 cmd[0] = SPACE;
1337 cmd[1] = 0x04;
1338 ltmp = (-arg);
1339 cmd[2] = (ltmp >> 16);
1340 cmd[3] = (ltmp >> 8);
1341 cmd[4] = ltmp;
1342 #ifdef DEBUG
1343 if (debugging) {
1344 if (cmd[2] & 0x80)
1345 ltmp = 0xff000000;
1346 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
1347 printk("st%d: Spacing tape backward %ld setmarks.\n", dev, (-ltmp));
1348 }
1349 #endif
1350 if (arg != 0) {
1351 blkno = fileno = (-1);
1352 at_sm = 1;
1353 }
1354 break;
1355 case MTWEOF:
1356 case MTWSM:
1357 if (STp->write_prot)
1358 return (-EACCES);
1359 cmd[0] = WRITE_FILEMARKS;
1360 if (cmd_in == MTWSM)
1361 cmd[1] = 2;
1362 cmd[2] = (arg >> 16);
1363 cmd[3] = (arg >> 8);
1364 cmd[4] = arg;
1365 timeout = ST_TIMEOUT;
1366 #ifdef DEBUG
1367 if (debugging) {
1368 if (cmd_in == MTWEOF)
1369 printk("st%d: Writing %d filemarks.\n", dev,
1370 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
1371 else
1372 printk("st%d: Writing %d setmarks.\n", dev,
1373 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
1374 }
1375 #endif
1376 if (fileno >= 0)
1377 fileno += arg;
1378 blkno = 0;
1379 at_sm = (cmd_in == MTWSM);
1380 break;
1381 case MTREW:
1382 cmd[0] = REZERO_UNIT;
1383 #ifdef ST_NOWAIT
1384 cmd[1] = 1;
1385 timeout = ST_TIMEOUT;
1386 #endif
1387 #ifdef DEBUG
1388 if (debugging)
1389 printk("st%d: Rewinding tape.\n", dev);
1390 #endif
1391 fileno = blkno = at_sm = 0 ;
1392 break;
1393 case MTOFFL:
1394 cmd[0] = START_STOP;
1395 #ifdef ST_NOWAIT
1396 cmd[1] = 1;
1397 timeout = ST_TIMEOUT;
1398 #endif
1399 #ifdef DEBUG
1400 if (debugging)
1401 printk("st%d: Unloading tape.\n", dev);
1402 #endif
1403 fileno = blkno = at_sm = 0 ;
1404 break;
1405 case MTNOP:
1406 #ifdef DEBUG
1407 if (debugging)
1408 printk("st%d: No op on tape.\n", dev);
1409 #endif
1410 return 0;
1411 break;
1412 case MTRETEN:
1413 cmd[0] = START_STOP;
1414 #ifdef ST_NOWAIT
1415 cmd[1] = 1;
1416 timeout = ST_TIMEOUT;
1417 #endif
1418 cmd[4] = 3;
1419 #ifdef DEBUG
1420 if (debugging)
1421 printk("st%d: Retensioning tape.\n", dev);
1422 #endif
1423 fileno = blkno = at_sm = 0;
1424 break;
1425 case MTEOM:
1426 if (!STp->fast_mteom) {
1427
1428 ioctl_result = st_int_ioctl(inode, file, MTFSF, 0x3fff);
1429 fileno = (STp->mt_status)->mt_fileno ;
1430 if (STp->eof == ST_EOD || STp->eof == ST_EOM_OK)
1431 return 0;
1432
1433
1434
1435
1436 }
1437 else
1438 fileno = (-1);
1439 cmd[0] = SPACE;
1440 cmd[1] = 3;
1441 #ifdef DEBUG
1442 if (debugging)
1443 printk("st%d: Spacing to end of recorded medium.\n", dev);
1444 #endif
1445 blkno = 0;
1446 at_sm = 0;
1447 break;
1448 case MTERASE:
1449 if (STp->write_prot)
1450 return (-EACCES);
1451 cmd[0] = ERASE;
1452 cmd[1] = 1;
1453 #ifdef ST_NOWAIT
1454 cmd[1] |= 2;
1455 timeout = ST_TIMEOUT;
1456 #else
1457 timeout = ST_LONG_TIMEOUT * 8;
1458 #endif
1459 #ifdef DEBUG
1460 if (debugging)
1461 printk("st%d: Erasing tape.\n", dev);
1462 #endif
1463 fileno = blkno = at_sm = 0 ;
1464 break;
1465 case MTSEEK:
1466 if ((STp->device)->scsi_level < SCSI_2) {
1467 cmd[0] = QFA_SEEK_BLOCK;
1468 cmd[2] = (arg >> 16);
1469 cmd[3] = (arg >> 8);
1470 cmd[4] = arg;
1471 cmd[5] = 0;
1472 }
1473 else {
1474 cmd[0] = SEEK_10;
1475 cmd[1] = 4;
1476 cmd[3] = (arg >> 24);
1477 cmd[4] = (arg >> 16);
1478 cmd[5] = (arg >> 8);
1479 cmd[6] = arg;
1480 }
1481 #ifdef ST_NOWAIT
1482 cmd[1] |= 1;
1483 timeout = ST_TIMEOUT;
1484 #endif
1485 #ifdef DEBUG
1486 if (debugging)
1487 printk("st%d: Seeking tape to block %ld.\n", dev, arg);
1488 #endif
1489 fileno = blkno = (-1);
1490 at_sm = 0;
1491 break;
1492 case MTSETBLK:
1493 case MTSETDENSITY:
1494 case MTSETDRVBUFFER:
1495 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
1496 return (-EIO);
1497 if (cmd_in == MTSETBLK &&
1498 arg != 0 &&
1499 (arg < STp->min_block || arg > STp->max_block ||
1500 arg > st_buffer_size)) {
1501 printk("st%d: Illegal block size.\n", dev);
1502 return (-EINVAL);
1503 }
1504 cmd[0] = MODE_SELECT;
1505 cmd[4] = datalen = 12;
1506
1507 memset((STp->buffer)->b_data, 0, 12);
1508 if (cmd_in == MTSETDRVBUFFER)
1509 (STp->buffer)->b_data[2] = (arg & 7) << 4;
1510 else
1511 (STp->buffer)->b_data[2] =
1512 STp->drv_buffer << 4;
1513 (STp->buffer)->b_data[3] = 8;
1514 if (cmd_in == MTSETDENSITY)
1515 (STp->buffer)->b_data[4] = arg;
1516 else
1517 (STp->buffer)->b_data[4] = STp->density;
1518 if (cmd_in == MTSETBLK)
1519 ltmp = arg;
1520 else
1521 ltmp = STp->block_size;
1522 (STp->buffer)->b_data[9] = (ltmp >> 16);
1523 (STp->buffer)->b_data[10] = (ltmp >> 8);
1524 (STp->buffer)->b_data[11] = ltmp;
1525 timeout = ST_TIMEOUT;
1526 #ifdef DEBUG
1527 if (debugging) {
1528 if (cmd_in == MTSETBLK)
1529 printk("st%d: Setting block size to %d bytes.\n", dev,
1530 (STp->buffer)->b_data[9] * 65536 +
1531 (STp->buffer)->b_data[10] * 256 +
1532 (STp->buffer)->b_data[11]);
1533 else if (cmd_in == MTSETDENSITY)
1534 printk("st%d: Setting density code to %x.\n", dev,
1535 (STp->buffer)->b_data[4]);
1536 else
1537 printk("st%d: Setting drive buffer code to %d.\n", dev,
1538 ((STp->buffer)->b_data[2] >> 4) & 7);
1539 }
1540 #endif
1541 break;
1542 default:
1543 printk("st%d: Unknown st_ioctl command %x.\n", dev, cmd_in);
1544 return (-ENOSYS);
1545 }
1546
1547 SCpnt = allocate_device(NULL, STp->device, 1);
1548 SCpnt->sense_buffer[0] = 0;
1549 SCpnt->request.dev = dev;
1550 scsi_do_cmd(SCpnt,
1551 (void *) cmd, (void *) (STp->buffer)->b_data, datalen,
1552 st_sleep_done, timeout, MAX_RETRIES);
1553
1554 if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
1555
1556 ioctl_result = (STp->buffer)->last_result_fatal;
1557
1558 SCpnt->request.dev = -1;
1559
1560 if (cmd_in == MTFSF)
1561 STp->moves_after_eof = 0;
1562 else
1563 STp->moves_after_eof = 1;
1564 if (!ioctl_result) {
1565 if (cmd_in != MTSEEK) {
1566 STp->drv_block = blkno;
1567 (STp->mt_status)->mt_fileno = fileno;
1568 STp->at_sm = at_sm;
1569 }
1570 else {
1571 STp->drv_block = (STp->mt_status)->mt_fileno = (-1);
1572 STp->at_sm = 0;
1573 }
1574 if (cmd_in == MTBSFM)
1575 ioctl_result = st_int_ioctl(inode, file, MTFSF, 1);
1576 else if (cmd_in == MTFSFM)
1577 ioctl_result = st_int_ioctl(inode, file, MTBSF, 1);
1578 else if (cmd_in == MTSETBLK) {
1579 STp->block_size = arg;
1580 if (arg != 0) {
1581 (STp->buffer)->buffer_blocks =
1582 st_buffer_size / STp->block_size;
1583 (STp->buffer)->buffer_size =
1584 (STp->buffer)->buffer_blocks * STp->block_size;
1585 }
1586 else {
1587 (STp->buffer)->buffer_blocks = 1;
1588 (STp->buffer)->buffer_size = st_buffer_size;
1589 }
1590 (STp->buffer)->buffer_bytes =
1591 (STp->buffer)->read_pointer = 0;
1592 }
1593 else if (cmd_in == MTSETDRVBUFFER)
1594 STp->drv_buffer = (arg & 7);
1595 else if (cmd_in == MTSETDENSITY)
1596 STp->density = arg;
1597 else if (cmd_in == MTEOM) {
1598 STp->eof = ST_EOD;
1599 STp->eof_hit = 0;
1600 }
1601 else if (cmd_in != MTSETBLK && cmd_in != MTNOP) {
1602 STp->eof = ST_NOEOF;
1603 STp->eof_hit = 0;
1604 }
1605 } else {
1606 if (SCpnt->sense_buffer[2] & 0x40) {
1607 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
1608 cmd_in != MTBSR && cmd_in != MTBSS)
1609 STp->eof = ST_EOM_OK;
1610 STp->eof_hit = 0;
1611 STp->drv_block = 0;
1612 }
1613 undone = (
1614 (SCpnt->sense_buffer[3] << 24) +
1615 (SCpnt->sense_buffer[4] << 16) +
1616 (SCpnt->sense_buffer[5] << 8) +
1617 SCpnt->sense_buffer[6] );
1618 if ( (cmd_in == MTFSF) || (cmd_in == MTFSFM) ) {
1619 if (fileno >= 0)
1620 (STp->mt_status)->mt_fileno = fileno - undone ;
1621 else
1622 (STp->mt_status)->mt_fileno = fileno;
1623 STp->drv_block = 0;
1624 }
1625 else if ( (cmd_in == MTBSF) || (cmd_in == MTBSFM) ) {
1626 (STp->mt_status)->mt_fileno = fileno + undone ;
1627 STp->drv_block = 0;
1628 }
1629 else if (cmd_in == MTFSR) {
1630 if (SCpnt->sense_buffer[2] & 0x80) {
1631 (STp->mt_status)->mt_fileno++;
1632 STp->drv_block = 0;
1633 }
1634 else {
1635 if (blkno >= undone)
1636 STp->drv_block = blkno - undone;
1637 else
1638 STp->drv_block = (-1);
1639 }
1640 }
1641 else if (cmd_in == MTBSR) {
1642 if (SCpnt->sense_buffer[2] & 0x80) {
1643 (STp->mt_status)->mt_fileno--;
1644 STp->drv_block = (-1);
1645 }
1646 else {
1647 if (blkno >= 0)
1648 STp->drv_block = blkno + undone;
1649 else
1650 STp->drv_block = (-1);
1651 }
1652 }
1653 else if (cmd_in == MTEOM || cmd_in == MTSEEK) {
1654 (STp->mt_status)->mt_fileno = (-1);
1655 STp->drv_block = (-1);
1656 }
1657 if (STp->eof == ST_NOEOF &&
1658 (SCpnt->sense_buffer[2] & 0x0f) == BLANK_CHECK)
1659 STp->eof = ST_EOD;
1660 }
1661
1662 return ioctl_result;
1663 }
1664
1665
1666
1667
1668 static int
1669 st_ioctl(struct inode * inode,struct file * file,
1670 unsigned int cmd_in, unsigned long arg)
1671 {
1672 int dev = MINOR(inode->i_rdev);
1673 int i, cmd, result;
1674 struct mtop mtc;
1675 struct mtpos mt_pos;
1676 unsigned char scmd[10];
1677 Scsi_Cmnd *SCpnt;
1678 Scsi_Tape *STp;
1679
1680 dev = dev & 127;
1681 STp = &(scsi_tapes[dev]);
1682 #ifdef DEBUG
1683 if (debugging && !STp->in_use) {
1684 printk("st%d: Incorrect device.\n", dev);
1685 return (-EIO);
1686 }
1687 #endif
1688
1689 cmd = cmd_in & IOCCMD_MASK;
1690 if (cmd == (MTIOCTOP & IOCCMD_MASK)) {
1691
1692 if (((cmd_in & IOCSIZE_MASK) >> IOCSIZE_SHIFT) != sizeof(mtc))
1693 return (-EINVAL);
1694
1695 i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(mtc));
1696 if (i)
1697 return i;
1698
1699 memcpy_fromfs((char *) &mtc, (char *)arg, sizeof(struct mtop));
1700
1701 i = flush_buffer(inode, file, mtc.mt_op == MTSEEK ||
1702 mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
1703 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM);
1704 if (i < 0)
1705 return i;
1706 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
1707 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
1708 mtc.mt_op != MTSETDRVBUFFER)
1709 STp->rw = ST_IDLE;
1710
1711 if (mtc.mt_op == MTSETDRVBUFFER &&
1712 (mtc.mt_count & MT_ST_OPTIONS) != 0)
1713 return st_set_options(inode, mtc.mt_count);
1714 else
1715 return st_int_ioctl(inode, file, mtc.mt_op, mtc.mt_count);
1716 }
1717 else if (cmd == (MTIOCGET & IOCCMD_MASK)) {
1718
1719 if (((cmd_in & IOCSIZE_MASK) >> IOCSIZE_SHIFT) != sizeof(struct mtget))
1720 return (-EINVAL);
1721 i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct mtget));
1722 if (i)
1723 return i;
1724
1725 (STp->mt_status)->mt_dsreg =
1726 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
1727 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
1728 (STp->mt_status)->mt_blkno = STp->drv_block;
1729 if (STp->block_size != 0) {
1730 if (STp->rw == ST_WRITING)
1731 (STp->mt_status)->mt_blkno +=
1732 (STp->buffer)->buffer_bytes / STp->block_size;
1733 else if (STp->rw == ST_READING)
1734 (STp->mt_status)->mt_blkno -= ((STp->buffer)->buffer_bytes +
1735 STp->block_size - 1) / STp->block_size;
1736 }
1737
1738 (STp->mt_status)->mt_gstat = 0;
1739 if (STp->drv_write_prot)
1740 (STp->mt_status)->mt_gstat |= GMT_WR_PROT(0xffffffff);
1741 if ((STp->mt_status)->mt_blkno == 0) {
1742 if ((STp->mt_status)->mt_fileno == 0)
1743 (STp->mt_status)->mt_gstat |= GMT_BOT(0xffffffff);
1744 else
1745 (STp->mt_status)->mt_gstat |= GMT_EOF(0xffffffff);
1746 }
1747 if (STp->eof == ST_EOM_OK || STp->eof == ST_EOM_ERROR)
1748 (STp->mt_status)->mt_gstat |= GMT_EOT(0xffffffff);
1749 else if (STp->eof == ST_EOD)
1750 (STp->mt_status)->mt_gstat |= GMT_EOD(0xffffffff);
1751 if (STp->density == 1)
1752 (STp->mt_status)->mt_gstat |= GMT_D_800(0xffffffff);
1753 else if (STp->density == 2)
1754 (STp->mt_status)->mt_gstat |= GMT_D_1600(0xffffffff);
1755 else if (STp->density == 3)
1756 (STp->mt_status)->mt_gstat |= GMT_D_6250(0xffffffff);
1757 if (STp->ready == ST_READY)
1758 (STp->mt_status)->mt_gstat |= GMT_ONLINE(0xffffffff);
1759 if (STp->ready == ST_NO_TAPE)
1760 (STp->mt_status)->mt_gstat |= GMT_DR_OPEN(0xffffffff);
1761 if (STp->at_sm)
1762 (STp->mt_status)->mt_gstat |= GMT_SM(0xffffffff);
1763
1764 memcpy_tofs((char *)arg, (char *)(STp->mt_status),
1765 sizeof(struct mtget));
1766
1767 (STp->mt_status)->mt_erreg = 0;
1768 return 0;
1769 }
1770 else if (cmd == (MTIOCPOS & IOCCMD_MASK)) {
1771 if (STp->ready != ST_READY)
1772 return (-EIO);
1773 #ifdef DEBUG
1774 if (debugging)
1775 printk("st%d: get tape position.\n", dev);
1776 #endif
1777 if (((cmd_in & IOCSIZE_MASK) >> IOCSIZE_SHIFT) != sizeof(struct mtpos))
1778 return (-EINVAL);
1779
1780 i = flush_buffer(inode, file, 0);
1781 if (i < 0)
1782 return i;
1783
1784 i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct mtpos));
1785 if (i)
1786 return i;
1787
1788 SCpnt = allocate_device(NULL, STp->device, 1);
1789
1790 SCpnt->sense_buffer[0]=0;
1791 memset (scmd, 0, 10);
1792 if ((STp->device)->scsi_level < SCSI_2) {
1793 scmd[0] = QFA_REQUEST_BLOCK;
1794 scmd[4] = 3;
1795 }
1796 else {
1797 scmd[0] = READ_POSITION;
1798 scmd[1] = 1;
1799 }
1800 SCpnt->request.dev = dev;
1801 SCpnt->sense_buffer[0] = 0;
1802 scsi_do_cmd(SCpnt,
1803 (void *) scmd, (void *) (STp->buffer)->b_data,
1804 20, st_sleep_done, ST_TIMEOUT, MAX_READY_RETRIES);
1805
1806 if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
1807
1808 if ((STp->buffer)->last_result_fatal != 0) {
1809 mt_pos.mt_blkno = (-1);
1810 #ifdef DEBUG
1811 if (debugging)
1812 printk("st%d: Can't read tape position.\n", dev);
1813 #endif
1814 result = (-EIO);
1815 }
1816 else {
1817 result = 0;
1818 if ((STp->device)->scsi_level < SCSI_2)
1819 mt_pos.mt_blkno = ((STp->buffer)->b_data[0] << 16)
1820 + ((STp->buffer)->b_data[1] << 8)
1821 + (STp->buffer)->b_data[2];
1822 else
1823 mt_pos.mt_blkno = ((STp->buffer)->b_data[4] << 24)
1824 + ((STp->buffer)->b_data[5] << 16)
1825 + ((STp->buffer)->b_data[6] << 8)
1826 + (STp->buffer)->b_data[7];
1827
1828 }
1829
1830 SCpnt->request.dev = -1;
1831
1832 memcpy_tofs((char *)arg, (char *) (&mt_pos), sizeof(struct mtpos));
1833 return result;
1834 }
1835 else if (STp->ready == ST_READY)
1836 return scsi_ioctl(STp->device, cmd_in, (void *) arg);
1837 else
1838 return (-EIO);
1839 }
1840
1841
1842
1843
1844
1845 void
1846 st_setup(char *str, int *ints)
1847 {
1848 if (ints[0] > 0 && ints[1] > 0)
1849 st_buffer_size = ints[1] * ST_BLOCK_SIZE;
1850 if (ints[0] > 1 && ints[2] > 0) {
1851 st_write_threshold = ints[2] * ST_BLOCK_SIZE;
1852 if (st_write_threshold > st_buffer_size)
1853 st_write_threshold = st_buffer_size;
1854 }
1855 if (ints[0] > 2 && ints[3] > 0)
1856 st_max_buffers = ints[3];
1857 }
1858
1859
1860 static struct file_operations st_fops = {
1861 NULL,
1862 st_read,
1863 st_write,
1864 NULL,
1865 NULL,
1866 st_ioctl,
1867 NULL,
1868 scsi_tape_open,
1869 scsi_tape_close,
1870 NULL
1871 };
1872
1873 static int st_attach(Scsi_Device * SDp){
1874 Scsi_Tape * tpnt;
1875 int i;
1876
1877 if(SDp->type != TYPE_TAPE) return 1;
1878
1879 if(st_template.nr_dev >= st_template.dev_max)
1880 {
1881 SDp->attached--;
1882 return 1;
1883 }
1884
1885 for(tpnt = scsi_tapes, i=0; i<st_template.dev_max; i++, tpnt++)
1886 if(!tpnt->device) break;
1887
1888 if(i >= st_template.dev_max) panic ("scsi_devices corrupt (st)");
1889
1890 scsi_tapes[i].device = SDp;
1891 if (SDp->scsi_level <= 2)
1892 scsi_tapes[i].mt_status->mt_type = MT_ISSCSI1;
1893 else
1894 scsi_tapes[i].mt_status->mt_type = MT_ISSCSI2;
1895
1896 st_template.nr_dev++;
1897 return 0;
1898 };
1899
1900 static int st_detect(Scsi_Device * SDp)
1901 {
1902 if(SDp->type != TYPE_TAPE) return 0;
1903
1904 printk("Detected scsi tape st%d at scsi%d, id %d, lun %d\n",
1905 st_template.dev_noticed++,
1906 SDp->host->host_no , SDp->id, SDp->lun);
1907
1908 return 1;
1909 }
1910
1911
1912 static void st_init()
1913 {
1914 int i;
1915 Scsi_Tape * STp;
1916 static int st_registered = 0;
1917
1918 if (st_template.dev_noticed == 0) return;
1919
1920 if(!st_registered) {
1921 if (register_chrdev(MAJOR_NR,"st",&st_fops)) {
1922 printk("Unable to get major %d for SCSI tapes\n",MAJOR_NR);
1923 return;
1924 }
1925 st_registered++;
1926 }
1927
1928 if (scsi_tapes) return;
1929 scsi_tapes = (Scsi_Tape *) scsi_init_malloc(
1930 (st_template.dev_noticed + ST_EXTRA_DEVS) *
1931 sizeof(Scsi_Tape), GFP_ATOMIC);
1932 st_template.dev_max = st_template.dev_noticed + ST_EXTRA_DEVS;
1933
1934 #ifdef DEBUG
1935 printk("st: Buffer size %d bytes, write threshold %d bytes.\n",
1936 st_buffer_size, st_write_threshold);
1937 #endif
1938
1939 for (i=0; i < st_template.dev_max; ++i) {
1940 STp = &(scsi_tapes[i]);
1941 STp->device = NULL;
1942 STp->capacity = 0xfffff;
1943 STp->dirty = 0;
1944 STp->rw = ST_IDLE;
1945 STp->eof = ST_NOEOF;
1946 STp->waiting = NULL;
1947 STp->in_use = 0;
1948 STp->drv_buffer = 1;
1949 STp->density = 0;
1950 STp->do_buffer_writes = ST_BUFFER_WRITES;
1951 STp->do_async_writes = ST_ASYNC_WRITES;
1952 STp->do_read_ahead = ST_READ_AHEAD;
1953 STp->two_fm = ST_TWO_FM;
1954 STp->fast_mteom = ST_FAST_MTEOM;
1955 STp->write_threshold = st_write_threshold;
1956 STp->drv_block = 0;
1957 STp->moves_after_eof = 1;
1958 STp->at_sm = 0;
1959 STp->mt_status = (struct mtget *) scsi_init_malloc(sizeof(struct mtget), GFP_ATOMIC);
1960
1961 memset((void *) scsi_tapes[i].mt_status, 0, sizeof(struct mtget));
1962 }
1963
1964
1965 st_nbr_buffers = st_template.dev_noticed + ST_EXTRA_DEVS;
1966 if (st_nbr_buffers > st_max_buffers)
1967 st_nbr_buffers = st_max_buffers;
1968 st_buffers = (ST_buffer **) scsi_init_malloc(st_nbr_buffers *
1969 sizeof(ST_buffer *), GFP_ATOMIC);
1970
1971
1972
1973
1974
1975 for (i=0; i < st_nbr_buffers; i++) {
1976 st_buffers[i] = (ST_buffer *) scsi_init_malloc(sizeof(ST_buffer) -
1977 1 + st_buffer_size, GFP_ATOMIC | GFP_DMA);
1978 #ifdef DEBUG
1979
1980 #endif
1981 st_buffers[i]->in_use = 0;
1982 st_buffers[i]->writing = 0;
1983 }
1984 return;
1985 }
1986
1987 static void st_detach(Scsi_Device * SDp)
1988 {
1989 Scsi_Tape * tpnt;
1990 int i;
1991
1992 for(tpnt = scsi_tapes, i=0; i<st_template.dev_max; i++, tpnt++)
1993 if(tpnt->device == SDp) {
1994 tpnt->device = NULL;
1995 SDp->attached--;
1996 st_template.nr_dev--;
1997 st_template.dev_noticed--;
1998 return;
1999 }
2000 return;
2001 }