This source file includes following definitions.
- st_chk_result
- st_sleep_done
- st_do_scsi
- write_behind_check
- back_over_eof
- flush_write_buffer
- flush_buffer
- scsi_tape_open
- scsi_tape_close
- st_write
- st_read
- st_log_options
- st_set_options
- st_compression
- st_int_ioctl
- st_ioctl
- new_tape_buffer
- enlarge_buffer
- normalize_buffer
- st_setup
- st_attach
- st_detect
- st_init
- st_detach
- init_module
- cleanup_module
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 #include <linux/module.h>
19
20 #include <linux/fs.h>
21 #include <linux/kernel.h>
22 #include <linux/sched.h>
23 #include <linux/mm.h>
24 #include <linux/string.h>
25 #include <linux/errno.h>
26 #include <linux/mtio.h>
27 #include <linux/ioctl.h>
28 #include <linux/fcntl.h>
29 #include <asm/segment.h>
30 #include <asm/dma.h>
31 #include <asm/system.h>
32
33
34
35 #define DEBUG 0
36
37
38
39
40 #define ST_DEB_MSG KERN_NOTICE
41
42 #define MAJOR_NR SCSI_TAPE_MAJOR
43 #include <linux/blk.h>
44 #include "scsi.h"
45 #include "hosts.h"
46 #include "scsi_ioctl.h"
47 #include "st.h"
48 #include "constants.h"
49
50
51
52 #define ST_BLOCK_SIZE 1024
53
54 #include "st_options.h"
55
56 #define ST_BUFFER_SIZE (ST_BUFFER_BLOCKS * ST_BLOCK_SIZE)
57 #define ST_WRITE_THRESHOLD (ST_WRITE_THRESHOLD_BLOCKS * ST_BLOCK_SIZE)
58
59
60
61 #if ST_BUFFER_SIZE >= (2 << 24 - 1)
62 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
63 #endif
64
65 #if DEBUG
66 static int debugging = 1;
67 #endif
68
69 #define MAX_RETRIES 0
70 #define MAX_WRITE_RETRIES 0
71 #define MAX_READY_RETRIES 5
72 #define NO_TAPE NOT_READY
73
74 #define ST_TIMEOUT (900 * HZ)
75 #define ST_LONG_TIMEOUT (2000 * HZ)
76
77 #define TAPE_NR(x) (MINOR(x) & ~(128 | ST_MODE_MASK))
78 #define TAPE_MODE(x) ((MINOR(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
79
80 static int st_nbr_buffers;
81 static ST_buffer **st_buffers;
82 static int st_buffer_size = ST_BUFFER_SIZE;
83 static int st_write_threshold = ST_WRITE_THRESHOLD;
84 static int st_max_buffers = ST_MAX_BUFFERS;
85
86 Scsi_Tape * scsi_tapes = NULL;
87
88 static int modes_defined = FALSE;
89
90 static ST_buffer *new_tape_buffer(int, int);
91 static int enlarge_buffer(ST_buffer *, int, int);
92 static void normalize_buffer(ST_buffer *);
93
94 static int st_init(void);
95 static int st_attach(Scsi_Device *);
96 static int st_detect(Scsi_Device *);
97 static void st_detach(Scsi_Device *);
98
99 struct Scsi_Device_Template st_template = {NULL, "tape", "st", NULL, TYPE_TAPE,
100 SCSI_TAPE_MAJOR, 0, 0, 0, 0,
101 st_detect, st_init,
102 NULL, st_attach, st_detach};
103
104 static int st_compression(Scsi_Tape *, int);
105
106 static int st_int_ioctl(struct inode * inode,struct file * file,
107 unsigned int cmd_in, unsigned long arg);
108
109
110
111
112
113 static int
114 st_chk_result(Scsi_Cmnd * SCpnt)
115 {
116 int dev = TAPE_NR(SCpnt->request.rq_dev);
117 int result = SCpnt->result;
118 unsigned char * sense = SCpnt->sense_buffer, scode;
119 #if DEBUG
120 const char *stp;
121 #endif
122
123 if (!result )
124 return 0;
125 #if DEBUG
126 if (debugging) {
127 printk(ST_DEB_MSG "st%d: Error: %x, cmd: %x %x %x %x %x %x Len: %d\n",
128 dev, result,
129 SCpnt->data_cmnd[0], SCpnt->data_cmnd[1], SCpnt->data_cmnd[2],
130 SCpnt->data_cmnd[3], SCpnt->data_cmnd[4], SCpnt->data_cmnd[5],
131 SCpnt->request_bufflen);
132 if (driver_byte(result) & DRIVER_SENSE)
133 print_sense("st", SCpnt);
134 else
135 printk("\n");
136 }
137 #endif
138 scode = sense[2] & 0x0f;
139 if (!(driver_byte(result) & DRIVER_SENSE) ||
140 ((sense[0] & 0x70) == 0x70 &&
141 scode != NO_SENSE &&
142 scode != RECOVERED_ERROR &&
143
144 scode != BLANK_CHECK &&
145 scode != VOLUME_OVERFLOW &&
146 SCpnt->data_cmnd[0] != MODE_SENSE &&
147 SCpnt->data_cmnd[0] != TEST_UNIT_READY)) {
148 #if !DEBUG
149 if (driver_byte(result) & DRIVER_SENSE) {
150 printk(KERN_WARNING "st%d: Error with sense data: ", dev);
151 print_sense("st", SCpnt);
152 }
153 else
154 printk(KERN_WARNING "st%d: Error %x.\n", dev, result);
155 #endif
156 }
157
158 if ((sense[0] & 0x70) == 0x70 &&
159 scode == RECOVERED_ERROR
160 #if ST_RECOVERED_WRITE_FATAL
161 && SCpnt->data_cmnd[0] != WRITE_6
162 && SCpnt->data_cmnd[0] != WRITE_FILEMARKS
163 #endif
164 ) {
165 scsi_tapes[dev].recover_count++;
166 scsi_tapes[dev].mt_status->mt_erreg += (1 << MT_ST_SOFTERR_SHIFT);
167 #if DEBUG
168 if (debugging) {
169 if (SCpnt->data_cmnd[0] == READ_6)
170 stp = "read";
171 else if (SCpnt->data_cmnd[0] == WRITE_6)
172 stp = "write";
173 else
174 stp = "ioctl";
175 printk(ST_DEB_MSG "st%d: Recovered %s error (%d).\n", dev, stp,
176 scsi_tapes[dev].recover_count);
177 }
178 #endif
179 if ((sense[2] & 0xe0) == 0)
180 return 0;
181 }
182 return (-EIO);
183 }
184
185
186
187 static void
188 st_sleep_done (Scsi_Cmnd * SCpnt)
189 {
190 unsigned int st_nbr;
191 int remainder;
192 Scsi_Tape * STp;
193
194 if ((st_nbr = TAPE_NR(SCpnt->request.rq_dev)) < st_template.nr_dev) {
195 STp = &(scsi_tapes[st_nbr]);
196 if ((STp->buffer)->writing &&
197 (SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
198 (SCpnt->sense_buffer[2] & 0x40)) {
199
200 if ((SCpnt->sense_buffer[0] & 0x80) != 0)
201 remainder = (SCpnt->sense_buffer[3] << 24) |
202 (SCpnt->sense_buffer[4] << 16) |
203 (SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
204 else
205 remainder = 0;
206 if ((SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW ||
207 remainder > 0)
208 (STp->buffer)->last_result = SCpnt->result;
209 else
210 (STp->buffer)->last_result = INT_MAX;
211 }
212 else
213 (STp->buffer)->last_result = SCpnt->result;
214 if ((STp->buffer)->writing) {
215
216 (STp->buffer)->last_result_fatal = st_chk_result(SCpnt);
217 SCpnt->request.rq_status = RQ_INACTIVE;
218 }
219 else
220 SCpnt->request.rq_status = RQ_SCSI_DONE;
221
222 #if DEBUG
223 STp->write_pending = 0;
224 #endif
225 up(SCpnt->request.sem);
226 }
227 #if DEBUG
228 else if (debugging)
229 printk(KERN_ERR "st?: Illegal interrupt device %x\n", st_nbr);
230 #endif
231 }
232
233
234
235 static Scsi_Cmnd *
236 st_do_scsi(Scsi_Cmnd *SCpnt, Scsi_Tape *STp, unsigned char *cmd, int bytes,
237 int timeout, int retries)
238 {
239 if (SCpnt == NULL)
240 if ((SCpnt = allocate_device(NULL, STp->device, 1)) == NULL) {
241 printk(KERN_ERR "st%d: Can't get SCSI request.\n", TAPE_NR(STp->devt));
242 return NULL;
243 }
244
245 cmd[1] |= (SCpnt->lun << 5) & 0xe0;
246 STp->sem = MUTEX_LOCKED;
247 SCpnt->request.sem = &(STp->sem);
248 SCpnt->request.rq_status = RQ_SCSI_BUSY;
249 SCpnt->request.rq_dev = STp->devt;
250
251 scsi_do_cmd(SCpnt, (void *)cmd, (STp->buffer)->b_data, bytes,
252 st_sleep_done, timeout, retries);
253
254 down(SCpnt->request.sem);
255
256 (STp->buffer)->last_result_fatal = st_chk_result(SCpnt);
257
258 return SCpnt;
259 }
260
261
262
263 static void
264 write_behind_check(Scsi_Tape *STp)
265 {
266 ST_buffer * STbuffer;
267
268 STbuffer = STp->buffer;
269
270 #if DEBUG
271 if (STp->write_pending)
272 STp->nbr_waits++;
273 else
274 STp->nbr_finished++;
275 #endif
276
277 down(&(STp->sem));
278
279 if (STbuffer->writing < STbuffer->buffer_bytes)
280 memcpy(STbuffer->b_data,
281 STbuffer->b_data + STbuffer->writing,
282 STbuffer->buffer_bytes - STbuffer->writing);
283 STbuffer->buffer_bytes -= STbuffer->writing;
284 if (STp->drv_block >= 0) {
285 if (STp->block_size == 0)
286 STp->drv_block++;
287 else
288 STp->drv_block += STbuffer->writing / STp->block_size;
289 }
290 STbuffer->writing = 0;
291
292 return;
293 }
294
295
296
297
298 static int
299 back_over_eof(Scsi_Tape *STp)
300 {
301 Scsi_Cmnd *SCpnt;
302 unsigned char cmd[10];
303
304 cmd[0] = SPACE;
305 cmd[1] = 0x01;
306 cmd[2] = cmd[3] = cmd[4] = 0xff;
307 cmd[5] = 0;
308
309 SCpnt = st_do_scsi(NULL, STp, cmd, 0, ST_TIMEOUT, MAX_RETRIES);
310 if (!SCpnt)
311 return (-EBUSY);
312
313 SCpnt->request.rq_status = RQ_INACTIVE;
314 if ((STp->buffer)->last_result != 0) {
315 printk(KERN_ERR "st%d: Backing over filemark failed.\n", TAPE_NR(STp->devt));
316 if ((STp->mt_status)->mt_fileno >= 0)
317 (STp->mt_status)->mt_fileno += 1;
318 (STp->mt_status)->mt_blkno = 0;
319 }
320
321 return (STp->buffer)->last_result_fatal;
322 }
323
324
325
326 static int
327 flush_write_buffer(Scsi_Tape *STp)
328 {
329 int offset, transfer, blks;
330 int result;
331 unsigned char cmd[10];
332 Scsi_Cmnd *SCpnt;
333
334 if ((STp->buffer)->writing) {
335 write_behind_check(STp);
336 if ((STp->buffer)->last_result_fatal) {
337 #if DEBUG
338 if (debugging)
339 printk(ST_DEB_MSG "st%d: Async write error (flush) %x.\n",
340 TAPE_NR(STp->devt), (STp->buffer)->last_result);
341 #endif
342 if ((STp->buffer)->last_result == INT_MAX)
343 return (-ENOSPC);
344 return (-EIO);
345 }
346 }
347
348 if (STp->block_size == 0)
349 return 0;
350
351 result = 0;
352 if (STp->dirty == 1) {
353
354 offset = (STp->buffer)->buffer_bytes;
355 transfer = ((offset + STp->block_size - 1) /
356 STp->block_size) * STp->block_size;
357 #if DEBUG
358 if (debugging)
359 printk(ST_DEB_MSG "st%d: Flushing %d bytes.\n", TAPE_NR(STp->devt), transfer);
360 #endif
361 memset((STp->buffer)->b_data + offset, 0, transfer - offset);
362
363 memset(cmd, 0, 10);
364 cmd[0] = WRITE_6;
365 cmd[1] = 1;
366 blks = transfer / STp->block_size;
367 cmd[2] = blks >> 16;
368 cmd[3] = blks >> 8;
369 cmd[4] = blks;
370
371 SCpnt = st_do_scsi(NULL, STp, cmd, transfer, ST_TIMEOUT, MAX_WRITE_RETRIES);
372 if (!SCpnt)
373 return (-EBUSY);
374
375 if ((STp->buffer)->last_result_fatal != 0) {
376 printk(KERN_ERR "st%d: Error on flush.\n", TAPE_NR(STp->devt));
377 if ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
378 (SCpnt->sense_buffer[2] & 0x40) &&
379 (SCpnt->sense_buffer[2] & 0x0f) != VOLUME_OVERFLOW) {
380 STp->dirty = 0;
381 (STp->buffer)->buffer_bytes = 0;
382 result = (-ENOSPC);
383 }
384 else
385 result = (-EIO);
386 STp->drv_block = (-1);
387 }
388 else {
389 if (STp->drv_block >= 0)
390 STp->drv_block += blks;
391 STp->dirty = 0;
392 (STp->buffer)->buffer_bytes = 0;
393 }
394 SCpnt->request.rq_status = RQ_INACTIVE;
395 }
396 return result;
397 }
398
399
400
401
402 static int
403 flush_buffer(struct inode * inode, struct file * filp, int seek_next)
404 {
405 int backspace, result;
406 Scsi_Tape * STp;
407 ST_buffer * STbuffer;
408 int dev = TAPE_NR(inode->i_rdev);
409
410 STp = &(scsi_tapes[dev]);
411 STbuffer = STp->buffer;
412
413
414
415
416
417 if( STp->device->was_reset )
418 return (-EIO);
419
420 if (STp->ready != ST_READY)
421 return 0;
422
423 if (STp->rw == ST_WRITING)
424 return flush_write_buffer(STp);
425
426 if (STp->block_size == 0)
427 return 0;
428
429 backspace = ((STp->buffer)->buffer_bytes +
430 (STp->buffer)->read_pointer) / STp->block_size -
431 ((STp->buffer)->read_pointer + STp->block_size - 1) /
432 STp->block_size;
433 (STp->buffer)->buffer_bytes = 0;
434 (STp->buffer)->read_pointer = 0;
435 result = 0;
436 if (!seek_next) {
437 if ((STp->eof == ST_FM) && !STp->eof_hit) {
438 result = back_over_eof(STp);
439 if (!result) {
440 STp->eof = ST_NOEOF;
441 STp->eof_hit = 0;
442 }
443 }
444 if (!result && backspace > 0)
445 result = st_int_ioctl(inode, filp, MTBSR, backspace);
446 }
447 else if ((STp->eof == ST_FM) && !STp->eof_hit) {
448 (STp->mt_status)->mt_fileno++;
449 STp->drv_block = 0;
450 }
451
452 return result;
453
454 }
455
456
457
458 static int
459 scsi_tape_open(struct inode * inode, struct file * filp)
460 {
461 unsigned short flags;
462 int i, need_dma_buffer, new_session = FALSE, setting_failed;
463 unsigned char cmd[10];
464 Scsi_Cmnd * SCpnt;
465 Scsi_Tape * STp;
466 ST_mode * STm;
467 int dev = TAPE_NR(inode->i_rdev);
468 int mode = TAPE_MODE(inode->i_rdev);
469
470 if (dev >= st_template.dev_max || !scsi_tapes[dev].device)
471 return (-ENXIO);
472 STp = &(scsi_tapes[dev]);
473 if (STp->in_use) {
474 #if DEBUG
475 printk(ST_DEB_MSG "st%d: Device already in use.\n", dev);
476 #endif
477 return (-EBUSY);
478 }
479 STp->rew_at_close = (MINOR(inode->i_rdev) & 0x80) == 0;
480
481 if (mode != STp->current_mode) {
482 #if DEBUG
483 if (debugging)
484 printk(ST_DEB_MSG "st%d: Mode change from %d to %d.\n",
485 dev, STp->current_mode, mode);
486 #endif
487
488
489 new_session = TRUE;
490 STp->current_mode = mode;
491 }
492 STm = &(STp->modes[STp->current_mode]);
493
494
495 need_dma_buffer = STp->restr_dma;
496 for (i=0; i < st_nbr_buffers; i++)
497 if (!st_buffers[i]->in_use &&
498 (!need_dma_buffer || st_buffers[i]->dma))
499 break;
500 if (i >= st_nbr_buffers) {
501 STp->buffer = new_tape_buffer(FALSE, need_dma_buffer);
502 if (STp->buffer == NULL) {
503 printk(KERN_WARNING "st%d: Can't allocate tape buffer.\n", dev);
504 return (-EBUSY);
505 }
506 }
507 else
508 STp->buffer = st_buffers[i];
509 (STp->buffer)->in_use = 1;
510 (STp->buffer)->writing = 0;
511 STp->in_use = 1;
512
513 flags = filp->f_flags;
514 STp->write_prot = ((flags & O_ACCMODE) == O_RDONLY);
515
516 STp->dirty = 0;
517 STp->rw = ST_IDLE;
518 STp->ready = ST_READY;
519 if (STp->eof != ST_EOD)
520 STp->eof = ST_NOEOF;
521 STp->eof_hit = 0;
522 STp->recover_count = 0;
523 #if DEBUG
524 STp->nbr_waits = STp->nbr_finished = 0;
525 #endif
526
527 memset ((void *) &cmd[0], 0, 10);
528 cmd[0] = TEST_UNIT_READY;
529
530 SCpnt = st_do_scsi(NULL, STp, cmd, 0, ST_LONG_TIMEOUT, MAX_READY_RETRIES);
531 if (!SCpnt)
532 return (-EBUSY);
533
534 if ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
535 (SCpnt->sense_buffer[2] & 0x0f) == UNIT_ATTENTION) {
536 (STp->mt_status)->mt_fileno = 0 ;
537 memset ((void *) &cmd[0], 0, 10);
538 cmd[0] = TEST_UNIT_READY;
539
540 SCpnt = st_do_scsi(SCpnt, STp, cmd, 0, ST_LONG_TIMEOUT, MAX_READY_RETRIES);
541
542 (STp->mt_status)->mt_fileno = STp->drv_block = 0;
543 STp->eof = ST_NOEOF;
544 (STp->device)->was_reset = 0;
545 new_session = TRUE;
546 }
547
548 if ((STp->buffer)->last_result_fatal != 0) {
549 if ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
550 (SCpnt->sense_buffer[2] & 0x0f) == NO_TAPE) {
551 (STp->mt_status)->mt_fileno = STp->drv_block = 0 ;
552 printk(KERN_NOTICE "st%d: No tape.\n", dev);
553 STp->ready = ST_NO_TAPE;
554 } else {
555 (STp->mt_status)->mt_fileno = STp->drv_block = (-1);
556 STp->ready = ST_NOT_READY;
557 }
558 SCpnt->request.rq_status = RQ_INACTIVE;
559 STp->density = 0;
560 STp->write_prot = 0;
561 STp->block_size = 0;
562 STp->eof = ST_NOEOF;
563 (STp->mt_status)->mt_fileno = STp->drv_block = 0;
564 STp->door_locked = ST_UNLOCKED;
565 if (scsi_tapes[dev].device->host->hostt->usage_count)
566 (*scsi_tapes[dev].device->host->hostt->usage_count)++;
567 if(st_template.usage_count) (*st_template.usage_count)++;
568 return 0;
569 }
570
571 memset ((void *) &cmd[0], 0, 10);
572 cmd[0] = READ_BLOCK_LIMITS;
573
574 SCpnt = st_do_scsi(SCpnt, STp, cmd, 6, ST_TIMEOUT, MAX_READY_RETRIES);
575
576 if (!SCpnt->result && !SCpnt->sense_buffer[0]) {
577 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
578 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
579 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
580 (STp->buffer)->b_data[5];
581 #if DEBUG
582 if (debugging)
583 printk(ST_DEB_MSG "st%d: Block limits %d - %d bytes.\n", dev, STp->min_block,
584 STp->max_block);
585 #endif
586 }
587 else {
588 STp->min_block = STp->max_block = (-1);
589 #if DEBUG
590 if (debugging)
591 printk(ST_DEB_MSG "st%d: Can't read block limits.\n", dev);
592 #endif
593 }
594
595 memset ((void *) &cmd[0], 0, 10);
596 cmd[0] = MODE_SENSE;
597 cmd[4] = 12;
598
599 SCpnt = st_do_scsi(SCpnt, STp, cmd, 12, ST_TIMEOUT, MAX_READY_RETRIES);
600
601 if ((STp->buffer)->last_result_fatal != 0) {
602 #if DEBUG
603 if (debugging)
604 printk(ST_DEB_MSG "st%d: No Mode Sense.\n", dev);
605 #endif
606 STp->block_size = ST_DEFAULT_BLOCK;
607 (STp->buffer)->last_result_fatal = 0;
608 STp->drv_write_prot = 0;
609 }
610 else {
611
612 #if DEBUG
613 if (debugging)
614 printk(ST_DEB_MSG "st%d: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
615 dev,
616 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
617 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]);
618 #endif
619
620 if ((STp->buffer)->b_data[3] >= 8) {
621 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
622 STp->density = (STp->buffer)->b_data[4];
623 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
624 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
625 #if DEBUG
626 if (debugging)
627 printk(ST_DEB_MSG "st%d: Density %x, tape length: %x, drv buffer: %d\n",
628 dev, STp->density, (STp->buffer)->b_data[5] * 65536 +
629 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
630 STp->drv_buffer);
631 #endif
632 }
633
634 if (STp->block_size > (STp->buffer)->buffer_size &&
635 !enlarge_buffer(STp->buffer, STp->block_size, STp->restr_dma)) {
636 printk(KERN_NOTICE "st%d: Blocksize %d too large for buffer.\n", dev,
637 STp->block_size);
638 (STp->buffer)->in_use = 0;
639 STp->in_use = 0;
640 return (-EIO);
641 }
642 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
643 }
644 SCpnt->request.rq_status = RQ_INACTIVE;
645
646 if (STp->block_size > 0)
647 (STp->buffer)->buffer_blocks = st_buffer_size / STp->block_size;
648 else
649 (STp->buffer)->buffer_blocks = 1;
650 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
651
652 #if DEBUG
653 if (debugging)
654 printk(ST_DEB_MSG "st%d: Block size: %d, buffer size: %d (%d blocks).\n", dev,
655 STp->block_size, (STp->buffer)->buffer_size,
656 (STp->buffer)->buffer_blocks);
657 #endif
658
659 if (STp->drv_write_prot) {
660 STp->write_prot = 1;
661 #if DEBUG
662 if (debugging)
663 printk(ST_DEB_MSG "st%d: Write protected\n", dev);
664 #endif
665 if ((flags & O_ACCMODE) == O_WRONLY || (flags & O_ACCMODE) == O_RDWR) {
666 (STp->buffer)->in_use = 0;
667 STp->buffer = 0;
668 STp->in_use = 0;
669 return (-EROFS);
670 }
671 }
672
673 if (new_session) {
674 STp->density_changed = STp->blksize_changed = FALSE;
675 STp->compression_changed = FALSE;
676 if (!(STm->defaults_for_writes)) {
677 setting_failed = FALSE;
678 if (STm->default_blksize >= 0 &&
679 STm->default_blksize != STp->block_size) {
680 if (STm->default_density >= 0 &&
681 STm->default_density != STp->density)
682 STp->density = STm->default_density;
683 if (st_int_ioctl(inode, filp, MTSETBLK, STm->default_blksize)) {
684 printk(KERN_WARNING "st%d: Can't set default block size to %d bytes.\n",
685 dev, STm->default_blksize);
686 if (modes_defined)
687 setting_failed = TRUE;
688 }
689 }
690 if (STm->default_density >= 0 &&
691 STm->default_density != STp->density) {
692 if (st_int_ioctl(inode, filp, MTSETDENSITY, STm->default_density)) {
693 printk(KERN_WARNING "st%d: Can't set default density to %x.\n",
694 dev, STm->default_density);
695 if (modes_defined)
696 setting_failed = TRUE;
697 }
698 }
699 if (setting_failed) {
700 (STp->buffer)->in_use = 0;
701 STp->buffer = 0;
702 STp->in_use = 0;
703 return (-EINVAL);
704 }
705 }
706 if (STp->default_drvbuffer != 0xff) {
707 if (st_int_ioctl(inode, filp, MTSETDRVBUFFER, STp->default_drvbuffer))
708 printk(KERN_WARNING "st%d: Can't set default drive buffering to %d.\n",
709 dev, STp->default_drvbuffer);
710 }
711 }
712
713 if (scsi_tapes[dev].device->host->hostt->usage_count)
714 (*scsi_tapes[dev].device->host->hostt->usage_count)++;
715 if(st_template.usage_count) (*st_template.usage_count)++;
716
717 return 0;
718 }
719
720
721
722 static void
723 scsi_tape_close(struct inode * inode, struct file * filp)
724 {
725 int result;
726 static unsigned char cmd[10];
727 Scsi_Cmnd * SCpnt;
728 Scsi_Tape * STp;
729 kdev_t devt = inode->i_rdev;
730 int dev;
731
732 dev = TAPE_NR(devt);
733 STp = &(scsi_tapes[dev]);
734
735 if ( STp->rw == ST_WRITING && !(STp->device)->was_reset) {
736
737 result = flush_write_buffer(STp);
738
739 #if DEBUG
740 if (debugging) {
741 printk(ST_DEB_MSG "st%d: File length %ld bytes.\n",
742 dev, (long)(filp->f_pos));
743 printk(ST_DEB_MSG "st%d: Async write waits %d, finished %d.\n",
744 dev, STp->nbr_waits, STp->nbr_finished);
745 }
746 #endif
747
748 if (result == 0 || result == (-ENOSPC)) {
749
750 memset(cmd, 0, 10);
751 cmd[0] = WRITE_FILEMARKS;
752 cmd[4] = 1 + STp->two_fm;
753
754 SCpnt = st_do_scsi(NULL, STp, cmd, 0, ST_TIMEOUT, MAX_WRITE_RETRIES);
755 if (!SCpnt)
756 return;
757
758 SCpnt->request.rq_status = RQ_INACTIVE;
759
760 if ((STp->buffer)->last_result_fatal != 0)
761 printk(KERN_ERR "st%d: Error on write filemark.\n", dev);
762 else {
763 if ((STp->mt_status)->mt_fileno >= 0)
764 (STp->mt_status)->mt_fileno++ ;
765 STp->drv_block = 0;
766 if (STp->two_fm)
767 back_over_eof(STp);
768 }
769 }
770
771 #if DEBUG
772 if (debugging)
773 printk(ST_DEB_MSG "st%d: Buffer flushed, %d EOF(s) written\n",
774 dev, cmd[4]);
775 #endif
776 }
777 else if (!STp->rew_at_close) {
778 if (STp->can_bsr)
779 flush_buffer(inode, filp, 0);
780 else if ((STp->eof == ST_FM) && !STp->eof_hit)
781 back_over_eof(STp);
782 }
783
784 if (STp->rew_at_close)
785 st_int_ioctl(inode, filp, MTREW, 1);
786
787 if (STp->door_locked == ST_LOCKED_AUTO)
788 st_int_ioctl(inode, filp, MTUNLOCK, 0);
789
790 if (STp->buffer != NULL) {
791 normalize_buffer(STp->buffer);
792 (STp->buffer)->in_use = 0;
793 }
794 STp->in_use = 0;
795
796 if (scsi_tapes[dev].device->host->hostt->usage_count)
797 (*scsi_tapes[dev].device->host->hostt->usage_count)--;
798 if(st_template.usage_count) (*st_template.usage_count)--;
799
800 return;
801 }
802
803
804
805 static int
806 st_write(struct inode * inode, struct file * filp, const char * buf, int count)
807 {
808 int total, do_count, blks, retval, transfer;
809 int write_threshold;
810 int doing_write = 0;
811 static unsigned char cmd[10];
812 const char *b_point;
813 Scsi_Cmnd * SCpnt = NULL;
814 Scsi_Tape * STp;
815 ST_mode * STm;
816 int dev = TAPE_NR(inode->i_rdev);
817
818 STp = &(scsi_tapes[dev]);
819 if (STp->ready != ST_READY)
820 return (-EIO);
821 STm = &(STp->modes[STp->current_mode]);
822 if (!STm->defined)
823 return (-ENXIO);
824
825
826
827
828
829 if( STp->device->was_reset )
830 return (-EIO);
831
832 #if DEBUG
833 if (!STp->in_use) {
834 printk(ST_DEB_MSG "st%d: Incorrect device.\n", dev);
835 return (-EIO);
836 }
837 #endif
838
839 if (STp->write_prot)
840 return (-EACCES);
841
842 if (STp->block_size == 0 &&
843 count > (STp->buffer)->buffer_size &&
844 !enlarge_buffer(STp->buffer, count, STp->restr_dma))
845 return (-EOVERFLOW);
846
847 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
848 !st_int_ioctl(inode, filp, MTLOCK, 0))
849 STp->door_locked = ST_LOCKED_AUTO;
850
851 if (STp->rw == ST_READING) {
852 retval = flush_buffer(inode, filp, 0);
853 if (retval)
854 return retval;
855 STp->rw = ST_WRITING;
856 }
857 else if (STp->rw != ST_WRITING) {
858 if (STm->defaults_for_writes &&
859 (STp->mt_status)->mt_fileno == 0 && STp->drv_block == 0) {
860
861 if (!(STp->blksize_changed) && STm->default_blksize >= 0 &&
862 STp->block_size != STm->default_blksize) {
863 if (STm->default_density >= 0 &&
864 STm->default_density != STp->density)
865 STp->density = STm->default_density;
866 if (st_int_ioctl(inode, filp, MTSETBLK, STm->default_blksize)) {
867 printk(KERN_WARNING "st%d: Can't set default block size to %d bytes.\n",
868 dev, STm->default_blksize);
869 if (modes_defined)
870 return (-EINVAL);
871 }
872 }
873 if (!(STp->density_changed) && STm->default_density >= 0 &&
874 STm->default_density != STp->density) {
875 if (st_int_ioctl(inode, filp, MTSETDENSITY, STm->default_density)) {
876 printk(KERN_WARNING "st%d: Can't set default density %x.\n",
877 dev, STm->default_density);
878 if (modes_defined)
879 return (-EINVAL);
880 }
881 }
882 }
883 if (STm->default_compression != ST_DONT_TOUCH &&
884 !(STp->compression_changed)) {
885 if (st_compression(STp, (STm->default_compression == ST_YES))) {
886 printk(KERN_WARNING "st%d: Can't set default compression.\n",
887 dev);
888 if (modes_defined)
889 return (-EINVAL);
890 }
891 }
892 }
893
894 if (STp->moves_after_eof < 255)
895 STp->moves_after_eof++;
896
897 if ((STp->buffer)->writing) {
898 write_behind_check(STp);
899 if ((STp->buffer)->last_result_fatal) {
900 #if DEBUG
901 if (debugging)
902 printk(ST_DEB_MSG "st%d: Async write error (write) %x.\n", dev,
903 (STp->buffer)->last_result);
904 #endif
905 if ((STp->buffer)->last_result == INT_MAX) {
906 retval = (-ENOSPC);
907 STp->eof = ST_EOM_OK;
908 }
909 else
910 retval = (-EIO);
911 return retval;
912 }
913 }
914 if (STp->eof == ST_EOM_OK)
915 return (-ENOSPC);
916 else if (STp->eof == ST_EOM_ERROR)
917 return (-EIO);
918
919 if (!STm->do_buffer_writes) {
920 if (STp->block_size != 0 && (count % STp->block_size) != 0)
921 return (-EIO);
922 write_threshold = 1;
923 }
924 else
925 write_threshold = (STp->buffer)->buffer_blocks * STp->block_size;
926 if (!STm->do_async_writes)
927 write_threshold--;
928
929 total = count;
930
931 memset(cmd, 0, 10);
932 cmd[0] = WRITE_6;
933 cmd[1] = (STp->block_size != 0);
934
935 STp->rw = ST_WRITING;
936
937 b_point = buf;
938 while((STp->block_size == 0 && !STm->do_async_writes && count > 0) ||
939 (STp->block_size != 0 &&
940 (STp->buffer)->buffer_bytes + count > write_threshold))
941 {
942 doing_write = 1;
943 if (STp->block_size == 0)
944 do_count = count;
945 else {
946 do_count = (STp->buffer)->buffer_blocks * STp->block_size -
947 (STp->buffer)->buffer_bytes;
948 if (do_count > count)
949 do_count = count;
950 }
951 memcpy_fromfs((STp->buffer)->b_data +
952 (STp->buffer)->buffer_bytes, b_point, do_count);
953
954 if (STp->block_size == 0)
955 blks = transfer = do_count;
956 else {
957 blks = ((STp->buffer)->buffer_bytes + do_count) /
958 STp->block_size;
959 transfer = blks * STp->block_size;
960 }
961 cmd[2] = blks >> 16;
962 cmd[3] = blks >> 8;
963 cmd[4] = blks;
964
965 SCpnt = st_do_scsi(SCpnt, STp, cmd, transfer, ST_TIMEOUT, MAX_WRITE_RETRIES);
966 if (!SCpnt)
967 return (-EBUSY);
968
969 if ((STp->buffer)->last_result_fatal != 0) {
970 #if DEBUG
971 if (debugging)
972 printk(ST_DEB_MSG "st%d: Error on write:\n", dev);
973 #endif
974 if ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
975 (SCpnt->sense_buffer[2] & 0x40)) {
976 if (STp->block_size != 0 && (SCpnt->sense_buffer[0] & 0x80) != 0)
977 transfer = (SCpnt->sense_buffer[3] << 24) |
978 (SCpnt->sense_buffer[4] << 16) |
979 (SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
980 else if (STp->block_size == 0 &&
981 (SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW)
982 transfer = do_count;
983 else
984 transfer = 0;
985 if (STp->block_size != 0)
986 transfer *= STp->block_size;
987 if (transfer <= do_count) {
988 filp->f_pos += do_count - transfer;
989 count -= do_count - transfer;
990 if (STp->drv_block >= 0) {
991 if (STp->block_size == 0 && transfer < do_count)
992 STp->drv_block++;
993 else if (STp->block_size != 0)
994 STp->drv_block += (do_count - transfer) / STp->block_size;
995 }
996 STp->eof = ST_EOM_OK;
997 retval = (-ENOSPC);
998 #if DEBUG
999 if (debugging)
1000 printk(ST_DEB_MSG "st%d: EOM with %d bytes unwritten.\n",
1001 dev, transfer);
1002 #endif
1003 }
1004 else {
1005 STp->eof = ST_EOM_ERROR;
1006 STp->drv_block = (-1);
1007 retval = (-EIO);
1008 #if DEBUG
1009 if (debugging)
1010 printk(ST_DEB_MSG "st%d: EOM with lost data.\n", dev);
1011 #endif
1012 }
1013 }
1014 else {
1015 STp->drv_block = (-1);
1016 retval = (-EIO);
1017 }
1018
1019 SCpnt->request.rq_status = RQ_INACTIVE;
1020 (STp->buffer)->buffer_bytes = 0;
1021 STp->dirty = 0;
1022 if (count < total)
1023 return total - count;
1024 else
1025 return retval;
1026 }
1027 filp->f_pos += do_count;
1028 b_point += do_count;
1029 count -= do_count;
1030 if (STp->drv_block >= 0) {
1031 if (STp->block_size == 0)
1032 STp->drv_block++;
1033 else
1034 STp->drv_block += blks;
1035 }
1036 (STp->buffer)->buffer_bytes = 0;
1037 STp->dirty = 0;
1038 }
1039 if (count != 0) {
1040 STp->dirty = 1;
1041 memcpy_fromfs((STp->buffer)->b_data +
1042 (STp->buffer)->buffer_bytes,b_point,count);
1043 filp->f_pos += count;
1044 (STp->buffer)->buffer_bytes += count;
1045 count = 0;
1046 }
1047
1048 if (doing_write && (STp->buffer)->last_result_fatal != 0) {
1049 SCpnt->request.rq_status = RQ_INACTIVE;
1050 return (STp->buffer)->last_result_fatal;
1051 }
1052
1053 if (STm->do_async_writes &&
1054 ((STp->buffer)->buffer_bytes >= STp->write_threshold ||
1055 STp->block_size == 0) ) {
1056
1057 if (!SCpnt) {
1058 SCpnt = allocate_device(NULL, STp->device, 1);
1059 if (!SCpnt)
1060 return (-EBUSY);
1061 }
1062 if (STp->block_size == 0)
1063 (STp->buffer)->writing = (STp->buffer)->buffer_bytes;
1064 else
1065 (STp->buffer)->writing = ((STp->buffer)->buffer_bytes /
1066 STp->block_size) * STp->block_size;
1067 STp->dirty = !((STp->buffer)->writing ==
1068 (STp->buffer)->buffer_bytes);
1069
1070 if (STp->block_size == 0)
1071 blks = (STp->buffer)->writing;
1072 else
1073 blks = (STp->buffer)->writing / STp->block_size;
1074 cmd[2] = blks >> 16;
1075 cmd[3] = blks >> 8;
1076 cmd[4] = blks;
1077 STp->sem = MUTEX_LOCKED;
1078 SCpnt->request.sem = &(STp->sem);
1079 SCpnt->request.rq_status = RQ_SCSI_BUSY;
1080 SCpnt->request.rq_dev = STp->devt;
1081 #if DEBUG
1082 STp->write_pending = 1;
1083 #endif
1084
1085 scsi_do_cmd (SCpnt,
1086 (void *) cmd, (STp->buffer)->b_data,
1087 (STp->buffer)->writing,
1088 st_sleep_done, ST_TIMEOUT, MAX_WRITE_RETRIES);
1089 }
1090 else if (SCpnt != NULL)
1091 SCpnt->request.rq_status = RQ_INACTIVE;
1092
1093 STp->at_sm &= (total != 0);
1094 return( total);
1095 }
1096
1097
1098
1099 static int
1100 st_read(struct inode * inode, struct file * filp, char * buf, int count)
1101 {
1102 int total;
1103 int transfer, blks, bytes;
1104 static unsigned char cmd[10];
1105 Scsi_Cmnd * SCpnt = NULL;
1106 Scsi_Tape * STp;
1107 int dev = TAPE_NR(inode->i_rdev);
1108
1109 STp = &(scsi_tapes[dev]);
1110 if (STp->ready != ST_READY)
1111 return (-EIO);
1112 if (!STp->modes[STp->current_mode].defined)
1113 return (-ENXIO);
1114 #if DEBUG
1115 if (!STp->in_use) {
1116 printk(ST_DEB_MSG "st%d: Incorrect device.\n", dev);
1117 return (-EIO);
1118 }
1119 #endif
1120
1121 if (STp->block_size == 0 &&
1122 count > (STp->buffer)->buffer_size &&
1123 !enlarge_buffer(STp->buffer, count, STp->restr_dma))
1124 return (-EOVERFLOW);
1125
1126 if (!(STp->do_read_ahead) && STp->block_size != 0 &&
1127 (count % STp->block_size) != 0)
1128 return (-EIO);
1129
1130 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1131 !st_int_ioctl(inode, filp, MTLOCK, 0))
1132 STp->door_locked = ST_LOCKED_AUTO;
1133
1134 if (STp->rw == ST_WRITING) {
1135 transfer = flush_buffer(inode, filp, 0);
1136 if (transfer)
1137 return transfer;
1138 STp->rw = ST_READING;
1139 }
1140 if (STp->moves_after_eof < 255)
1141 STp->moves_after_eof++;
1142
1143 #if DEBUG
1144 if (debugging && STp->eof != ST_NOEOF)
1145 printk(ST_DEB_MSG "st%d: EOF flag up. Bytes %d\n", dev,
1146 (STp->buffer)->buffer_bytes);
1147 #endif
1148 if (((STp->buffer)->buffer_bytes == 0) &&
1149 (STp->eof == ST_EOM_OK || STp->eof == ST_EOD))
1150 return (-EIO);
1151
1152 STp->rw = ST_READING;
1153
1154 for (total = 0; total < count; ) {
1155
1156 if ((STp->buffer)->buffer_bytes == 0 &&
1157 STp->eof == ST_NOEOF) {
1158
1159 memset(cmd, 0, 10);
1160 cmd[0] = READ_6;
1161 cmd[1] = (STp->block_size != 0);
1162 if (STp->block_size == 0)
1163 blks = bytes = count;
1164 else {
1165 if (STp->do_read_ahead) {
1166 blks = (STp->buffer)->buffer_blocks;
1167 bytes = blks * STp->block_size;
1168 }
1169 else {
1170 bytes = count;
1171 if (bytes > (STp->buffer)->buffer_size)
1172 bytes = (STp->buffer)->buffer_size;
1173 blks = bytes / STp->block_size;
1174 bytes = blks * STp->block_size;
1175 }
1176 }
1177 cmd[2] = blks >> 16;
1178 cmd[3] = blks >> 8;
1179 cmd[4] = blks;
1180
1181 SCpnt = st_do_scsi(SCpnt, STp, cmd, bytes, ST_TIMEOUT, MAX_RETRIES);
1182 if (!SCpnt)
1183 return (-EBUSY);
1184
1185 (STp->buffer)->read_pointer = 0;
1186 STp->eof_hit = 0;
1187 STp->at_sm = 0;
1188
1189 if ((STp->buffer)->last_result_fatal) {
1190 #if DEBUG
1191 if (debugging)
1192 printk(ST_DEB_MSG "st%d: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1193 dev,
1194 SCpnt->sense_buffer[0], SCpnt->sense_buffer[1],
1195 SCpnt->sense_buffer[2], SCpnt->sense_buffer[3],
1196 SCpnt->sense_buffer[4], SCpnt->sense_buffer[5],
1197 SCpnt->sense_buffer[6], SCpnt->sense_buffer[7]);
1198 #endif
1199 if ((SCpnt->sense_buffer[0] & 0x70) == 0x70) {
1200
1201 if ((SCpnt->sense_buffer[2] & 0xe0) != 0) {
1202
1203 if ((SCpnt->sense_buffer[0] & 0x80) != 0)
1204 transfer = (SCpnt->sense_buffer[3] << 24) |
1205 (SCpnt->sense_buffer[4] << 16) |
1206 (SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
1207 else
1208 transfer = 0;
1209 if (STp->block_size == 0 &&
1210 (SCpnt->sense_buffer[2] & 0x0f) == MEDIUM_ERROR)
1211 transfer = bytes;
1212
1213 if (SCpnt->sense_buffer[2] & 0x20) {
1214 if (STp->block_size == 0) {
1215 if (transfer <= 0)
1216 transfer = 0;
1217 (STp->buffer)->buffer_bytes = bytes - transfer;
1218 }
1219 else {
1220 printk(KERN_NOTICE "st%d: Incorrect block size.\n", dev);
1221 SCpnt->request.rq_status = RQ_INACTIVE;
1222 return (-EIO);
1223 }
1224 }
1225 else if (SCpnt->sense_buffer[2] & 0x40) {
1226 STp->eof = ST_EOM_OK;
1227 if (STp->block_size == 0)
1228 (STp->buffer)->buffer_bytes = bytes - transfer;
1229 else
1230 (STp->buffer)->buffer_bytes =
1231 bytes - transfer * STp->block_size;
1232 #if DEBUG
1233 if (debugging)
1234 printk(ST_DEB_MSG "st%d: EOM detected (%d bytes read).\n", dev,
1235 (STp->buffer)->buffer_bytes);
1236 #endif
1237 }
1238 else if (SCpnt->sense_buffer[2] & 0x80) {
1239 STp->eof = ST_FM;
1240 if (STp->block_size == 0)
1241 (STp->buffer)->buffer_bytes = 0;
1242 else
1243 (STp->buffer)->buffer_bytes =
1244 bytes - transfer * STp->block_size;
1245 #if DEBUG
1246 if (debugging)
1247 printk(ST_DEB_MSG
1248 "st%d: EOF detected (%d bytes read, transferred %d bytes).\n",
1249 dev, (STp->buffer)->buffer_bytes, total);
1250 #endif
1251 }
1252 }
1253 else {
1254 #if DEBUG
1255 if (debugging)
1256 printk(ST_DEB_MSG "st%d: Tape error while reading.\n", dev);
1257 #endif
1258 SCpnt->request.rq_status = RQ_INACTIVE;
1259 STp->drv_block = (-1);
1260 if (total)
1261 return total;
1262 else if (STp->moves_after_eof == 1 &&
1263 (SCpnt->sense_buffer[2] & 0x0f) == BLANK_CHECK) {
1264 #if DEBUG
1265 if (debugging)
1266 printk(ST_DEB_MSG
1267 "st%d: Zero returned for first BLANK CHECK after EOF.\n",
1268 dev);
1269 #endif
1270 STp->eof = ST_EOD;
1271 return 0;
1272 }
1273 else
1274 return -EIO;
1275 }
1276 }
1277 else {
1278 transfer = (STp->buffer)->last_result_fatal;
1279 SCpnt->request.rq_status = RQ_INACTIVE;
1280 return transfer;
1281 }
1282 }
1283 else
1284 (STp->buffer)->buffer_bytes = bytes;
1285
1286 if (STp->drv_block >= 0) {
1287 if (STp->block_size == 0)
1288 STp->drv_block++;
1289 else
1290 STp->drv_block += (STp->buffer)->buffer_bytes / STp->block_size;
1291 }
1292
1293 }
1294
1295
1296 if ((STp->buffer)->buffer_bytes > 0) {
1297 #if DEBUG
1298 if (debugging && STp->eof != ST_NOEOF)
1299 printk(ST_DEB_MSG "st%d: EOF up. Left %d, needed %d.\n", dev,
1300 (STp->buffer)->buffer_bytes, count - total);
1301 #endif
1302 transfer = (STp->buffer)->buffer_bytes < count - total ?
1303 (STp->buffer)->buffer_bytes : count - total;
1304 memcpy_tofs(buf, (STp->buffer)->b_data +
1305 (STp->buffer)->read_pointer,transfer);
1306 filp->f_pos += transfer;
1307 buf += transfer;
1308 total += transfer;
1309 (STp->buffer)->buffer_bytes -= transfer;
1310 (STp->buffer)->read_pointer += transfer;
1311 }
1312 else if (STp->eof != ST_NOEOF) {
1313 STp->eof_hit = 1;
1314 if (SCpnt != NULL)
1315 SCpnt->request.rq_status = RQ_INACTIVE;
1316 if (total == 0 && STp->eof == ST_FM) {
1317 STp->eof = ST_NOEOF;
1318 STp->drv_block = 0;
1319 if (STp->moves_after_eof > 1)
1320 STp->moves_after_eof = 0;
1321 if ((STp->mt_status)->mt_fileno >= 0)
1322 (STp->mt_status)->mt_fileno++;
1323 }
1324 if (total == 0 && STp->eof == ST_EOM_OK)
1325 return (-EIO);
1326 return total;
1327 }
1328
1329 if (STp->block_size == 0)
1330 count = total;
1331
1332 }
1333
1334 if (SCpnt != NULL)
1335 SCpnt->request.rq_status = RQ_INACTIVE;
1336
1337 return total;
1338 }
1339
1340
1341
1342
1343 static void
1344 st_log_options(Scsi_Tape *STp, ST_mode *STm, int dev)
1345 {
1346 printk(KERN_INFO
1347 "st%d: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
1348 dev, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
1349 STp->do_read_ahead);
1350 printk(KERN_INFO
1351 "st%d: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d, defs for wr: %d \n",
1352 dev, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock,
1353 STm->defaults_for_writes);
1354 #if DEBUG
1355 printk(KERN_INFO
1356 "st%d: debugging: %d\n",
1357 dev, debugging);
1358 #endif
1359 }
1360
1361
1362 static int
1363 st_set_options(struct inode * inode, long options)
1364 {
1365 int value;
1366 long code;
1367 Scsi_Tape *STp;
1368 ST_mode *STm;
1369 int dev = TAPE_NR(inode->i_rdev);
1370
1371 STp = &(scsi_tapes[dev]);
1372 STm = &(STp->modes[STp->current_mode]);
1373 if (!STm->defined) {
1374 memcpy(STm, &(STp->modes[0]), sizeof(ST_mode));
1375 modes_defined = TRUE;
1376 #if DEBUG
1377 if (debugging)
1378 printk(ST_DEB_MSG "st%d: Initialized mode %d definition from mode 0\n",
1379 dev, STp->current_mode);
1380 #endif
1381 }
1382
1383 code = options & MT_ST_OPTIONS;
1384 if (code == MT_ST_BOOLEANS) {
1385 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
1386 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
1387 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
1388 STp->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
1389 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
1390 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
1391 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
1392 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
1393 #if DEBUG
1394 debugging = (options & MT_ST_DEBUGGING) != 0;
1395 #endif
1396 st_log_options(STp, STm, dev);
1397 }
1398 else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
1399 value = (code == MT_ST_SETBOOLEANS);
1400 if ((options & MT_ST_BUFFER_WRITES) != 0)
1401 STm->do_buffer_writes = value;
1402 if ((options & MT_ST_ASYNC_WRITES) != 0)
1403 STm->do_async_writes = value;
1404 if ((options & MT_ST_DEF_WRITES) != 0)
1405 STm->defaults_for_writes = value;
1406 if ((options & MT_ST_READ_AHEAD) != 0)
1407 STp->do_read_ahead = value;
1408 if ((options & MT_ST_TWO_FM) != 0)
1409 STp->two_fm = value;
1410 if ((options & MT_ST_FAST_MTEOM) != 0)
1411 STp->fast_mteom = value;
1412 if ((options & MT_ST_AUTO_LOCK) != 0)
1413 STp->do_auto_lock = value;
1414 if ((options & MT_ST_CAN_BSR) != 0)
1415 STp->can_bsr = value;
1416 #if DEBUG
1417 if ((options & MT_ST_DEBUGGING) != 0)
1418 debugging = value;
1419 #endif
1420 st_log_options(STp, STm, dev);
1421 }
1422 else if (code == MT_ST_WRITE_THRESHOLD) {
1423 value = (options & ~MT_ST_OPTIONS) * ST_BLOCK_SIZE;
1424 if (value < 1 || value > st_buffer_size) {
1425 printk(KERN_WARNING "st%d: Write threshold %d too small or too large.\n",
1426 dev, value);
1427 return (-EIO);
1428 }
1429 STp->write_threshold = value;
1430 printk(KERN_INFO "st%d: Write threshold set to %d bytes.\n",
1431 dev, value);
1432 }
1433 else if (code == MT_ST_DEF_BLKSIZE) {
1434 value = (options & ~MT_ST_OPTIONS);
1435 if (value == ~MT_ST_OPTIONS) {
1436 STm->default_blksize = (-1);
1437 printk(KERN_INFO "st%d: Default block size disabled.\n", dev);
1438 }
1439 else {
1440 STm->default_blksize = value;
1441 printk(KERN_INFO "st%d: Default block size set to %d bytes.\n",
1442 dev, STm->default_blksize);
1443 }
1444 }
1445 else if (code == MT_ST_DEF_OPTIONS) {
1446 code = (options & ~MT_ST_CLEAR_DEFAULT);
1447 value = (options & MT_ST_CLEAR_DEFAULT);
1448 if (code == MT_ST_DEF_DENSITY) {
1449 if (value == MT_ST_CLEAR_DEFAULT) {
1450 STm->default_density = (-1);
1451 printk(KERN_INFO "st%d: Density default disabled.\n", dev);
1452 }
1453 else {
1454 STm->default_density = value & 0xff;
1455 printk(KERN_INFO "st%d: Density default set to %x\n",
1456 dev, STm->default_density);
1457 }
1458 }
1459 else if (code == MT_ST_DEF_DRVBUFFER) {
1460 if (value == MT_ST_CLEAR_DEFAULT) {
1461 STp->default_drvbuffer = 0xff;
1462 printk(KERN_INFO "st%d: Drive buffer default disabled.\n", dev);
1463 }
1464 else {
1465 STp->default_drvbuffer = value & 7;
1466 printk(KERN_INFO "st%d: Drive buffer default set to %x\n",
1467 dev, STp->default_drvbuffer);
1468 }
1469 }
1470 else if (code == MT_ST_DEF_COMPRESSION) {
1471 if (value == MT_ST_CLEAR_DEFAULT) {
1472 STm->default_compression = ST_DONT_TOUCH;
1473 printk(KERN_INFO "st%d: Compression default disabled.\n", dev);
1474 }
1475 else {
1476 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
1477 printk(KERN_INFO "st%d: Compression default set to %x\n",
1478 dev, (value & 1));
1479 }
1480 }
1481 }
1482 else
1483 return (-EIO);
1484
1485 return 0;
1486 }
1487
1488
1489 #define COMPRESSION_PAGE 0x0f
1490 #define COMPRESSION_PAGE_LENGTH 16
1491
1492 #define MODE_HEADER_LENGTH 4
1493
1494 #define DCE_MASK 0x80
1495 #define DCC_MASK 0x40
1496 #define RED_MASK 0x60
1497
1498
1499
1500 static int
1501 st_compression(Scsi_Tape * STp, int state)
1502 {
1503 int dev;
1504 unsigned char cmd[10];
1505 Scsi_Cmnd * SCpnt = NULL;
1506
1507
1508 memset(cmd, 0, 10);
1509 cmd[0] = MODE_SENSE;
1510 cmd[1] = 8;
1511 cmd[2] = COMPRESSION_PAGE;
1512 cmd[4] = COMPRESSION_PAGE_LENGTH + MODE_HEADER_LENGTH;
1513
1514 SCpnt = st_do_scsi(SCpnt, STp, cmd, cmd[4], ST_TIMEOUT, 0);
1515 dev = TAPE_NR(SCpnt->request.rq_dev);
1516
1517 if ((STp->buffer)->last_result_fatal != 0) {
1518 #if DEBUG
1519 if (debugging)
1520 printk(ST_DEB_MSG "st%d: Compression mode page not supported.\n", dev);
1521 #endif
1522 SCpnt->request.rq_status = RQ_INACTIVE;
1523 return (-EIO);
1524 }
1525 #if DEBUG
1526 if (debugging)
1527 printk(ST_DEB_MSG "st%d: Compression state is %d.\n", dev,
1528 ((STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] & DCE_MASK ? 1 : 0));
1529 #endif
1530
1531
1532 if (((STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] & DCC_MASK) == 0) {
1533 #if DEBUG
1534 if (debugging)
1535 printk(ST_DEB_MSG "st%d: Compression not supported.\n", dev);
1536 #endif
1537 SCpnt->request.rq_status = RQ_INACTIVE;
1538 return (-EIO);
1539 }
1540
1541
1542 if (state)
1543 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] |= DCE_MASK;
1544 else
1545 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] &= ~DCE_MASK;
1546
1547 memset(cmd, 0, 10);
1548 cmd[0] = MODE_SELECT;
1549 cmd[1] = 0x10;
1550 cmd[4] = COMPRESSION_PAGE_LENGTH + MODE_HEADER_LENGTH;
1551
1552 (STp->buffer)->b_data[0] = 0;
1553 (STp->buffer)->b_data[1] = 0;
1554 (STp->buffer)->b_data[MODE_HEADER_LENGTH] &= 0x3f;
1555 SCpnt = st_do_scsi(SCpnt, STp, cmd, cmd[4], ST_TIMEOUT, 0);
1556
1557 if ((STp->buffer)->last_result_fatal != 0) {
1558 #if DEBUG
1559 if (debugging)
1560 printk(ST_DEB_MSG "st%d: Compression change failed.\n", dev);
1561 #endif
1562 SCpnt->request.rq_status = RQ_INACTIVE;
1563 return (-EIO);
1564 }
1565
1566 #if DEBUG
1567 if (debugging)
1568 printk(ST_DEB_MSG "st%d: Compression state changed to %d.\n",
1569 dev, state);
1570 #endif
1571
1572 SCpnt->request.rq_status = RQ_INACTIVE;
1573 STp->compression_changed = TRUE;
1574 return 0;
1575 }
1576
1577
1578
1579 static int
1580 st_int_ioctl(struct inode * inode,struct file * file,
1581 unsigned int cmd_in, unsigned long arg)
1582 {
1583 int timeout = ST_LONG_TIMEOUT;
1584 long ltmp;
1585 int ioctl_result;
1586 unsigned char cmd[10];
1587 Scsi_Cmnd * SCpnt;
1588 Scsi_Tape * STp;
1589 int fileno, blkno, at_sm, undone, datalen;
1590 int dev = TAPE_NR(inode->i_rdev);
1591
1592 STp = &(scsi_tapes[dev]);
1593 if (STp->ready != ST_READY && cmd_in != MTLOAD)
1594 return (-EIO);
1595 fileno = (STp->mt_status)->mt_fileno ;
1596 blkno = STp->drv_block;
1597 at_sm = STp->at_sm;
1598
1599 memset(cmd, 0, 10);
1600 datalen = 0;
1601 switch (cmd_in) {
1602 case MTFSF:
1603 case MTFSFM:
1604 cmd[0] = SPACE;
1605 cmd[1] = 0x01;
1606 cmd[2] = (arg >> 16);
1607 cmd[3] = (arg >> 8);
1608 cmd[4] = arg;
1609 #if DEBUG
1610 if (debugging)
1611 printk(ST_DEB_MSG "st%d: Spacing tape forward over %d filemarks.\n",
1612 dev, cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
1613 #endif
1614 if (fileno >= 0)
1615 fileno += arg;
1616 blkno = 0;
1617 at_sm &= (arg != 0);
1618 break;
1619 case MTBSF:
1620 case MTBSFM:
1621 cmd[0] = SPACE;
1622 cmd[1] = 0x01;
1623 ltmp = (-arg);
1624 cmd[2] = (ltmp >> 16);
1625 cmd[3] = (ltmp >> 8);
1626 cmd[4] = ltmp;
1627 #if DEBUG
1628 if (debugging) {
1629 if (cmd[2] & 0x80)
1630 ltmp = 0xff000000;
1631 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
1632 printk(ST_DEB_MSG "st%d: Spacing tape backward over %ld filemarks.\n",
1633 dev, (-ltmp));
1634 }
1635 #endif
1636 if (fileno >= 0)
1637 fileno -= arg;
1638 blkno = (-1);
1639 at_sm &= (arg != 0);
1640 break;
1641 case MTFSR:
1642 cmd[0] = SPACE;
1643 cmd[1] = 0x00;
1644 cmd[2] = (arg >> 16);
1645 cmd[3] = (arg >> 8);
1646 cmd[4] = arg;
1647 #if DEBUG
1648 if (debugging)
1649 printk(ST_DEB_MSG "st%d: Spacing tape forward %d blocks.\n", dev,
1650 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
1651 #endif
1652 if (blkno >= 0)
1653 blkno += arg;
1654 at_sm &= (arg != 0);
1655 break;
1656 case MTBSR:
1657 cmd[0] = SPACE;
1658 cmd[1] = 0x00;
1659 ltmp = (-arg);
1660 cmd[2] = (ltmp >> 16);
1661 cmd[3] = (ltmp >> 8);
1662 cmd[4] = ltmp;
1663 #if DEBUG
1664 if (debugging) {
1665 if (cmd[2] & 0x80)
1666 ltmp = 0xff000000;
1667 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
1668 printk(ST_DEB_MSG "st%d: Spacing tape backward %ld blocks.\n", dev, (-ltmp));
1669 }
1670 #endif
1671 if (blkno >= 0)
1672 blkno -= arg;
1673 at_sm &= (arg != 0);
1674 break;
1675 case MTFSS:
1676 cmd[0] = SPACE;
1677 cmd[1] = 0x04;
1678 cmd[2] = (arg >> 16);
1679 cmd[3] = (arg >> 8);
1680 cmd[4] = arg;
1681 #if DEBUG
1682 if (debugging)
1683 printk(ST_DEB_MSG "st%d: Spacing tape forward %d setmarks.\n", dev,
1684 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
1685 #endif
1686 if (arg != 0) {
1687 blkno = fileno = (-1);
1688 at_sm = 1;
1689 }
1690 break;
1691 case MTBSS:
1692 cmd[0] = SPACE;
1693 cmd[1] = 0x04;
1694 ltmp = (-arg);
1695 cmd[2] = (ltmp >> 16);
1696 cmd[3] = (ltmp >> 8);
1697 cmd[4] = ltmp;
1698 #if DEBUG
1699 if (debugging) {
1700 if (cmd[2] & 0x80)
1701 ltmp = 0xff000000;
1702 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
1703 printk(ST_DEB_MSG "st%d: Spacing tape backward %ld setmarks.\n",
1704 dev, (-ltmp));
1705 }
1706 #endif
1707 if (arg != 0) {
1708 blkno = fileno = (-1);
1709 at_sm = 1;
1710 }
1711 break;
1712 case MTWEOF:
1713 case MTWSM:
1714 if (STp->write_prot)
1715 return (-EACCES);
1716 cmd[0] = WRITE_FILEMARKS;
1717 if (cmd_in == MTWSM)
1718 cmd[1] = 2;
1719 cmd[2] = (arg >> 16);
1720 cmd[3] = (arg >> 8);
1721 cmd[4] = arg;
1722 timeout = ST_TIMEOUT;
1723 #if DEBUG
1724 if (debugging) {
1725 if (cmd_in == MTWEOF)
1726 printk(ST_DEB_MSG "st%d: Writing %d filemarks.\n", dev,
1727 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
1728 else
1729 printk(ST_DEB_MSG "st%d: Writing %d setmarks.\n", dev,
1730 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
1731 }
1732 #endif
1733 if (fileno >= 0)
1734 fileno += arg;
1735 blkno = 0;
1736 at_sm = (cmd_in == MTWSM);
1737 break;
1738 case MTREW:
1739 cmd[0] = REZERO_UNIT;
1740 #if ST_NOWAIT
1741 cmd[1] = 1;
1742 timeout = ST_TIMEOUT;
1743 #endif
1744 #if DEBUG
1745 if (debugging)
1746 printk(ST_DEB_MSG "st%d: Rewinding tape.\n", dev);
1747 #endif
1748 fileno = blkno = at_sm = 0 ;
1749 break;
1750 case MTOFFL:
1751 case MTLOAD:
1752 case MTUNLOAD:
1753 cmd[0] = START_STOP;
1754 if (cmd_in == MTLOAD)
1755 cmd[4] |= 1;
1756 #if ST_NOWAIT
1757 cmd[1] = 1;
1758 timeout = ST_TIMEOUT;
1759 #else
1760 timeout = ST_LONG_TIMEOUT * 8;
1761 #endif
1762 #if DEBUG
1763 if (debugging) {
1764 if (cmd_in != MTLOAD)
1765 printk(ST_DEB_MSG "st%d: Unloading tape.\n", dev);
1766 else
1767 printk(ST_DEB_MSG "st%d: Loading tape.\n", dev);
1768 }
1769 #endif
1770 fileno = blkno = at_sm = 0 ;
1771 break;
1772 case MTNOP:
1773 #if DEBUG
1774 if (debugging)
1775 printk(ST_DEB_MSG "st%d: No op on tape.\n", dev);
1776 #endif
1777 return 0;
1778 break;
1779 case MTRETEN:
1780 cmd[0] = START_STOP;
1781 #if ST_NOWAIT
1782 cmd[1] = 1;
1783 timeout = ST_TIMEOUT;
1784 #endif
1785 cmd[4] = 3;
1786 #if DEBUG
1787 if (debugging)
1788 printk(ST_DEB_MSG "st%d: Retensioning tape.\n", dev);
1789 #endif
1790 fileno = blkno = at_sm = 0;
1791 break;
1792 case MTEOM:
1793 if (!STp->fast_mteom) {
1794
1795 ioctl_result = st_int_ioctl(inode, file, MTFSF, 0x3fff);
1796 fileno = (STp->mt_status)->mt_fileno ;
1797 if (STp->eof == ST_EOD || STp->eof == ST_EOM_OK)
1798 return 0;
1799
1800
1801
1802
1803 }
1804 else
1805 fileno = (-1);
1806 cmd[0] = SPACE;
1807 cmd[1] = 3;
1808 #if DEBUG
1809 if (debugging)
1810 printk(ST_DEB_MSG "st%d: Spacing to end of recorded medium.\n", dev);
1811 #endif
1812 blkno = 0;
1813 at_sm = 0;
1814 break;
1815 case MTERASE:
1816 if (STp->write_prot)
1817 return (-EACCES);
1818 cmd[0] = ERASE;
1819 cmd[1] = 1;
1820 #if ST_NOWAIT
1821 cmd[1] |= 2;
1822 timeout = ST_TIMEOUT;
1823 #else
1824 timeout = ST_LONG_TIMEOUT * 8;
1825 #endif
1826 #if DEBUG
1827 if (debugging)
1828 printk(ST_DEB_MSG "st%d: Erasing tape.\n", dev);
1829 #endif
1830 fileno = blkno = at_sm = 0 ;
1831 break;
1832 case MTLOCK:
1833 cmd[0] = ALLOW_MEDIUM_REMOVAL;
1834 cmd[4] = SCSI_REMOVAL_PREVENT;
1835 #if DEBUG
1836 if (debugging)
1837 printk(ST_DEB_MSG "st%d: Locking drive door.\n", dev);
1838 #endif;
1839 break;
1840 case MTUNLOCK:
1841 cmd[0] = ALLOW_MEDIUM_REMOVAL;
1842 cmd[4] = SCSI_REMOVAL_ALLOW;
1843 #if DEBUG
1844 if (debugging)
1845 printk(ST_DEB_MSG "st%d: Unlocking drive door.\n", dev);
1846 #endif;
1847 break;
1848 case MTSEEK:
1849 if ((STp->device)->scsi_level < SCSI_2) {
1850 cmd[0] = QFA_SEEK_BLOCK;
1851 cmd[2] = (arg >> 16);
1852 cmd[3] = (arg >> 8);
1853 cmd[4] = arg;
1854 cmd[5] = 0;
1855 }
1856 else {
1857 cmd[0] = SEEK_10;
1858 cmd[1] = 4;
1859 cmd[3] = (arg >> 24);
1860 cmd[4] = (arg >> 16);
1861 cmd[5] = (arg >> 8);
1862 cmd[6] = arg;
1863 }
1864 #if ST_NOWAIT
1865 cmd[1] |= 1;
1866 timeout = ST_TIMEOUT;
1867 #endif
1868 #if DEBUG
1869 if (debugging)
1870 printk(ST_DEB_MSG "st%d: Seeking tape to block %ld.\n", dev, arg);
1871 #endif
1872 fileno = blkno = (-1);
1873 at_sm = 0;
1874 break;
1875 case MTSETBLK:
1876 case MTSETDENSITY:
1877 case MTSETDRVBUFFER:
1878 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
1879 return (-EIO);
1880 if (cmd_in == MTSETBLK &&
1881 arg != 0 &&
1882 (arg < STp->min_block || arg > STp->max_block ||
1883 arg > st_buffer_size)) {
1884 printk(KERN_WARNING "st%d: Illegal block size.\n", dev);
1885 return (-EINVAL);
1886 }
1887 cmd[0] = MODE_SELECT;
1888 cmd[4] = datalen = 12;
1889
1890 memset((STp->buffer)->b_data, 0, 12);
1891 if (cmd_in == MTSETDRVBUFFER)
1892 (STp->buffer)->b_data[2] = (arg & 7) << 4;
1893 else
1894 (STp->buffer)->b_data[2] =
1895 STp->drv_buffer << 4;
1896 (STp->buffer)->b_data[3] = 8;
1897 if (cmd_in == MTSETDENSITY) {
1898 (STp->buffer)->b_data[4] = arg;
1899 STp->density_changed = TRUE;
1900 }
1901 else
1902 (STp->buffer)->b_data[4] = STp->density;
1903 if (cmd_in == MTSETBLK) {
1904 ltmp = arg;
1905 STp->blksize_changed = TRUE;
1906 }
1907 else
1908 ltmp = STp->block_size;
1909 (STp->buffer)->b_data[9] = (ltmp >> 16);
1910 (STp->buffer)->b_data[10] = (ltmp >> 8);
1911 (STp->buffer)->b_data[11] = ltmp;
1912 timeout = ST_TIMEOUT;
1913 #if DEBUG
1914 if (debugging) {
1915 if (cmd_in == MTSETBLK)
1916 printk(ST_DEB_MSG "st%d: Setting block size to %d bytes.\n", dev,
1917 (STp->buffer)->b_data[9] * 65536 +
1918 (STp->buffer)->b_data[10] * 256 +
1919 (STp->buffer)->b_data[11]);
1920 else if (cmd_in == MTSETDENSITY)
1921 printk(ST_DEB_MSG "st%d: Setting density code to %x.\n", dev,
1922 (STp->buffer)->b_data[4]);
1923 else
1924 printk(ST_DEB_MSG "st%d: Setting drive buffer code to %d.\n", dev,
1925 ((STp->buffer)->b_data[2] >> 4) & 7);
1926 }
1927 #endif
1928 break;
1929 default:
1930 return (-ENOSYS);
1931 }
1932
1933 SCpnt = st_do_scsi(NULL, STp, cmd, datalen, timeout, MAX_RETRIES);
1934 if (!SCpnt)
1935 return (-EBUSY);
1936
1937 ioctl_result = (STp->buffer)->last_result_fatal;
1938
1939 SCpnt->request.rq_status = RQ_INACTIVE;
1940
1941 if (cmd_in == MTFSF)
1942 STp->moves_after_eof = 0;
1943 else
1944 STp->moves_after_eof = 1;
1945 if (!ioctl_result) {
1946 if (cmd_in != MTSEEK) {
1947 STp->drv_block = blkno;
1948 (STp->mt_status)->mt_fileno = fileno;
1949 STp->at_sm = at_sm;
1950 }
1951 else {
1952 STp->drv_block = (STp->mt_status)->mt_fileno = (-1);
1953 STp->at_sm = 0;
1954 }
1955 if (cmd_in == MTLOCK)
1956 STp->door_locked = ST_LOCKED_EXPLICIT;
1957 else if (cmd_in == MTUNLOCK)
1958 STp->door_locked = ST_UNLOCKED;
1959 if (cmd_in == MTBSFM)
1960 ioctl_result = st_int_ioctl(inode, file, MTFSF, 1);
1961 else if (cmd_in == MTFSFM)
1962 ioctl_result = st_int_ioctl(inode, file, MTBSF, 1);
1963 else if (cmd_in == MTSETBLK) {
1964 STp->block_size = arg;
1965 if (arg != 0)
1966 (STp->buffer)->buffer_blocks =
1967 (STp->buffer)->buffer_size / STp->block_size;
1968 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1969 }
1970 else if (cmd_in == MTSETDRVBUFFER)
1971 STp->drv_buffer = (arg & 7);
1972 else if (cmd_in == MTSETDENSITY)
1973 STp->density = arg;
1974 else if (cmd_in == MTEOM) {
1975 STp->eof = ST_EOD;
1976 STp->eof_hit = 0;
1977 }
1978 else if (cmd_in != MTSETBLK && cmd_in != MTNOP) {
1979 STp->eof = ST_NOEOF;
1980 STp->eof_hit = 0;
1981 }
1982 if (cmd_in == MTOFFL || cmd_in == MTUNLOAD)
1983 STp->rew_at_close = 0;
1984 else if (cmd_in == MTLOAD)
1985 STp->rew_at_close = (MINOR(inode->i_rdev) & 0x80) == 0;
1986 } else {
1987 if (SCpnt->sense_buffer[2] & 0x40) {
1988 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
1989 cmd_in != MTBSR && cmd_in != MTBSS)
1990 STp->eof = ST_EOM_OK;
1991 STp->eof_hit = 0;
1992 STp->drv_block = 0;
1993 }
1994 undone = (
1995 (SCpnt->sense_buffer[3] << 24) +
1996 (SCpnt->sense_buffer[4] << 16) +
1997 (SCpnt->sense_buffer[5] << 8) +
1998 SCpnt->sense_buffer[6] );
1999 if ( (cmd_in == MTFSF) || (cmd_in == MTFSFM) ) {
2000 if (fileno >= 0)
2001 (STp->mt_status)->mt_fileno = fileno - undone ;
2002 else
2003 (STp->mt_status)->mt_fileno = fileno;
2004 STp->drv_block = 0;
2005 }
2006 else if ( (cmd_in == MTBSF) || (cmd_in == MTBSFM) ) {
2007 (STp->mt_status)->mt_fileno = fileno + undone ;
2008 STp->drv_block = 0;
2009 }
2010 else if (cmd_in == MTFSR) {
2011 if (SCpnt->sense_buffer[2] & 0x80) {
2012 (STp->mt_status)->mt_fileno++;
2013 STp->drv_block = 0;
2014 }
2015 else {
2016 if (blkno >= undone)
2017 STp->drv_block = blkno - undone;
2018 else
2019 STp->drv_block = (-1);
2020 }
2021 }
2022 else if (cmd_in == MTBSR) {
2023 if (SCpnt->sense_buffer[2] & 0x80) {
2024 (STp->mt_status)->mt_fileno--;
2025 STp->drv_block = (-1);
2026 }
2027 else {
2028 if (blkno >= 0)
2029 STp->drv_block = blkno + undone;
2030 else
2031 STp->drv_block = (-1);
2032 }
2033 }
2034 else if (cmd_in == MTEOM || cmd_in == MTSEEK) {
2035 (STp->mt_status)->mt_fileno = (-1);
2036 STp->drv_block = (-1);
2037 }
2038 if (STp->eof == ST_NOEOF &&
2039 (SCpnt->sense_buffer[2] & 0x0f) == BLANK_CHECK)
2040 STp->eof = ST_EOD;
2041 if (cmd_in == MTLOCK)
2042 STp->door_locked = ST_LOCK_FAILS;
2043 }
2044
2045 return ioctl_result;
2046 }
2047
2048
2049
2050
2051 static int
2052 st_ioctl(struct inode * inode,struct file * file,
2053 unsigned int cmd_in, unsigned long arg)
2054 {
2055 int i, cmd_nr, cmd_type, result;
2056 struct mtop mtc;
2057 struct mtpos mt_pos;
2058 unsigned char scmd[10];
2059 Scsi_Cmnd *SCpnt;
2060 Scsi_Tape *STp;
2061 ST_mode *STm;
2062 int dev = TAPE_NR(inode->i_rdev);
2063
2064 STp = &(scsi_tapes[dev]);
2065 #if DEBUG
2066 if (debugging && !STp->in_use) {
2067 printk(ST_DEB_MSG "st%d: Incorrect device.\n", dev);
2068 return (-EIO);
2069 }
2070 #endif
2071 STm = &(STp->modes[STp->current_mode]);
2072
2073
2074
2075
2076
2077 if( cmd_in == SCSI_IOCTL_GET_IDLUN || cmd_in == SCSI_IOCTL_PROBE_HOST )
2078 {
2079 return scsi_ioctl(STp->device, cmd_in, (void *) arg);
2080 }
2081
2082 cmd_type = _IOC_TYPE(cmd_in);
2083 cmd_nr = _IOC_NR(cmd_in);
2084 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
2085 if (_IOC_SIZE(cmd_in) != sizeof(mtc))
2086 return (-EINVAL);
2087
2088 i = verify_area(VERIFY_READ, (void *)arg, sizeof(mtc));
2089 if (i)
2090 return i;
2091
2092 memcpy_fromfs((char *) &mtc, (char *)arg, sizeof(struct mtop));
2093
2094 if (mtc.mt_op == MTSETDRVBUFFER && !suser()) {
2095 printk(KERN_WARNING "st%d: MTSETDRVBUFFER only allowed for root.\n", dev);
2096 return (-EPERM);
2097 }
2098 if (!STm->defined &&
2099 (mtc.mt_op != MTSETDRVBUFFER && (mtc.mt_count & MT_ST_OPTIONS) == 0))
2100 return (-ENXIO);
2101
2102 if (!(STp->device)->was_reset) {
2103
2104 if (STp->eof_hit) {
2105 if (mtc.mt_op == MTFSF || mtc.mt_op == MTEOM) {
2106 mtc.mt_count -= 1;
2107 (STp->mt_status)->mt_fileno += 1;
2108 }
2109 else if (mtc.mt_op == MTBSF) {
2110 mtc.mt_count += 1;
2111 (STp->mt_status)->mt_fileno += 1;
2112 }
2113 }
2114
2115 i = flush_buffer(inode, file, mtc.mt_op == MTSEEK ||
2116 mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
2117 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
2118 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
2119 mtc.mt_op == MTCOMPRESSION);
2120 if (i < 0)
2121 return i;
2122 }
2123 else {
2124
2125
2126
2127
2128
2129 if(mtc.mt_op != MTREW &&
2130 mtc.mt_op != MTOFFL &&
2131 mtc.mt_op != MTRETEN &&
2132 mtc.mt_op != MTERASE &&
2133 mtc.mt_op != MTSEEK &&
2134 mtc.mt_op != MTEOM)
2135 return (-EIO);
2136 STp->device->was_reset = 0;
2137 if (STp->door_locked != ST_UNLOCKED &&
2138 STp->door_locked != ST_LOCK_FAILS) {
2139 if (st_int_ioctl(inode, file, MTLOCK, 0)) {
2140 printk(KERN_NOTICE "st%d: Could not relock door after bus reset.\n",
2141 dev);
2142 STp->door_locked = ST_UNLOCKED;
2143 }
2144 }
2145 }
2146
2147 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
2148 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
2149 mtc.mt_op != MTSETDRVBUFFER)
2150 STp->rw = ST_IDLE;
2151
2152 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
2153 st_int_ioctl(inode, file, MTUNLOCK, 0);
2154
2155 if (mtc.mt_op == MTSETDRVBUFFER &&
2156 (mtc.mt_count & MT_ST_OPTIONS) != 0)
2157 return st_set_options(inode, mtc.mt_count);
2158 else if (mtc.mt_op == MTCOMPRESSION)
2159 return st_compression(STp, (mtc.mt_count & 1));
2160 else
2161 return st_int_ioctl(inode, file, mtc.mt_op, mtc.mt_count);
2162 }
2163
2164 if (!STm->defined)
2165 return (-ENXIO);
2166
2167 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
2168
2169 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget))
2170 return (-EINVAL);
2171 i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct mtget));
2172 if (i)
2173 return i;
2174
2175 i = flush_buffer(inode, file, FALSE);
2176 if (i < 0)
2177 return i;
2178
2179 (STp->mt_status)->mt_dsreg =
2180 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
2181 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
2182 (STp->mt_status)->mt_blkno = STp->drv_block;
2183 if (STp->block_size != 0) {
2184 if (STp->rw == ST_WRITING)
2185 (STp->mt_status)->mt_blkno +=
2186 (STp->buffer)->buffer_bytes / STp->block_size;
2187 else if (STp->rw == ST_READING)
2188 (STp->mt_status)->mt_blkno -= ((STp->buffer)->buffer_bytes +
2189 STp->block_size - 1) / STp->block_size;
2190 }
2191
2192 (STp->mt_status)->mt_gstat = 0;
2193 if (STp->drv_write_prot)
2194 (STp->mt_status)->mt_gstat |= GMT_WR_PROT(0xffffffff);
2195 if ((STp->mt_status)->mt_blkno == 0) {
2196 if ((STp->mt_status)->mt_fileno == 0)
2197 (STp->mt_status)->mt_gstat |= GMT_BOT(0xffffffff);
2198 else
2199 (STp->mt_status)->mt_gstat |= GMT_EOF(0xffffffff);
2200 }
2201 if (STp->eof == ST_EOM_OK || STp->eof == ST_EOM_ERROR)
2202 (STp->mt_status)->mt_gstat |= GMT_EOT(0xffffffff);
2203 else if (STp->eof == ST_EOD)
2204 (STp->mt_status)->mt_gstat |= GMT_EOD(0xffffffff);
2205 if (STp->density == 1)
2206 (STp->mt_status)->mt_gstat |= GMT_D_800(0xffffffff);
2207 else if (STp->density == 2)
2208 (STp->mt_status)->mt_gstat |= GMT_D_1600(0xffffffff);
2209 else if (STp->density == 3)
2210 (STp->mt_status)->mt_gstat |= GMT_D_6250(0xffffffff);
2211 if (STp->ready == ST_READY)
2212 (STp->mt_status)->mt_gstat |= GMT_ONLINE(0xffffffff);
2213 if (STp->ready == ST_NO_TAPE)
2214 (STp->mt_status)->mt_gstat |= GMT_DR_OPEN(0xffffffff);
2215 if (STp->at_sm)
2216 (STp->mt_status)->mt_gstat |= GMT_SM(0xffffffff);
2217
2218 memcpy_tofs((char *)arg, (char *)(STp->mt_status),
2219 sizeof(struct mtget));
2220
2221 (STp->mt_status)->mt_erreg = 0;
2222 return 0;
2223 }
2224 else if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
2225 if (STp->ready != ST_READY)
2226 return (-EIO);
2227 #if DEBUG
2228 if (debugging)
2229 printk(ST_DEB_MSG "st%d: get tape position.\n", dev);
2230 #endif
2231 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos))
2232 return (-EINVAL);
2233
2234 i = flush_buffer(inode, file, 0);
2235 if (i < 0)
2236 return i;
2237
2238 i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct mtpos));
2239 if (i)
2240 return i;
2241
2242 memset (scmd, 0, 10);
2243 if ((STp->device)->scsi_level < SCSI_2) {
2244 scmd[0] = QFA_REQUEST_BLOCK;
2245 scmd[4] = 3;
2246 }
2247 else {
2248 scmd[0] = READ_POSITION;
2249 scmd[1] = 1;
2250 }
2251 SCpnt = st_do_scsi(NULL, STp, scmd, 20, ST_TIMEOUT, MAX_READY_RETRIES);
2252 if (!SCpnt)
2253 return (-EBUSY);
2254
2255 if ((STp->buffer)->last_result_fatal != 0) {
2256 mt_pos.mt_blkno = (-1);
2257 #if DEBUG
2258 if (debugging)
2259 printk(ST_DEB_MSG "st%d: Can't read tape position.\n", dev);
2260 #endif
2261 result = (-EIO);
2262 }
2263 else {
2264 result = 0;
2265 if ((STp->device)->scsi_level < SCSI_2)
2266 mt_pos.mt_blkno = ((STp->buffer)->b_data[0] << 16)
2267 + ((STp->buffer)->b_data[1] << 8)
2268 + (STp->buffer)->b_data[2];
2269 else
2270 mt_pos.mt_blkno = ((STp->buffer)->b_data[4] << 24)
2271 + ((STp->buffer)->b_data[5] << 16)
2272 + ((STp->buffer)->b_data[6] << 8)
2273 + (STp->buffer)->b_data[7];
2274
2275 }
2276
2277 SCpnt->request.rq_status = RQ_INACTIVE;
2278
2279 memcpy_tofs((char *)arg, (char *) (&mt_pos), sizeof(struct mtpos));
2280 return result;
2281 }
2282 else
2283 return scsi_ioctl(STp->device, cmd_in, (void *) arg);
2284 }
2285
2286
2287
2288 static ST_buffer *
2289 new_tape_buffer( int from_initialization, int need_dma )
2290 {
2291 int priority, a_size;
2292 ST_buffer *tb;
2293
2294 if (st_nbr_buffers >= st_template.dev_max)
2295 return NULL;
2296
2297 if (from_initialization) {
2298 priority = GFP_ATOMIC;
2299 a_size = st_buffer_size;
2300 }
2301 else {
2302 priority = GFP_KERNEL;
2303 for (a_size = PAGE_SIZE; a_size < st_buffer_size; a_size <<= 1)
2304 ;
2305 }
2306 tb = (ST_buffer *)scsi_init_malloc(sizeof(ST_buffer), priority);
2307 if (tb) {
2308 if (need_dma)
2309 priority |= GFP_DMA;
2310 tb->b_data = (unsigned char *)scsi_init_malloc(a_size, priority);
2311 if (!tb->b_data) {
2312 scsi_init_free((char *)tb, sizeof(ST_buffer));
2313 tb = NULL;
2314 }
2315 }
2316 if (!tb) {
2317 printk(KERN_NOTICE "st: Can't allocate new tape buffer (nbr %d).\n",
2318 st_nbr_buffers);
2319 return NULL;
2320 }
2321 #if DEBUG
2322 if (debugging)
2323 printk(ST_DEB_MSG
2324 "st: Allocated tape buffer %d (%d bytes, dma: %d, a: %p).\n",
2325 st_nbr_buffers, a_size, need_dma, tb->b_data);
2326 #endif
2327 tb->in_use = 0;
2328 tb->dma = need_dma;
2329 tb->buffer_size = a_size;
2330 tb->writing = 0;
2331 tb->orig_b_data = NULL;
2332 st_buffers[st_nbr_buffers++] = tb;
2333 return tb;
2334 }
2335
2336
2337
2338 static int
2339 enlarge_buffer(ST_buffer *STbuffer, int new_size, int need_dma)
2340 {
2341 int a_size, priority;
2342 unsigned char *tbd;
2343
2344 normalize_buffer(STbuffer);
2345
2346 for (a_size = PAGE_SIZE; a_size < new_size; a_size <<= 1)
2347 ;
2348
2349 priority = GFP_KERNEL;
2350 if (need_dma)
2351 priority |= GFP_DMA;
2352 tbd = (unsigned char *)scsi_init_malloc(a_size, priority);
2353 if (!tbd)
2354 return FALSE;
2355 #if DEBUG
2356 if (debugging)
2357 printk(ST_DEB_MSG
2358 "st: Buffer at %p enlarged to %d bytes (dma: %d, a: %p).\n",
2359 STbuffer->b_data, a_size, need_dma, tbd);
2360 #endif
2361
2362 STbuffer->orig_b_data = STbuffer->b_data;
2363 STbuffer->orig_size = STbuffer->buffer_size;
2364 STbuffer->b_data = tbd;
2365 STbuffer->buffer_size = a_size;
2366 return TRUE;
2367 }
2368
2369
2370
2371 static void
2372 normalize_buffer(ST_buffer *STbuffer)
2373 {
2374 if (STbuffer->orig_b_data == NULL)
2375 return;
2376
2377 scsi_init_free(STbuffer->b_data, STbuffer->buffer_size);
2378 STbuffer->b_data = STbuffer->orig_b_data;
2379 STbuffer->orig_b_data = NULL;
2380 STbuffer->buffer_size = STbuffer->orig_size;
2381
2382 #if DEBUG
2383 if (debugging)
2384 printk(ST_DEB_MSG "st: Buffer at %p normalized to %d bytes.\n",
2385 STbuffer->b_data, STbuffer->buffer_size);
2386 #endif
2387 }
2388
2389
2390
2391
2392
2393 void
2394 st_setup(char *str, int *ints)
2395 {
2396 if (ints[0] > 0 && ints[1] > 0)
2397 st_buffer_size = ints[1] * ST_BLOCK_SIZE;
2398 if (ints[0] > 1 && ints[2] > 0) {
2399 st_write_threshold = ints[2] * ST_BLOCK_SIZE;
2400 if (st_write_threshold > st_buffer_size)
2401 st_write_threshold = st_buffer_size;
2402 }
2403 if (ints[0] > 2 && ints[3] > 0)
2404 st_max_buffers = ints[3];
2405 }
2406
2407
2408 static struct file_operations st_fops = {
2409 NULL,
2410 st_read,
2411 st_write,
2412 NULL,
2413 NULL,
2414 st_ioctl,
2415 NULL,
2416 scsi_tape_open,
2417 scsi_tape_close,
2418 NULL
2419 };
2420
2421 static int st_attach(Scsi_Device * SDp){
2422 Scsi_Tape * tpnt;
2423 int i;
2424
2425 if(SDp->type != TYPE_TAPE) return 1;
2426
2427 if(st_template.nr_dev >= st_template.dev_max)
2428 {
2429 SDp->attached--;
2430 return 1;
2431 }
2432
2433 for(tpnt = scsi_tapes, i=0; i<st_template.dev_max; i++, tpnt++)
2434 if(!tpnt->device) break;
2435
2436 if(i >= st_template.dev_max) panic ("scsi_devices corrupt (st)");
2437
2438 scsi_tapes[i].device = SDp;
2439 if (SDp->scsi_level <= 2)
2440 scsi_tapes[i].mt_status->mt_type = MT_ISSCSI1;
2441 else
2442 scsi_tapes[i].mt_status->mt_type = MT_ISSCSI2;
2443
2444 tpnt->devt = MKDEV(SCSI_TAPE_MAJOR, i);
2445 tpnt->dirty = 0;
2446 tpnt->rw = ST_IDLE;
2447 tpnt->eof = ST_NOEOF;
2448 tpnt->waiting = NULL;
2449 tpnt->in_use = 0;
2450 tpnt->drv_buffer = 1;
2451 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
2452 tpnt->density = 0;
2453 tpnt->do_read_ahead = ST_READ_AHEAD;
2454 tpnt->do_auto_lock = ST_AUTO_LOCK;
2455 tpnt->can_bsr = ST_IN_FILE_POS;
2456 tpnt->two_fm = ST_TWO_FM;
2457 tpnt->fast_mteom = ST_FAST_MTEOM;
2458 tpnt->write_threshold = st_write_threshold;
2459 tpnt->default_drvbuffer = 0xff;
2460 tpnt->drv_block = (-1);
2461 tpnt->moves_after_eof = 1;
2462 tpnt->at_sm = 0;
2463 (tpnt->mt_status)->mt_fileno = (tpnt->mt_status)->mt_blkno = (-1);
2464
2465 for (i=0; i < ST_NBR_MODES; i++) {
2466 tpnt->modes[i].defined = FALSE;
2467 tpnt->modes[i].defaults_for_writes = 0;
2468 tpnt->modes[i].do_async_writes = ST_ASYNC_WRITES;
2469 tpnt->modes[i].do_buffer_writes = ST_BUFFER_WRITES;
2470 tpnt->modes[i].default_compression = ST_DONT_TOUCH;
2471 tpnt->modes[i].default_blksize = (-1);
2472 tpnt->modes[i].default_density = (-1);
2473 }
2474 tpnt->current_mode = 0;
2475 tpnt->modes[0].defined = TRUE;
2476
2477 tpnt->density_changed = tpnt->compression_changed =
2478 tpnt->blksize_changed = FALSE;
2479
2480 st_template.nr_dev++;
2481 return 0;
2482 };
2483
2484 static int st_detect(Scsi_Device * SDp)
2485 {
2486 if(SDp->type != TYPE_TAPE) return 0;
2487
2488 printk("Detected scsi tape st%d at scsi%d, channel %d, id %d, lun %d\n",
2489 st_template.dev_noticed++,
2490 SDp->host->host_no, SDp->channel, SDp->id, SDp->lun);
2491
2492 return 1;
2493 }
2494
2495 static int st_registered = 0;
2496
2497
2498 static int st_init()
2499 {
2500 int i;
2501 Scsi_Tape * STp;
2502 #if !ST_RUNTIME_BUFFERS
2503 int target_nbr;
2504 #endif
2505
2506 if (st_template.dev_noticed == 0) return 0;
2507
2508 if(!st_registered) {
2509 if (register_chrdev(SCSI_TAPE_MAJOR,"st",&st_fops)) {
2510 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",MAJOR_NR);
2511 return 1;
2512 }
2513 st_registered++;
2514 }
2515
2516 if (scsi_tapes) return 0;
2517 st_template.dev_max = st_template.dev_noticed + ST_EXTRA_DEVS;
2518 if (st_template.dev_max < ST_MAX_TAPES)
2519 st_template.dev_max = ST_MAX_TAPES;
2520 if (st_template.dev_max > 128 / ST_NBR_MODES)
2521 printk(KERN_INFO "st: Only %d tapes accessible.\n", 128 / ST_NBR_MODES);
2522 scsi_tapes =
2523 (Scsi_Tape *) scsi_init_malloc(st_template.dev_max * sizeof(Scsi_Tape),
2524 GFP_ATOMIC);
2525 if (scsi_tapes == NULL) {
2526 printk(KERN_ERR "Unable to allocate descriptors for SCSI tapes.\n");
2527 unregister_chrdev(SCSI_TAPE_MAJOR, "st");
2528 return 1;
2529 }
2530
2531 #if DEBUG
2532 printk(ST_DEB_MSG "st: Buffer size %d bytes, write threshold %d bytes.\n",
2533 st_buffer_size, st_write_threshold);
2534 #endif
2535
2536 memset(scsi_tapes, 0, st_template.dev_max * sizeof(Scsi_Tape));
2537 for (i=0; i < st_template.dev_max; ++i) {
2538 STp = &(scsi_tapes[i]);
2539 STp->capacity = 0xfffff;
2540 STp->mt_status = (struct mtget *) scsi_init_malloc(sizeof(struct mtget),
2541 GFP_ATOMIC);
2542
2543 memset((void *) scsi_tapes[i].mt_status, 0, sizeof(struct mtget));
2544 }
2545
2546
2547 st_buffers =
2548 (ST_buffer **) scsi_init_malloc(st_template.dev_max * sizeof(ST_buffer *),
2549 GFP_ATOMIC);
2550 if (st_buffers == NULL) {
2551 printk(KERN_ERR "Unable to allocate tape buffer pointers.\n");
2552 unregister_chrdev(SCSI_TAPE_MAJOR, "st");
2553 scsi_init_free((char *) scsi_tapes,
2554 st_template.dev_max * sizeof(Scsi_Tape));
2555 return 1;
2556 }
2557
2558 #if ST_RUNTIME_BUFFERS
2559 st_nbr_buffers = 0;
2560 #else
2561 target_nbr = st_template.dev_noticed;
2562 if (target_nbr < ST_EXTRA_DEVS)
2563 target_nbr = ST_EXTRA_DEVS;
2564 if (target_nbr > st_max_buffers)
2565 target_nbr = st_max_buffers;
2566
2567 for (i=st_nbr_buffers=0; i < target_nbr; i++) {
2568 if (!new_tape_buffer(TRUE, TRUE)) {
2569 if (i == 0) {
2570 #if 0
2571 printk(KERN_ERR "Can't continue without at least one tape buffer.\n");
2572 unregister_chrdev(SCSI_TAPE_MAJOR, "st");
2573 scsi_init_free((char *) st_buffers,
2574 st_template.dev_max * sizeof(ST_buffer *));
2575 scsi_init_free((char *) scsi_tapes,
2576 st_template.dev_max * sizeof(Scsi_Tape));
2577 return 1;
2578 #else
2579 printk(KERN_INFO "No tape buffers allocated at initialization.\n");
2580 break;
2581 #endif
2582 }
2583 printk(KERN_INFO "Number of tape buffers adjusted.\n");
2584 break;
2585 }
2586 }
2587 #endif
2588 return 0;
2589 }
2590
2591 static void st_detach(Scsi_Device * SDp)
2592 {
2593 Scsi_Tape * tpnt;
2594 int i;
2595
2596 for(tpnt = scsi_tapes, i=0; i<st_template.dev_max; i++, tpnt++)
2597 if(tpnt->device == SDp) {
2598 tpnt->device = NULL;
2599 SDp->attached--;
2600 st_template.nr_dev--;
2601 st_template.dev_noticed--;
2602 return;
2603 }
2604 return;
2605 }
2606
2607
2608 #ifdef MODULE
2609
2610 int init_module(void) {
2611 st_template.usage_count = &mod_use_count_;
2612 return scsi_register_module(MODULE_SCSI_DEV, &st_template);
2613 }
2614
2615 void cleanup_module( void)
2616 {
2617 int i;
2618
2619 scsi_unregister_module(MODULE_SCSI_DEV, &st_template);
2620 unregister_chrdev(SCSI_TAPE_MAJOR, "st");
2621 st_registered--;
2622 if(scsi_tapes != NULL) {
2623 scsi_init_free((char *) scsi_tapes,
2624 st_template.dev_max * sizeof(Scsi_Tape));
2625
2626 if (st_buffers != NULL) {
2627 for (i=0; i < st_nbr_buffers; i++)
2628 if (st_buffers[i] != NULL) {
2629 scsi_init_free((char *) st_buffers[i]->b_data,
2630 st_buffers[i]->buffer_size);
2631 scsi_init_free((char *) st_buffers[i], sizeof(ST_buffer));
2632 }
2633
2634 scsi_init_free((char *) st_buffers,
2635 st_template.dev_max * sizeof(ST_buffer *));
2636 }
2637 }
2638 st_template.dev_max = 0;
2639 }
2640 #endif