?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] drivers/video: Use ARRAY_SIZE macro
[linux-2.6/openmoko-kernel/knife-kernel.git] / drivers / scsi / osst.c
blob66ea47a9c53c74774e95f584f484761e0e2ff3f7
1 /*
2 SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
3 file Documentation/scsi/st.txt for more information.
4
5 History:
6
7 OnStream SCSI Tape support (osst) cloned from st.c by
8 Willem Riede (osst@riede.org) Feb 2000
9 Fixes ... Kurt Garloff <garloff@suse.de> Mar 2000
10
11 Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.
12 Contribution and ideas from several people including (in alphabetical
13 order) Klaus Ehrenfried, Wolfgang Denk, Steve Hirsch, Andreas Koppenh"ofer,
14 Michael Leodolter, Eyal Lebedinsky, J"org Weule, and Eric Youngdale.
15
16 Copyright 1992 - 2002 Kai Makisara / 2000 - 2006 Willem Riede
17 email osst@riede.org
18
19 $Header: /cvsroot/osst/Driver/osst.c,v 1.73 2005/01/01 21:13:34 wriede Exp $
20
21 Microscopic alterations - Rik Ling, 2000/12/21
22 Last st.c sync: Tue Oct 15 22:01:04 2002 by makisara
23 Some small formal changes - aeb, 950809
24 */
25
26 static const char * cvsid = "$Id: osst.c,v 1.73 2005/01/01 21:13:34 wriede Exp $";
27 static const char * osst_version = "0.99.4";
28
29 /* The "failure to reconnect" firmware bug */
30 #define OSST_FW_NEED_POLL_MIN 10601 /*(107A)*/
31 #define OSST_FW_NEED_POLL_MAX 10704 /*(108D)*/
32 #define OSST_FW_NEED_POLL(x,d) ((x) >= OSST_FW_NEED_POLL_MIN && (x) <= OSST_FW_NEED_POLL_MAX && d->host->this_id != 7)
33
34 #include <linux/module.h>
35
36 #include <linux/fs.h>
37 #include <linux/kernel.h>
38 #include <linux/sched.h>
39 #include <linux/proc_fs.h>
40 #include <linux/mm.h>
41 #include <linux/init.h>
42 #include <linux/string.h>
43 #include <linux/errno.h>
44 #include <linux/mtio.h>
45 #include <linux/ioctl.h>
46 #include <linux/fcntl.h>
47 #include <linux/spinlock.h>
48 #include <linux/vmalloc.h>
49 #include <linux/blkdev.h>
50 #include <linux/moduleparam.h>
51 #include <linux/delay.h>
52 #include <asm/uaccess.h>
53 #include <asm/dma.h>
54 #include <asm/system.h>
55
56 /* The driver prints some debugging information on the console if DEBUG
57 is defined and non-zero. */
58 #define DEBUG 0
59
60 /* The message level for the debug messages is currently set to KERN_NOTICE
61 so that people can easily see the messages. Later when the debugging messages
62 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
63 #define OSST_DEB_MSG KERN_NOTICE
64
65 #include <scsi/scsi.h>
66 #include <scsi/scsi_dbg.h>
67 #include <scsi/scsi_device.h>
68 #include <scsi/scsi_driver.h>
69 #include <scsi/scsi_eh.h>
70 #include <scsi/scsi_host.h>
71 #include <scsi/scsi_ioctl.h>
72
73 #define ST_KILOBYTE 1024
74
75 #include "st.h"
76 #include "osst.h"
77 #include "osst_options.h"
78 #include "osst_detect.h"
79
80 static int max_dev = 0;
81 static int write_threshold_kbs = 0;
82 static int max_sg_segs = 0;
83
84 #ifdef MODULE
85 MODULE_AUTHOR("Willem Riede");
86 MODULE_DESCRIPTION("OnStream {DI-|FW-|SC-|USB}{30|50} Tape Driver");
87 MODULE_LICENSE("GPL");
88 MODULE_ALIAS_CHARDEV_MAJOR(OSST_MAJOR);
89
90 module_param(max_dev, int, 0444);
91 MODULE_PARM_DESC(max_dev, "Maximum number of OnStream Tape Drives to attach (4)");
92
93 module_param(write_threshold_kbs, int, 0644);
94 MODULE_PARM_DESC(write_threshold_kbs, "Asynchronous write threshold (KB; 32)");
95
96 module_param(max_sg_segs, int, 0644);
97 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (9)");
98 #else
99 static struct osst_dev_parm {
100 char *name;
101 int *val;
102 } parms[] __initdata = {
103 { "max_dev", &max_dev },
104 { "write_threshold_kbs", &write_threshold_kbs },
105 { "max_sg_segs", &max_sg_segs }
106 };
107 #endif
108
109 /* Some default definitions have been moved to osst_options.h */
110 #define OSST_BUFFER_SIZE (OSST_BUFFER_BLOCKS * ST_KILOBYTE)
111 #define OSST_WRITE_THRESHOLD (OSST_WRITE_THRESHOLD_BLOCKS * ST_KILOBYTE)
112
113 /* The buffer size should fit into the 24 bits for length in the
114 6-byte SCSI read and write commands. */
115 #if OSST_BUFFER_SIZE >= (2 << 24 - 1)
116 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
117 #endif
118
119 #if DEBUG
120 static int debugging = 1;
121 /* uncomment define below to test error recovery */
122 // #define OSST_INJECT_ERRORS 1
123 #endif
124
125 /* Do not retry! The drive firmware already retries when appropriate,
126 and when it tries to tell us something, we had better listen... */
127 #define MAX_RETRIES 0
128
129 #define NO_TAPE NOT_READY
130
131 #define OSST_WAIT_POSITION_COMPLETE (HZ > 200 ? HZ / 200 : 1)
132 #define OSST_WAIT_WRITE_COMPLETE (HZ / 12)
133 #define OSST_WAIT_LONG_WRITE_COMPLETE (HZ / 2)
134
135 #define OSST_TIMEOUT (200 * HZ)
136 #define OSST_LONG_TIMEOUT (1800 * HZ)
137
138 #define TAPE_NR(x) (iminor(x) & ~(-1 << ST_MODE_SHIFT))
139 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
140 #define TAPE_REWIND(x) ((iminor(x) & 0x80) == 0)
141 #define TAPE_IS_RAW(x) (TAPE_MODE(x) & (ST_NBR_MODES >> 1))
142
143 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
144 24 bits) */
145 #define SET_DENS_AND_BLK 0x10001
146
147 static int osst_buffer_size = OSST_BUFFER_SIZE;
148 static int osst_write_threshold = OSST_WRITE_THRESHOLD;
149 static int osst_max_sg_segs = OSST_MAX_SG;
150 static int osst_max_dev = OSST_MAX_TAPES;
151 static int osst_nr_dev;
152
153 static struct osst_tape **os_scsi_tapes = NULL;
154 static DEFINE_RWLOCK(os_scsi_tapes_lock);
155
156 static int modes_defined = 0;
157
158 static struct osst_buffer *new_tape_buffer(int, int, int);
159 static int enlarge_buffer(struct osst_buffer *, int);
160 static void normalize_buffer(struct osst_buffer *);
161 static int append_to_buffer(const char __user *, struct osst_buffer *, int);
162 static int from_buffer(struct osst_buffer *, char __user *, int);
163 static int osst_zero_buffer_tail(struct osst_buffer *);
164 static int osst_copy_to_buffer(struct osst_buffer *, unsigned char *);
165 static int osst_copy_from_buffer(struct osst_buffer *, unsigned char *);
166
167 static int osst_probe(struct device *);
168 static int osst_remove(struct device *);
169
170 static struct scsi_driver osst_template = {
171 .owner = THIS_MODULE,
172 .gendrv = {
173 .name = "osst",
174 .probe = osst_probe,
175 .remove = osst_remove,
176 }
177 };
178
179 static int osst_int_ioctl(struct osst_tape *STp, struct osst_request ** aSRpnt,
180 unsigned int cmd_in, unsigned long arg);
181
182 static int osst_set_frame_position(struct osst_tape *STp, struct osst_request ** aSRpnt, int frame, int skip);
183
184 static int osst_get_frame_position(struct osst_tape *STp, struct osst_request ** aSRpnt);
185
186 static int osst_flush_write_buffer(struct osst_tape *STp, struct osst_request ** aSRpnt);
187
188 static int osst_write_error_recovery(struct osst_tape * STp, struct osst_request ** aSRpnt, int pending);
189
190 static inline char *tape_name(struct osst_tape *tape)
191 {
192 return tape->drive->disk_name;
193 }
194 \f
195 /* Routines that handle the interaction with mid-layer SCSI routines */
196
197
198 /* Normalize Sense */
199 static void osst_analyze_sense(struct osst_request *SRpnt, struct st_cmdstatus *s)
200 {
201 const u8 *ucp;
202 const u8 *sense = SRpnt->sense;
203
204 s->have_sense = scsi_normalize_sense(SRpnt->sense,
205 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
206 s->flags = 0;
207
208 if (s->have_sense) {
209 s->deferred = 0;
210 s->remainder_valid =
211 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
212 switch (sense[0] & 0x7f) {
213 case 0x71:
214 s->deferred = 1;
215 case 0x70:
216 s->fixed_format = 1;
217 s->flags = sense[2] & 0xe0;
218 break;
219 case 0x73:
220 s->deferred = 1;
221 case 0x72:
222 s->fixed_format = 0;
223 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
224 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
225 break;
226 }
227 }
228 }
229
230 /* Convert the result to success code */
231 static int osst_chk_result(struct osst_tape * STp, struct osst_request * SRpnt)
232 {
233 char *name = tape_name(STp);
234 int result = SRpnt->result;
235 u8 * sense = SRpnt->sense, scode;
236 #if DEBUG
237 const char *stp;
238 #endif
239 struct st_cmdstatus *cmdstatp;
240
241 if (!result)
242 return 0;
243
244 cmdstatp = &STp->buffer->cmdstat;
245 osst_analyze_sense(SRpnt, cmdstatp);
246
247 if (cmdstatp->have_sense)
248 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
249 else
250 scode = 0;
251 #if DEBUG
252 if (debugging) {
253 printk(OSST_DEB_MSG "%s:D: Error: %x, cmd: %x %x %x %x %x %x\n",
254 name, result,
255 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
256 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
257 if (scode) printk(OSST_DEB_MSG "%s:D: Sense: %02x, ASC: %02x, ASCQ: %02x\n",
258 name, scode, sense[12], sense[13]);
259 if (cmdstatp->have_sense)
260 __scsi_print_sense("osst ", SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
261 }
262 else
263 #endif
264 if (cmdstatp->have_sense && (
265 scode != NO_SENSE &&
266 scode != RECOVERED_ERROR &&
267 /* scode != UNIT_ATTENTION && */
268 scode != BLANK_CHECK &&
269 scode != VOLUME_OVERFLOW &&
270 SRpnt->cmd[0] != MODE_SENSE &&
271 SRpnt->cmd[0] != TEST_UNIT_READY)) { /* Abnormal conditions for tape */
272 if (cmdstatp->have_sense) {
273 printk(KERN_WARNING "%s:W: Command with sense data:\n", name);
274 __scsi_print_sense("osst ", SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
275 }
276 else {
277 static int notyetprinted = 1;
278
279 printk(KERN_WARNING
280 "%s:W: Warning %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
281 name, result, suggestion(result), driver_byte(result) & DRIVER_MASK,
282 host_byte(result));
283 if (notyetprinted) {
284 notyetprinted = 0;
285 printk(KERN_INFO
286 "%s:I: This warning may be caused by your scsi controller,\n", name);
287 printk(KERN_INFO
288 "%s:I: it has been reported with some Buslogic cards.\n", name);
289 }
290 }
291 }
292 STp->pos_unknown |= STp->device->was_reset;
293
294 if (cmdstatp->have_sense && scode == RECOVERED_ERROR) {
295 STp->recover_count++;
296 STp->recover_erreg++;
297 #if DEBUG
298 if (debugging) {
299 if (SRpnt->cmd[0] == READ_6)
300 stp = "read";
301 else if (SRpnt->cmd[0] == WRITE_6)
302 stp = "write";
303 else
304 stp = "ioctl";
305 printk(OSST_DEB_MSG "%s:D: Recovered %s error (%d).\n", name, stp,
306 STp->recover_count);
307 }
308 #endif
309 if ((sense[2] & 0xe0) == 0)
310 return 0;
311 }
312 return (-EIO);
313 }
314
315
316 /* Wakeup from interrupt */
317 static void osst_sleep_done(void *data, char *sense, int result, int resid)
318 {
319 struct osst_request *SRpnt = data;
320 struct osst_tape *STp = SRpnt->stp;
321
322 memcpy(SRpnt->sense, sense, SCSI_SENSE_BUFFERSIZE);
323 STp->buffer->cmdstat.midlevel_result = SRpnt->result = result;
324 #if DEBUG
325 STp->write_pending = 0;
326 #endif
327 if (SRpnt->waiting)
328 complete(SRpnt->waiting);
329 }
330
331 /* osst_request memory management */
332 static struct osst_request *osst_allocate_request(void)
333 {
334 return kzalloc(sizeof(struct osst_request), GFP_KERNEL);
335 }
336
337 static void osst_release_request(struct osst_request *streq)
338 {
339 kfree(streq);
340 }
341
342 /* Do the scsi command. Waits until command performed if do_wait is true.
343 Otherwise osst_write_behind_check() is used to check that the command
344 has finished. */
345 static struct osst_request * osst_do_scsi(struct osst_request *SRpnt, struct osst_tape *STp,
346 unsigned char *cmd, int bytes, int direction, int timeout, int retries, int do_wait)
347 {
348 unsigned char *bp;
349 unsigned short use_sg;
350 #ifdef OSST_INJECT_ERRORS
351 static int inject = 0;
352 static int repeat = 0;
353 #endif
354 struct completion *waiting;
355
356 /* if async, make sure there's no command outstanding */
357 if (!do_wait && ((STp->buffer)->last_SRpnt)) {
358 printk(KERN_ERR "%s: Async command already active.\n",
359 tape_name(STp));
360 if (signal_pending(current))
361 (STp->buffer)->syscall_result = (-EINTR);
362 else
363 (STp->buffer)->syscall_result = (-EBUSY);
364 return NULL;
365 }
366
367 if (SRpnt == NULL) {
368 SRpnt = osst_allocate_request();
369 if (SRpnt == NULL) {
370 printk(KERN_ERR "%s: Can't allocate SCSI request.\n",
371 tape_name(STp));
372 if (signal_pending(current))
373 (STp->buffer)->syscall_result = (-EINTR);
374 else
375 (STp->buffer)->syscall_result = (-EBUSY);
376 return NULL;
377 }
378 SRpnt->stp = STp;
379 }
380
381 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
382 which IO is outstanding. It's nulled out when the IO completes. */
383 if (!do_wait)
384 (STp->buffer)->last_SRpnt = SRpnt;
385
386 waiting = &STp->wait;
387 init_completion(waiting);
388 SRpnt->waiting = waiting;
389
390 use_sg = (bytes > STp->buffer->sg[0].length) ? STp->buffer->use_sg : 0;
391 if (use_sg) {
392 bp = (char *)&(STp->buffer->sg[0]);
393 if (STp->buffer->sg_segs < use_sg)
394 use_sg = STp->buffer->sg_segs;
395 }
396 else
397 bp = (STp->buffer)->b_data;
398
399 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
400 STp->buffer->cmdstat.have_sense = 0;
401 STp->buffer->syscall_result = 0;
402
403 if (scsi_execute_async(STp->device, cmd, COMMAND_SIZE(cmd[0]), direction, bp, bytes,
404 use_sg, timeout, retries, SRpnt, osst_sleep_done, GFP_KERNEL))
405 /* could not allocate the buffer or request was too large */
406 (STp->buffer)->syscall_result = (-EBUSY);
407 else if (do_wait) {
408 wait_for_completion(waiting);
409 SRpnt->waiting = NULL;
410 STp->buffer->syscall_result = osst_chk_result(STp, SRpnt);
411 #ifdef OSST_INJECT_ERRORS
412 if (STp->buffer->syscall_result == 0 &&
413 cmd[0] == READ_6 &&
414 cmd[4] &&
415 ( (++ inject % 83) == 29 ||
416 (STp->first_frame_position == 240
417 /* or STp->read_error_frame to fail again on the block calculated above */ &&
418 ++repeat < 3))) {
419 printk(OSST_DEB_MSG "%s:D: Injecting read error\n", tape_name(STp));
420 STp->buffer->last_result_fatal = 1;
421 }
422 #endif
423 }
424 return SRpnt;
425 }
426
427
428 /* Handle the write-behind checking (downs the semaphore) */
429 static void osst_write_behind_check(struct osst_tape *STp)
430 {
431 struct osst_buffer * STbuffer;
432
433 STbuffer = STp->buffer;
434
435 #if DEBUG
436 if (STp->write_pending)
437 STp->nbr_waits++;
438 else
439 STp->nbr_finished++;
440 #endif
441 wait_for_completion(&(STp->wait));
442 STp->buffer->last_SRpnt->waiting = NULL;
443
444 STp->buffer->syscall_result = osst_chk_result(STp, STp->buffer->last_SRpnt);
445
446 if (STp->buffer->syscall_result)
447 STp->buffer->syscall_result =
448 osst_write_error_recovery(STp, &(STp->buffer->last_SRpnt), 1);
449 else
450 STp->first_frame_position++;
451
452 osst_release_request(STp->buffer->last_SRpnt);
453
454 if (STbuffer->writing < STbuffer->buffer_bytes)
455 printk(KERN_WARNING "osst :A: write_behind_check: something left in buffer!\n");
456
457 STbuffer->last_SRpnt = NULL;
458 STbuffer->buffer_bytes -= STbuffer->writing;
459 STbuffer->writing = 0;
460
461 return;
462 }
463
464
465 \f
466 /* Onstream specific Routines */
467 /*
468 * Initialize the OnStream AUX
469 */
470 static void osst_init_aux(struct osst_tape * STp, int frame_type, int frame_seq_number,
471 int logical_blk_num, int blk_sz, int blk_cnt)
472 {
473 os_aux_t *aux = STp->buffer->aux;
474 os_partition_t *par = &aux->partition;
475 os_dat_t *dat = &aux->dat;
476
477 if (STp->raw) return;
478
479 memset(aux, 0, sizeof(*aux));
480 aux->format_id = htonl(0);
481 memcpy(aux->application_sig, "LIN4", 4);
482 aux->hdwr = htonl(0);
483 aux->frame_type = frame_type;
484
485 switch (frame_type) {
486 case OS_FRAME_TYPE_HEADER:
487 aux->update_frame_cntr = htonl(STp->update_frame_cntr);
488 par->partition_num = OS_CONFIG_PARTITION;
489 par->par_desc_ver = OS_PARTITION_VERSION;
490 par->wrt_pass_cntr = htons(0xffff);
491 /* 0-4 = reserved, 5-9 = header, 2990-2994 = header, 2995-2999 = reserved */
492 par->first_frame_ppos = htonl(0);
493 par->last_frame_ppos = htonl(0xbb7);
494 aux->frame_seq_num = htonl(0);
495 aux->logical_blk_num_high = htonl(0);
496 aux->logical_blk_num = htonl(0);
497 aux->next_mark_ppos = htonl(STp->first_mark_ppos);
498 break;
499 case OS_FRAME_TYPE_DATA:
500 case OS_FRAME_TYPE_MARKER:
501 dat->dat_sz = 8;
502 dat->reserved1 = 0;
503 dat->entry_cnt = 1;
504 dat->reserved3 = 0;
505 dat->dat_list[0].blk_sz = htonl(blk_sz);
506 dat->dat_list[0].blk_cnt = htons(blk_cnt);
507 dat->dat_list[0].flags = frame_type==OS_FRAME_TYPE_MARKER?
508 OS_DAT_FLAGS_MARK:OS_DAT_FLAGS_DATA;
509 dat->dat_list[0].reserved = 0;
510 case OS_FRAME_TYPE_EOD:
511 aux->update_frame_cntr = htonl(0);
512 par->partition_num = OS_DATA_PARTITION;
513 par->par_desc_ver = OS_PARTITION_VERSION;
514 par->wrt_pass_cntr = htons(STp->wrt_pass_cntr);
515 par->first_frame_ppos = htonl(STp->first_data_ppos);
516 par->last_frame_ppos = htonl(STp->capacity);
517 aux->frame_seq_num = htonl(frame_seq_number);
518 aux->logical_blk_num_high = htonl(0);
519 aux->logical_blk_num = htonl(logical_blk_num);
520 break;
521 default: ; /* probably FILL */
522 }
523 aux->filemark_cnt = ntohl(STp->filemark_cnt);
524 aux->phys_fm = ntohl(0xffffffff);
525 aux->last_mark_ppos = ntohl(STp->last_mark_ppos);
526 aux->last_mark_lbn = ntohl(STp->last_mark_lbn);
527 }
528
529 /*
530 * Verify that we have the correct tape frame
531 */
532 static int osst_verify_frame(struct osst_tape * STp, int frame_seq_number, int quiet)
533 {
534 char * name = tape_name(STp);
535 os_aux_t * aux = STp->buffer->aux;
536 os_partition_t * par = &(aux->partition);
537 struct st_partstat * STps = &(STp->ps[STp->partition]);
538 int blk_cnt, blk_sz, i;
539
540 if (STp->raw) {
541 if (STp->buffer->syscall_result) {
542 for (i=0; i < STp->buffer->sg_segs; i++)
543 memset(page_address(STp->buffer->sg[i].page),
544 0, STp->buffer->sg[i].length);
545 strcpy(STp->buffer->b_data, "READ ERROR ON FRAME");
546 } else
547 STp->buffer->buffer_bytes = OS_FRAME_SIZE;
548 return 1;
549 }
550 if (STp->buffer->syscall_result) {
551 #if DEBUG
552 printk(OSST_DEB_MSG "%s:D: Skipping frame, read error\n", name);
553 #endif
554 return 0;
555 }
556 if (ntohl(aux->format_id) != 0) {
557 #if DEBUG
558 printk(OSST_DEB_MSG "%s:D: Skipping frame, format_id %u\n", name, ntohl(aux->format_id));
559 #endif
560 goto err_out;
561 }
562 if (memcmp(aux->application_sig, STp->application_sig, 4) != 0 &&
563 (memcmp(aux->application_sig, "LIN3", 4) != 0 || STp->linux_media_version != 4)) {
564 #if DEBUG
565 printk(OSST_DEB_MSG "%s:D: Skipping frame, incorrect application signature\n", name);
566 #endif
567 goto err_out;
568 }
569 if (par->partition_num != OS_DATA_PARTITION) {
570 if (!STp->linux_media || STp->linux_media_version != 2) {
571 #if DEBUG
572 printk(OSST_DEB_MSG "%s:D: Skipping frame, partition num %d\n",
573 name, par->partition_num);
574 #endif
575 goto err_out;
576 }
577 }
578 if (par->par_desc_ver != OS_PARTITION_VERSION) {
579 #if DEBUG
580 printk(OSST_DEB_MSG "%s:D: Skipping frame, partition version %d\n", name, par->par_desc_ver);
581 #endif
582 goto err_out;
583 }
584 if (ntohs(par->wrt_pass_cntr) != STp->wrt_pass_cntr) {
585 #if DEBUG
586 printk(OSST_DEB_MSG "%s:D: Skipping frame, wrt_pass_cntr %d (expected %d)\n",
587 name, ntohs(par->wrt_pass_cntr), STp->wrt_pass_cntr);
588 #endif
589 goto err_out;
590 }
591 if (aux->frame_type != OS_FRAME_TYPE_DATA &&
592 aux->frame_type != OS_FRAME_TYPE_EOD &&
593 aux->frame_type != OS_FRAME_TYPE_MARKER) {
594 if (!quiet)
595 #if DEBUG
596 printk(OSST_DEB_MSG "%s:D: Skipping frame, frame type %x\n", name, aux->frame_type);
597 #endif
598 goto err_out;
599 }
600 if (aux->frame_type == OS_FRAME_TYPE_EOD &&
601 STp->first_frame_position < STp->eod_frame_ppos) {
602 printk(KERN_INFO "%s:I: Skipping premature EOD frame %d\n", name,
603 STp->first_frame_position);
604 goto err_out;
605 }
606 if (frame_seq_number != -1 && ntohl(aux->frame_seq_num) != frame_seq_number) {
607 if (!quiet)
608 #if DEBUG
609 printk(OSST_DEB_MSG "%s:D: Skipping frame, sequence number %u (expected %d)\n",
610 name, ntohl(aux->frame_seq_num), frame_seq_number);
611 #endif
612 goto err_out;
613 }
614 if (aux->frame_type == OS_FRAME_TYPE_MARKER) {
615 STps->eof = ST_FM_HIT;
616
617 i = ntohl(aux->filemark_cnt);
618 if (STp->header_cache != NULL && i < OS_FM_TAB_MAX && (i > STp->filemark_cnt ||
619 STp->first_frame_position - 1 != ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[i]))) {
620 #if DEBUG
621 printk(OSST_DEB_MSG "%s:D: %s filemark %d at frame pos %d\n", name,
622 STp->header_cache->dat_fm_tab.fm_tab_ent[i] == 0?"Learned":"Corrected",
623 i, STp->first_frame_position - 1);
624 #endif
625 STp->header_cache->dat_fm_tab.fm_tab_ent[i] = htonl(STp->first_frame_position - 1);
626 if (i >= STp->filemark_cnt)
627 STp->filemark_cnt = i+1;
628 }
629 }
630 if (aux->frame_type == OS_FRAME_TYPE_EOD) {
631 STps->eof = ST_EOD_1;
632 STp->frame_in_buffer = 1;
633 }
634 if (aux->frame_type == OS_FRAME_TYPE_DATA) {
635 blk_cnt = ntohs(aux->dat.dat_list[0].blk_cnt);
636 blk_sz = ntohl(aux->dat.dat_list[0].blk_sz);
637 STp->buffer->buffer_bytes = blk_cnt * blk_sz;
638 STp->buffer->read_pointer = 0;
639 STp->frame_in_buffer = 1;
640
641 /* See what block size was used to write file */
642 if (STp->block_size != blk_sz && blk_sz > 0) {
643 printk(KERN_INFO
644 "%s:I: File was written with block size %d%c, currently %d%c, adjusted to match.\n",
645 name, blk_sz<1024?blk_sz:blk_sz/1024,blk_sz<1024?'b':'k',
646 STp->block_size<1024?STp->block_size:STp->block_size/1024,
647 STp->block_size<1024?'b':'k');
648 STp->block_size = blk_sz;
649 STp->buffer->buffer_blocks = OS_DATA_SIZE / blk_sz;
650 }
651 STps->eof = ST_NOEOF;
652 }
653 STp->frame_seq_number = ntohl(aux->frame_seq_num);
654 STp->logical_blk_num = ntohl(aux->logical_blk_num);
655 return 1;
656
657 err_out:
658 if (STp->read_error_frame == 0)
659 STp->read_error_frame = STp->first_frame_position - 1;
660 return 0;
661 }
662
663 /*
664 * Wait for the unit to become Ready
665 */
666 static int osst_wait_ready(struct osst_tape * STp, struct osst_request ** aSRpnt,
667 unsigned timeout, int initial_delay)
668 {
669 unsigned char cmd[MAX_COMMAND_SIZE];
670 struct osst_request * SRpnt;
671 unsigned long startwait = jiffies;
672 #if DEBUG
673 int dbg = debugging;
674 char * name = tape_name(STp);
675
676 printk(OSST_DEB_MSG "%s:D: Reached onstream wait ready\n", name);
677 #endif
678
679 if (initial_delay > 0)
680 msleep(jiffies_to_msecs(initial_delay));
681
682 memset(cmd, 0, MAX_COMMAND_SIZE);
683 cmd[0] = TEST_UNIT_READY;
684
685 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
686 *aSRpnt = SRpnt;
687 if (!SRpnt) return (-EBUSY);
688
689 while ( STp->buffer->syscall_result && time_before(jiffies, startwait + timeout*HZ) &&
690 (( SRpnt->sense[2] == 2 && SRpnt->sense[12] == 4 &&
691 (SRpnt->sense[13] == 1 || SRpnt->sense[13] == 8) ) ||
692 ( SRpnt->sense[2] == 6 && SRpnt->sense[12] == 0x28 &&
693 SRpnt->sense[13] == 0 ) )) {
694 #if DEBUG
695 if (debugging) {
696 printk(OSST_DEB_MSG "%s:D: Sleeping in onstream wait ready\n", name);
697 printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name);
698 debugging = 0;
699 }
700 #endif
701 msleep(100);
702
703 memset(cmd, 0, MAX_COMMAND_SIZE);
704 cmd[0] = TEST_UNIT_READY;
705
706 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
707 }
708 *aSRpnt = SRpnt;
709 #if DEBUG
710 debugging = dbg;
711 #endif
712 if ( STp->buffer->syscall_result &&
713 osst_write_error_recovery(STp, aSRpnt, 0) ) {
714 #if DEBUG
715 printk(OSST_DEB_MSG "%s:D: Abnormal exit from onstream wait ready\n", name);
716 printk(OSST_DEB_MSG "%s:D: Result = %d, Sense: 0=%02x, 2=%02x, 12=%02x, 13=%02x\n", name,
717 STp->buffer->syscall_result, SRpnt->sense[0], SRpnt->sense[2],
718 SRpnt->sense[12], SRpnt->sense[13]);
719 #endif
720 return (-EIO);
721 }
722 #if DEBUG
723 printk(OSST_DEB_MSG "%s:D: Normal exit from onstream wait ready\n", name);
724 #endif
725 return 0;
726 }
727
728 /*
729 * Wait for a tape to be inserted in the unit
730 */
731 static int osst_wait_for_medium(struct osst_tape * STp, struct osst_request ** aSRpnt, unsigned timeout)
732 {
733 unsigned char cmd[MAX_COMMAND_SIZE];
734 struct osst_request * SRpnt;
735 unsigned long startwait = jiffies;
736 #if DEBUG
737 int dbg = debugging;
738 char * name = tape_name(STp);
739
740 printk(OSST_DEB_MSG "%s:D: Reached onstream wait for medium\n", name);
741 #endif
742
743 memset(cmd, 0, MAX_COMMAND_SIZE);
744 cmd[0] = TEST_UNIT_READY;
745
746 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
747 *aSRpnt = SRpnt;
748 if (!SRpnt) return (-EBUSY);
749
750 while ( STp->buffer->syscall_result && time_before(jiffies, startwait + timeout*HZ) &&
751 SRpnt->sense[2] == 2 && SRpnt->sense[12] == 0x3a && SRpnt->sense[13] == 0 ) {
752 #if DEBUG
753 if (debugging) {
754 printk(OSST_DEB_MSG "%s:D: Sleeping in onstream wait medium\n", name);
755 printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name);
756 debugging = 0;
757 }
758 #endif
759 msleep(100);
760
761 memset(cmd, 0, MAX_COMMAND_SIZE);
762 cmd[0] = TEST_UNIT_READY;
763
764 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
765 }
766 *aSRpnt = SRpnt;
767 #if DEBUG
768 debugging = dbg;
769 #endif
770 if ( STp->buffer->syscall_result && SRpnt->sense[2] != 2 &&
771 SRpnt->sense[12] != 4 && SRpnt->sense[13] == 1) {
772 #if DEBUG
773 printk(OSST_DEB_MSG "%s:D: Abnormal exit from onstream wait medium\n", name);
774 printk(OSST_DEB_MSG "%s:D: Result = %d, Sense: 0=%02x, 2=%02x, 12=%02x, 13=%02x\n", name,
775 STp->buffer->syscall_result, SRpnt->sense[0], SRpnt->sense[2],
776 SRpnt->sense[12], SRpnt->sense[13]);
777 #endif
778 return 0;
779 }
780 #if DEBUG
781 printk(OSST_DEB_MSG "%s:D: Normal exit from onstream wait medium\n", name);
782 #endif
783 return 1;
784 }
785
786 static int osst_position_tape_and_confirm(struct osst_tape * STp, struct osst_request ** aSRpnt, int frame)
787 {
788 int retval;
789
790 osst_wait_ready(STp, aSRpnt, 15 * 60, 0); /* TODO - can this catch a write error? */
791 retval = osst_set_frame_position(STp, aSRpnt, frame, 0);
792 if (retval) return (retval);
793 osst_wait_ready(STp, aSRpnt, 15 * 60, OSST_WAIT_POSITION_COMPLETE);
794 return (osst_get_frame_position(STp, aSRpnt));
795 }
796
797 /*
798 * Wait for write(s) to complete
799 */
800 static int osst_flush_drive_buffer(struct osst_tape * STp, struct osst_request ** aSRpnt)
801 {
802 unsigned char cmd[MAX_COMMAND_SIZE];
803 struct osst_request * SRpnt;
804 int result = 0;
805 int delay = OSST_WAIT_WRITE_COMPLETE;
806 #if DEBUG
807 char * name = tape_name(STp);
808
809 printk(OSST_DEB_MSG "%s:D: Reached onstream flush drive buffer (write filemark)\n", name);
810 #endif
811
812 memset(cmd, 0, MAX_COMMAND_SIZE);
813 cmd[0] = WRITE_FILEMARKS;
814 cmd[1] = 1;
815
816 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
817 *aSRpnt = SRpnt;
818 if (!SRpnt) return (-EBUSY);
819 if (STp->buffer->syscall_result) {
820 if ((SRpnt->sense[2] & 0x0f) == 2 && SRpnt->sense[12] == 4) {
821 if (SRpnt->sense[13] == 8) {
822 delay = OSST_WAIT_LONG_WRITE_COMPLETE;
823 }
824 } else
825 result = osst_write_error_recovery(STp, aSRpnt, 0);
826 }
827 result |= osst_wait_ready(STp, aSRpnt, 5 * 60, delay);
828 STp->ps[STp->partition].rw = OS_WRITING_COMPLETE;
829
830 return (result);
831 }
832
833 #define OSST_POLL_PER_SEC 10
834 static int osst_wait_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, int curr, int minlast, int to)
835 {
836 unsigned long startwait = jiffies;
837 char * name = tape_name(STp);
838 #if DEBUG
839 char notyetprinted = 1;
840 #endif
841 if (minlast >= 0 && STp->ps[STp->partition].rw != ST_READING)
842 printk(KERN_ERR "%s:A: Waiting for frame without having initialized read!\n", name);
843
844 while (time_before (jiffies, startwait + to*HZ))
845 {
846 int result;
847 result = osst_get_frame_position(STp, aSRpnt);
848 if (result == -EIO)
849 if ((result = osst_write_error_recovery(STp, aSRpnt, 0)) == 0)
850 return 0; /* successful recovery leaves drive ready for frame */
851 if (result < 0) break;
852 if (STp->first_frame_position == curr &&
853 ((minlast < 0 &&
854 (signed)STp->last_frame_position > (signed)curr + minlast) ||
855 (minlast >= 0 && STp->cur_frames > minlast)
856 ) && result >= 0)
857 {
858 #if DEBUG
859 if (debugging || jiffies - startwait >= 2*HZ/OSST_POLL_PER_SEC)
860 printk (OSST_DEB_MSG
861 "%s:D: Succ wait f fr %i (>%i): %i-%i %i (%i): %3li.%li s\n",
862 name, curr, curr+minlast, STp->first_frame_position,
863 STp->last_frame_position, STp->cur_frames,
864 result, (jiffies-startwait)/HZ,
865 (((jiffies-startwait)%HZ)*10)/HZ);
866 #endif
867 return 0;
868 }
869 #if DEBUG
870 if (jiffies - startwait >= 2*HZ/OSST_POLL_PER_SEC && notyetprinted)
871 {
872 printk (OSST_DEB_MSG "%s:D: Wait for frame %i (>%i): %i-%i %i (%i)\n",
873 name, curr, curr+minlast, STp->first_frame_position,
874 STp->last_frame_position, STp->cur_frames, result);
875 notyetprinted--;
876 }
877 #endif
878 msleep(1000 / OSST_POLL_PER_SEC);
879 }
880 #if DEBUG
881 printk (OSST_DEB_MSG "%s:D: Fail wait f fr %i (>%i): %i-%i %i: %3li.%li s\n",
882 name, curr, curr+minlast, STp->first_frame_position,
883 STp->last_frame_position, STp->cur_frames,
884 (jiffies-startwait)/HZ, (((jiffies-startwait)%HZ)*10)/HZ);
885 #endif
886 return -EBUSY;
887 }
888
889 static int osst_recover_wait_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, int writing)
890 {
891 struct osst_request * SRpnt;
892 unsigned char cmd[MAX_COMMAND_SIZE];
893 unsigned long startwait = jiffies;
894 int retval = 1;
895 char * name = tape_name(STp);
896
897 if (writing) {
898 char mybuf[24];
899 char * olddata = STp->buffer->b_data;
900 int oldsize = STp->buffer->buffer_size;
901
902 /* write zero fm then read pos - if shows write error, try to recover - if no progress, wait */
903
904 memset(cmd, 0, MAX_COMMAND_SIZE);
905 cmd[0] = WRITE_FILEMARKS;
906 cmd[1] = 1;
907 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout,
908 MAX_RETRIES, 1);
909
910 while (retval && time_before (jiffies, startwait + 5*60*HZ)) {
911
912 if (STp->buffer->syscall_result && (SRpnt->sense[2] & 0x0f) != 2) {
913
914 /* some failure - not just not-ready */
915 retval = osst_write_error_recovery(STp, aSRpnt, 0);
916 break;
917 }
918 schedule_timeout_interruptible(HZ / OSST_POLL_PER_SEC);
919
920 STp->buffer->b_data = mybuf; STp->buffer->buffer_size = 24;
921 memset(cmd, 0, MAX_COMMAND_SIZE);
922 cmd[0] = READ_POSITION;
923
924 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 20, DMA_FROM_DEVICE, STp->timeout,
925 MAX_RETRIES, 1);
926
927 retval = ( STp->buffer->syscall_result || (STp->buffer)->b_data[15] > 25 );
928 STp->buffer->b_data = olddata; STp->buffer->buffer_size = oldsize;
929 }
930 if (retval)
931 printk(KERN_ERR "%s:E: Device did not succeed to write buffered data\n", name);
932 } else
933 /* TODO - figure out which error conditions can be handled */
934 if (STp->buffer->syscall_result)
935 printk(KERN_WARNING
936 "%s:W: Recover_wait_frame(read) cannot handle %02x:%02x:%02x\n", name,
937 (*aSRpnt)->sense[ 2] & 0x0f,
938 (*aSRpnt)->sense[12],
939 (*aSRpnt)->sense[13]);
940
941 return retval;
942 }
943
944 /*
945 * Read the next OnStream tape frame at the current location
946 */
947 static int osst_read_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, int timeout)
948 {
949 unsigned char cmd[MAX_COMMAND_SIZE];
950 struct osst_request * SRpnt;
951 int retval = 0;
952 #if DEBUG
953 os_aux_t * aux = STp->buffer->aux;
954 char * name = tape_name(STp);
955 #endif
956
957 if (STp->poll)
958 if (osst_wait_frame (STp, aSRpnt, STp->first_frame_position, 0, timeout))
959 retval = osst_recover_wait_frame(STp, aSRpnt, 0);
960
961 memset(cmd, 0, MAX_COMMAND_SIZE);
962 cmd[0] = READ_6;
963 cmd[1] = 1;
964 cmd[4] = 1;
965
966 #if DEBUG
967 if (debugging)
968 printk(OSST_DEB_MSG "%s:D: Reading frame from OnStream tape\n", name);
969 #endif
970 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, OS_FRAME_SIZE, DMA_FROM_DEVICE,
971 STp->timeout, MAX_RETRIES, 1);
972 *aSRpnt = SRpnt;
973 if (!SRpnt)
974 return (-EBUSY);
975
976 if ((STp->buffer)->syscall_result) {
977 retval = 1;
978 if (STp->read_error_frame == 0) {
979 STp->read_error_frame = STp->first_frame_position;
980 #if DEBUG
981 printk(OSST_DEB_MSG "%s:D: Recording read error at %d\n", name, STp->read_error_frame);
982 #endif
983 }
984 #if DEBUG
985 if (debugging)
986 printk(OSST_DEB_MSG "%s:D: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
987 name,
988 SRpnt->sense[0], SRpnt->sense[1],
989 SRpnt->sense[2], SRpnt->sense[3],
990 SRpnt->sense[4], SRpnt->sense[5],
991 SRpnt->sense[6], SRpnt->sense[7]);
992 #endif
993 }
994 else
995 STp->first_frame_position++;
996 #if DEBUG
997 if (debugging) {
998 char sig[8]; int i;
999 for (i=0;i<4;i++)
1000 sig[i] = aux->application_sig[i]<32?'^':aux->application_sig[i];
1001 sig[4] = '\0';
1002 printk(OSST_DEB_MSG
1003 "%s:D: AUX: %s UpdFrCt#%d Wpass#%d %s FrSeq#%d LogBlk#%d Qty=%d Sz=%d\n", name, sig,
1004 ntohl(aux->update_frame_cntr), ntohs(aux->partition.wrt_pass_cntr),
1005 aux->frame_type==1?"EOD":aux->frame_type==2?"MARK":
1006 aux->frame_type==8?"HEADR":aux->frame_type==0x80?"DATA":"FILL",
1007 ntohl(aux->frame_seq_num), ntohl(aux->logical_blk_num),
1008 ntohs(aux->dat.dat_list[0].blk_cnt), ntohl(aux->dat.dat_list[0].blk_sz) );
1009 if (aux->frame_type==2)
1010 printk(OSST_DEB_MSG "%s:D: mark_cnt=%d, last_mark_ppos=%d, last_mark_lbn=%d\n", name,
1011 ntohl(aux->filemark_cnt), ntohl(aux->last_mark_ppos), ntohl(aux->last_mark_lbn));
1012 printk(OSST_DEB_MSG "%s:D: Exit read frame from OnStream tape with code %d\n", name, retval);
1013 }
1014 #endif
1015 return (retval);
1016 }
1017
1018 static int osst_initiate_read(struct osst_tape * STp, struct osst_request ** aSRpnt)
1019 {
1020 struct st_partstat * STps = &(STp->ps[STp->partition]);
1021 struct osst_request * SRpnt ;
1022 unsigned char cmd[MAX_COMMAND_SIZE];
1023 int retval = 0;
1024 char * name = tape_name(STp);
1025
1026 if (STps->rw != ST_READING) { /* Initialize read operation */
1027 if (STps->rw == ST_WRITING || STp->dirty) {
1028 STp->write_type = OS_WRITE_DATA;
1029 osst_flush_write_buffer(STp, aSRpnt);
1030 osst_flush_drive_buffer(STp, aSRpnt);
1031 }
1032 STps->rw = ST_READING;
1033 STp->frame_in_buffer = 0;
1034
1035 /*
1036 * Issue a read 0 command to get the OnStream drive
1037 * read frames into its buffer.
1038 */
1039 memset(cmd, 0, MAX_COMMAND_SIZE);
1040 cmd[0] = READ_6;
1041 cmd[1] = 1;
1042
1043 #if DEBUG
1044 printk(OSST_DEB_MSG "%s:D: Start Read Ahead on OnStream tape\n", name);
1045 #endif
1046 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
1047 *aSRpnt = SRpnt;
1048 if ((retval = STp->buffer->syscall_result))
1049 printk(KERN_WARNING "%s:W: Error starting read ahead\n", name);
1050 }
1051
1052 return retval;
1053 }
1054
1055 static int osst_get_logical_frame(struct osst_tape * STp, struct osst_request ** aSRpnt,
1056 int frame_seq_number, int quiet)
1057 {
1058 struct st_partstat * STps = &(STp->ps[STp->partition]);
1059 char * name = tape_name(STp);
1060 int cnt = 0,
1061 bad = 0,
1062 past = 0,
1063 x,
1064 position;
1065
1066 /*
1067 * If we want just any frame (-1) and there is a frame in the buffer, return it
1068 */
1069 if (frame_seq_number == -1 && STp->frame_in_buffer) {
1070 #if DEBUG
1071 printk(OSST_DEB_MSG "%s:D: Frame %d still in buffer\n", name, STp->frame_seq_number);
1072 #endif
1073 return (STps->eof);
1074 }
1075 /*
1076 * Search and wait for the next logical tape frame
1077 */
1078 while (1) {
1079 if (cnt++ > 400) {
1080 printk(KERN_ERR "%s:E: Couldn't find logical frame %d, aborting\n",
1081 name, frame_seq_number);
1082 if (STp->read_error_frame) {
1083 osst_set_frame_position(STp, aSRpnt, STp->read_error_frame, 0);
1084 #if DEBUG
1085 printk(OSST_DEB_MSG "%s:D: Repositioning tape to bad frame %d\n",
1086 name, STp->read_error_frame);
1087 #endif
1088 STp->read_error_frame = 0;
1089 STp->abort_count++;
1090 }
1091 return (-EIO);
1092 }
1093 #if DEBUG
1094 if (debugging)
1095 printk(OSST_DEB_MSG "%s:D: Looking for frame %d, attempt %d\n",
1096 name, frame_seq_number, cnt);
1097 #endif
1098 if ( osst_initiate_read(STp, aSRpnt)
1099 || ( (!STp->frame_in_buffer) && osst_read_frame(STp, aSRpnt, 30) ) ) {
1100 if (STp->raw)
1101 return (-EIO);
1102 position = osst_get_frame_position(STp, aSRpnt);
1103 if (position >= 0xbae && position < 0xbb8)
1104 position = 0xbb8;
1105 else if (position > STp->eod_frame_ppos || ++bad == 10) {
1106 position = STp->read_error_frame - 1;
1107 bad = 0;
1108 }
1109 else {
1110 position += 29;
1111 cnt += 19;
1112 }
1113 #if DEBUG
1114 printk(OSST_DEB_MSG "%s:D: Bad frame detected, positioning tape to block %d\n",
1115 name, position);
1116 #endif
1117 osst_set_frame_position(STp, aSRpnt, position, 0);
1118 continue;
1119 }
1120 if (osst_verify_frame(STp, frame_seq_number, quiet))
1121 break;
1122 if (osst_verify_frame(STp, -1, quiet)) {
1123 x = ntohl(STp->buffer->aux->frame_seq_num);
1124 if (STp->fast_open) {
1125 printk(KERN_WARNING
1126 "%s:W: Found logical frame %d instead of %d after fast open\n",
1127 name, x, frame_seq_number);
1128 STp->header_ok = 0;
1129 STp->read_error_frame = 0;
1130 return (-EIO);
1131 }
1132 if (x > frame_seq_number) {
1133 if (++past > 3) {
1134 /* positioning backwards did not bring us to the desired frame */
1135 position = STp->read_error_frame - 1;
1136 }
1137 else {
1138 position = osst_get_frame_position(STp, aSRpnt)
1139 + frame_seq_number - x - 1;
1140
1141 if (STp->first_frame_position >= 3000 && position < 3000)
1142 position -= 10;
1143 }
1144 #if DEBUG
1145 printk(OSST_DEB_MSG
1146 "%s:D: Found logical frame %d while looking for %d: back up %d\n",
1147 name, x, frame_seq_number,
1148 STp->first_frame_position - position);
1149 #endif
1150 osst_set_frame_position(STp, aSRpnt, position, 0);
1151 cnt += 10;
1152 }
1153 else
1154 past = 0;
1155 }
1156 if (osst_get_frame_position(STp, aSRpnt) == 0xbaf) {
1157 #if DEBUG
1158 printk(OSST_DEB_MSG "%s:D: Skipping config partition\n", name);
1159 #endif
1160 osst_set_frame_position(STp, aSRpnt, 0xbb8, 0);
1161 cnt--;
1162 }
1163 STp->frame_in_buffer = 0;
1164 }
1165 if (cnt > 1) {
1166 STp->recover_count++;
1167 STp->recover_erreg++;
1168 printk(KERN_WARNING "%s:I: Don't worry, Read error at position %d recovered\n",
1169 name, STp->read_error_frame);
1170 }
1171 STp->read_count++;
1172
1173 #if DEBUG
1174 if (debugging || STps->eof)
1175 printk(OSST_DEB_MSG
1176 "%s:D: Exit get logical frame (%d=>%d) from OnStream tape with code %d\n",
1177 name, frame_seq_number, STp->frame_seq_number, STps->eof);
1178 #endif
1179 STp->fast_open = 0;
1180 STp->read_error_frame = 0;
1181 return (STps->eof);
1182 }
1183
1184 static int osst_seek_logical_blk(struct osst_tape * STp, struct osst_request ** aSRpnt, int logical_blk_num)
1185 {
1186 struct st_partstat * STps = &(STp->ps[STp->partition]);
1187 char * name = tape_name(STp);
1188 int retries = 0;
1189 int frame_seq_estimate, ppos_estimate, move;
1190
1191 if (logical_blk_num < 0) logical_blk_num = 0;
1192 #if DEBUG
1193 printk(OSST_DEB_MSG "%s:D: Seeking logical block %d (now at %d, size %d%c)\n",
1194 name, logical_blk_num, STp->logical_blk_num,
1195 STp->block_size<1024?STp->block_size:STp->block_size/1024,
1196 STp->block_size<1024?'b':'k');
1197 #endif
1198 /* Do we know where we are? */
1199 if (STps->drv_block >= 0) {
1200 move = logical_blk_num - STp->logical_blk_num;
1201 if (move < 0) move -= (OS_DATA_SIZE / STp->block_size) - 1;
1202 move /= (OS_DATA_SIZE / STp->block_size);
1203 frame_seq_estimate = STp->frame_seq_number + move;
1204 } else
1205 frame_seq_estimate = logical_blk_num * STp->block_size / OS_DATA_SIZE;
1206
1207 if (frame_seq_estimate < 2980) ppos_estimate = frame_seq_estimate + 10;
1208 else ppos_estimate = frame_seq_estimate + 20;
1209 while (++retries < 10) {
1210 if (ppos_estimate > STp->eod_frame_ppos-2) {
1211 frame_seq_estimate += STp->eod_frame_ppos - 2 - ppos_estimate;
1212 ppos_estimate = STp->eod_frame_ppos - 2;
1213 }
1214 if (frame_seq_estimate < 0) {
1215 frame_seq_estimate = 0;
1216 ppos_estimate = 10;
1217 }
1218 osst_set_frame_position(STp, aSRpnt, ppos_estimate, 0);
1219 if (osst_get_logical_frame(STp, aSRpnt, frame_seq_estimate, 1) >= 0) {
1220 /* we've located the estimated frame, now does it have our block? */
1221 if (logical_blk_num < STp->logical_blk_num ||
1222 logical_blk_num >= STp->logical_blk_num + ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt)) {
1223 if (STps->eof == ST_FM_HIT)
1224 move = logical_blk_num < STp->logical_blk_num? -2 : 1;
1225 else {
1226 move = logical_blk_num - STp->logical_blk_num;
1227 if (move < 0) move -= (OS_DATA_SIZE / STp->block_size) - 1;
1228 move /= (OS_DATA_SIZE / STp->block_size);
1229 }
1230 if (!move) move = logical_blk_num > STp->logical_blk_num ? 1 : -1;
1231 #if DEBUG
1232 printk(OSST_DEB_MSG
1233 "%s:D: Seek retry %d at ppos %d fsq %d (est %d) lbn %d (need %d) move %d\n",
1234 name, retries, ppos_estimate, STp->frame_seq_number, frame_seq_estimate,
1235 STp->logical_blk_num, logical_blk_num, move);
1236 #endif
1237 frame_seq_estimate += move;
1238 ppos_estimate += move;
1239 continue;
1240 } else {
1241 STp->buffer->read_pointer = (logical_blk_num - STp->logical_blk_num) * STp->block_size;
1242 STp->buffer->buffer_bytes -= STp->buffer->read_pointer;
1243 STp->logical_blk_num = logical_blk_num;
1244 #if DEBUG
1245 printk(OSST_DEB_MSG
1246 "%s:D: Seek success at ppos %d fsq %d in_buf %d, bytes %d, ptr %d*%d\n",
1247 name, ppos_estimate, STp->frame_seq_number, STp->frame_in_buffer,
1248 STp->buffer->buffer_bytes, STp->buffer->read_pointer / STp->block_size,
1249 STp->block_size);
1250 #endif
1251 STps->drv_file = ntohl(STp->buffer->aux->filemark_cnt);
1252 if (STps->eof == ST_FM_HIT) {
1253 STps->drv_file++;
1254 STps->drv_block = 0;
1255 } else {
1256 STps->drv_block = ntohl(STp->buffer->aux->last_mark_lbn)?
1257 STp->logical_blk_num -
1258 (STps->drv_file ? ntohl(STp->buffer->aux->last_mark_lbn) + 1 : 0):
1259 -1;
1260 }
1261 STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD:ST_NOEOF;
1262 return 0;
1263 }
1264 }
1265 if (osst_get_logical_frame(STp, aSRpnt, -1, 1) < 0)
1266 goto error;
1267 /* we are not yet at the estimated frame, adjust our estimate of its physical position */
1268 #if DEBUG
1269 printk(OSST_DEB_MSG "%s:D: Seek retry %d at ppos %d fsq %d (est %d) lbn %d (need %d)\n",
1270 name, retries, ppos_estimate, STp->frame_seq_number, frame_seq_estimate,
1271 STp->logical_blk_num, logical_blk_num);
1272 #endif
1273 if (frame_seq_estimate != STp->frame_seq_number)
1274 ppos_estimate += frame_seq_estimate - STp->frame_seq_number;
1275 else
1276 break;
1277 }
1278 error:
1279 printk(KERN_ERR "%s:E: Couldn't seek to logical block %d (at %d), %d retries\n",
1280 name, logical_blk_num, STp->logical_blk_num, retries);
1281 return (-EIO);
1282 }
1283
1284 /* The values below are based on the OnStream frame payload size of 32K == 2**15,
1285 * that is, OSST_FRAME_SHIFT + OSST_SECTOR_SHIFT must be 15. With a minimum block
1286 * size of 512 bytes, we need to be able to resolve 32K/512 == 64 == 2**6 positions
1287 * inside each frame. Finaly, OSST_SECTOR_MASK == 2**OSST_FRAME_SHIFT - 1.
1288 */
1289 #define OSST_FRAME_SHIFT 6
1290 #define OSST_SECTOR_SHIFT 9
1291 #define OSST_SECTOR_MASK 0x03F
1292
1293 static int osst_get_sector(struct osst_tape * STp, struct osst_request ** aSRpnt)
1294 {
1295 int sector;
1296 #if DEBUG
1297 char * name = tape_name(STp);
1298
1299 printk(OSST_DEB_MSG
1300 "%s:D: Positioned at ppos %d, frame %d, lbn %d, file %d, blk %d, %cptr %d, eof %d\n",
1301 name, STp->first_frame_position, STp->frame_seq_number, STp->logical_blk_num,
1302 STp->ps[STp->partition].drv_file, STp->ps[STp->partition].drv_block,
1303 STp->ps[STp->partition].rw == ST_WRITING?'w':'r',
1304 STp->ps[STp->partition].rw == ST_WRITING?STp->buffer->buffer_bytes:
1305 STp->buffer->read_pointer, STp->ps[STp->partition].eof);
1306 #endif
1307 /* do we know where we are inside a file? */
1308 if (STp->ps[STp->partition].drv_block >= 0) {
1309 sector = (STp->frame_in_buffer ? STp->first_frame_position-1 :
1310 STp->first_frame_position) << OSST_FRAME_SHIFT;
1311 if (STp->ps[STp->partition].rw == ST_WRITING)
1312 sector |= (STp->buffer->buffer_bytes >> OSST_SECTOR_SHIFT) & OSST_SECTOR_MASK;
1313 else
1314 sector |= (STp->buffer->read_pointer >> OSST_SECTOR_SHIFT) & OSST_SECTOR_MASK;
1315 } else {
1316 sector = osst_get_frame_position(STp, aSRpnt);
1317 if (sector > 0)
1318 sector <<= OSST_FRAME_SHIFT;
1319 }
1320 return sector;
1321 }
1322
1323 static int osst_seek_sector(struct osst_tape * STp, struct osst_request ** aSRpnt, int sector)
1324 {
1325 struct st_partstat * STps = &(STp->ps[STp->partition]);
1326 int frame = sector >> OSST_FRAME_SHIFT,
1327 offset = (sector & OSST_SECTOR_MASK) << OSST_SECTOR_SHIFT,
1328 r;
1329 #if DEBUG
1330 char * name = tape_name(STp);
1331
1332 printk(OSST_DEB_MSG "%s:D: Seeking sector %d in frame %d at offset %d\n",
1333 name, sector, frame, offset);
1334 #endif
1335 if (frame < 0 || frame >= STp->capacity) return (-ENXIO);
1336
1337 if (frame <= STp->first_data_ppos) {
1338 STp->frame_seq_number = STp->logical_blk_num = STps->drv_file = STps->drv_block = 0;
1339 return (osst_set_frame_position(STp, aSRpnt, frame, 0));
1340 }
1341 r = osst_set_frame_position(STp, aSRpnt, offset?frame:frame-1, 0);
1342 if (r < 0) return r;
1343
1344 r = osst_get_logical_frame(STp, aSRpnt, -1, 1);
1345 if (r < 0) return r;
1346
1347 if (osst_get_frame_position(STp, aSRpnt) != (offset?frame+1:frame)) return (-EIO);
1348
1349 if (offset) {
1350 STp->logical_blk_num += offset / STp->block_size;
1351 STp->buffer->read_pointer = offset;
1352 STp->buffer->buffer_bytes -= offset;
1353 } else {
1354 STp->frame_seq_number++;
1355 STp->frame_in_buffer = 0;
1356 STp->logical_blk_num += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
1357 STp->buffer->buffer_bytes = STp->buffer->read_pointer = 0;
1358 }
1359 STps->drv_file = ntohl(STp->buffer->aux->filemark_cnt);
1360 if (STps->eof == ST_FM_HIT) {
1361 STps->drv_file++;
1362 STps->drv_block = 0;
1363 } else {
1364 STps->drv_block = ntohl(STp->buffer->aux->last_mark_lbn)?
1365 STp->logical_blk_num -
1366 (STps->drv_file ? ntohl(STp->buffer->aux->last_mark_lbn) + 1 : 0):
1367 -1;
1368 }
1369 STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD:ST_NOEOF;
1370 #if DEBUG
1371 printk(OSST_DEB_MSG
1372 "%s:D: Now positioned at ppos %d, frame %d, lbn %d, file %d, blk %d, rptr %d, eof %d\n",
1373 name, STp->first_frame_position, STp->frame_seq_number, STp->logical_blk_num,
1374 STps->drv_file, STps->drv_block, STp->buffer->read_pointer, STps->eof);
1375 #endif
1376 return 0;
1377 }
1378
1379 /*
1380 * Read back the drive's internal buffer contents, as a part
1381 * of the write error recovery mechanism for old OnStream
1382 * firmware revisions.
1383 * Precondition for this function to work: all frames in the
1384 * drive's buffer must be of one type (DATA, MARK or EOD)!
1385 */
1386 static int osst_read_back_buffer_and_rewrite(struct osst_tape * STp, struct osst_request ** aSRpnt,
1387 unsigned int frame, unsigned int skip, int pending)
1388 {
1389 struct osst_request * SRpnt = * aSRpnt;
1390 unsigned char * buffer, * p;
1391 unsigned char cmd[MAX_COMMAND_SIZE];
1392 int flag, new_frame, i;
1393 int nframes = STp->cur_frames;
1394 int blks_per_frame = ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
1395 int frame_seq_number = ntohl(STp->buffer->aux->frame_seq_num)
1396 - (nframes + pending - 1);
1397 int logical_blk_num = ntohl(STp->buffer->aux->logical_blk_num)
1398 - (nframes + pending - 1) * blks_per_frame;
1399 char * name = tape_name(STp);
1400 unsigned long startwait = jiffies;
1401 #if DEBUG
1402 int dbg = debugging;
1403 #endif
1404
1405 if ((buffer = (unsigned char *)vmalloc((nframes + 1) * OS_DATA_SIZE)) == NULL)
1406 return (-EIO);
1407
1408 printk(KERN_INFO "%s:I: Reading back %d frames from drive buffer%s\n",
1409 name, nframes, pending?" and one that was pending":"");
1410
1411 osst_copy_from_buffer(STp->buffer, (p = &buffer[nframes * OS_DATA_SIZE]));
1412 #if DEBUG
1413 if (pending && debugging)
1414 printk(OSST_DEB_MSG "%s:D: Pending frame %d (lblk %d), data %02x %02x %02x %02x\n",
1415 name, frame_seq_number + nframes,
1416 logical_blk_num + nframes * blks_per_frame,
1417 p[0], p[1], p[2], p[3]);
1418 #endif
1419 for (i = 0, p = buffer; i < nframes; i++, p += OS_DATA_SIZE) {
1420
1421 memset(cmd, 0, MAX_COMMAND_SIZE);
1422 cmd[0] = 0x3C; /* Buffer Read */
1423 cmd[1] = 6; /* Retrieve Faulty Block */
1424 cmd[7] = 32768 >> 8;
1425 cmd[8] = 32768 & 0xff;
1426
1427 SRpnt = osst_do_scsi(SRpnt, STp, cmd, OS_FRAME_SIZE, DMA_FROM_DEVICE,
1428 STp->timeout, MAX_RETRIES, 1);
1429
1430 if ((STp->buffer)->syscall_result || !SRpnt) {
1431 printk(KERN_ERR "%s:E: Failed to read frame back from OnStream buffer\n", name);
1432 vfree(buffer);
1433 *aSRpnt = SRpnt;
1434 return (-EIO);
1435 }
1436 osst_copy_from_buffer(STp->buffer, p);
1437 #if DEBUG
1438 if (debugging)
1439 printk(OSST_DEB_MSG "%s:D: Read back logical frame %d, data %02x %02x %02x %02x\n",
1440 name, frame_seq_number + i, p[0], p[1], p[2], p[3]);
1441 #endif
1442 }
1443 *aSRpnt = SRpnt;
1444 osst_get_frame_position(STp, aSRpnt);
1445
1446 #if DEBUG
1447 printk(OSST_DEB_MSG "%s:D: Frames left in buffer: %d\n", name, STp->cur_frames);
1448 #endif
1449 /* Write synchronously so we can be sure we're OK again and don't have to recover recursively */
1450 /* In the header we don't actually re-write the frames that fail, just the ones after them */
1451
1452 for (flag=1, new_frame=frame, p=buffer, i=0; i < nframes + pending; ) {
1453
1454 if (flag) {
1455 if (STp->write_type == OS_WRITE_HEADER) {
1456 i += skip;
1457 p += skip * OS_DATA_SIZE;
1458 }
1459 else if (new_frame < 2990 && new_frame+skip+nframes+pending >= 2990)
1460 new_frame = 3000-i;
1461 else
1462 new_frame += skip;
1463 #if DEBUG
1464 printk(OSST_DEB_MSG "%s:D: Position to frame %d, write fseq %d\n",
1465 name, new_frame+i, frame_seq_number+i);
1466 #endif
1467 osst_set_frame_position(STp, aSRpnt, new_frame + i, 0);
1468 osst_wait_ready(STp, aSRpnt, 60, OSST_WAIT_POSITION_COMPLETE);
1469 osst_get_frame_position(STp, aSRpnt);
1470 SRpnt = * aSRpnt;
1471
1472 if (new_frame > frame + 1000) {
1473 printk(KERN_ERR "%s:E: Failed to find writable tape media\n", name);
1474 vfree(buffer);
1475 return (-EIO);
1476 }
1477 if ( i >= nframes + pending ) break;
1478 flag = 0;
1479 }
1480 osst_copy_to_buffer(STp->buffer, p);
1481 /*
1482 * IMPORTANT: for error recovery to work, _never_ queue frames with mixed frame type!
1483 */
1484 osst_init_aux(STp, STp->buffer->aux->frame_type, frame_seq_number+i,
1485 logical_blk_num + i*blks_per_frame,
1486 ntohl(STp->buffer->aux->dat.dat_list[0].blk_sz), blks_per_frame);
1487 memset(cmd, 0, MAX_COMMAND_SIZE);
1488 cmd[0] = WRITE_6;
1489 cmd[1] = 1;
1490 cmd[4] = 1;
1491
1492 #if DEBUG
1493 if (debugging)
1494 printk(OSST_DEB_MSG
1495 "%s:D: About to write frame %d, seq %d, lbn %d, data %02x %02x %02x %02x\n",
1496 name, new_frame+i, frame_seq_number+i, logical_blk_num + i*blks_per_frame,
1497 p[0], p[1], p[2], p[3]);
1498 #endif
1499 SRpnt = osst_do_scsi(SRpnt, STp, cmd, OS_FRAME_SIZE, DMA_TO_DEVICE,
1500 STp->timeout, MAX_RETRIES, 1);
1501
1502 if (STp->buffer->syscall_result)
1503 flag = 1;
1504 else {
1505 p += OS_DATA_SIZE; i++;
1506
1507 /* if we just sent the last frame, wait till all successfully written */
1508 if ( i == nframes + pending ) {
1509 #if DEBUG
1510 printk(OSST_DEB_MSG "%s:D: Check re-write successful\n", name);
1511 #endif
1512 memset(cmd, 0, MAX_COMMAND_SIZE);
1513 cmd[0] = WRITE_FILEMARKS;
1514 cmd[1] = 1;
1515 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
1516 STp->timeout, MAX_RETRIES, 1);
1517 #if DEBUG
1518 if (debugging) {
1519 printk(OSST_DEB_MSG "%s:D: Sleeping in re-write wait ready\n", name);
1520 printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name);
1521 debugging = 0;
1522 }
1523 #endif
1524 flag = STp->buffer->syscall_result;
1525 while ( !flag && time_before(jiffies, startwait + 60*HZ) ) {
1526
1527 memset(cmd, 0, MAX_COMMAND_SIZE);
1528 cmd[0] = TEST_UNIT_READY;
1529
1530 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, STp->timeout,
1531 MAX_RETRIES, 1);
1532
1533 if (SRpnt->sense[2] == 2 && SRpnt->sense[12] == 4 &&
1534 (SRpnt->sense[13] == 1 || SRpnt->sense[13] == 8)) {
1535 /* in the process of becoming ready */
1536 msleep(100);
1537 continue;
1538 }
1539 if (STp->buffer->syscall_result)
1540 flag = 1;
1541 break;
1542 }
1543 #if DEBUG
1544 debugging = dbg;
1545 printk(OSST_DEB_MSG "%s:D: Wait re-write finished\n", name);
1546 #endif
1547 }
1548 }
1549 *aSRpnt = SRpnt;
1550 if (flag) {
1551 if ((SRpnt->sense[ 2] & 0x0f) == 13 &&
1552 SRpnt->sense[12] == 0 &&
1553 SRpnt->sense[13] == 2) {
1554 printk(KERN_ERR "%s:E: Volume overflow in write error recovery\n", name);
1555 vfree(buffer);
1556 return (-EIO); /* hit end of tape = fail */
1557 }
1558 i = ((SRpnt->sense[3] << 24) |
1559 (SRpnt->sense[4] << 16) |
1560 (SRpnt->sense[5] << 8) |
1561 SRpnt->sense[6] ) - new_frame;
1562 p = &buffer[i * OS_DATA_SIZE];
1563 #if DEBUG
1564 printk(OSST_DEB_MSG "%s:D: Additional write error at %d\n", name, new_frame+i);
1565 #endif
1566 osst_get_frame_position(STp, aSRpnt);
1567 #if DEBUG
1568 printk(OSST_DEB_MSG "%s:D: reported frame positions: host = %d, tape = %d, buffer = %d\n",
1569 name, STp->first_frame_position, STp->last_frame_position, STp->cur_frames);
1570 #endif
1571 }
1572 }
1573 if (flag) {
1574 /* error recovery did not successfully complete */
1575 printk(KERN_ERR "%s:D: Write error recovery failed in %s\n", name,
1576 STp->write_type == OS_WRITE_HEADER?"header":"body");
1577 }
1578 if (!pending)
1579 osst_copy_to_buffer(STp->buffer, p); /* so buffer content == at entry in all cases */
1580 vfree(buffer);
1581 return 0;
1582 }
1583
1584 static int osst_reposition_and_retry(struct osst_tape * STp, struct osst_request ** aSRpnt,
1585 unsigned int frame, unsigned int skip, int pending)
1586 {
1587 unsigned char cmd[MAX_COMMAND_SIZE];
1588 struct osst_request * SRpnt;
1589 char * name = tape_name(STp);
1590 int expected = 0;
1591 int attempts = 1000 / skip;
1592 int flag = 1;
1593 unsigned long startwait = jiffies;
1594 #if DEBUG
1595 int dbg = debugging;
1596 #endif
1597
1598 while (attempts && time_before(jiffies, startwait + 60*HZ)) {
1599 if (flag) {
1600 #if DEBUG
1601 debugging = dbg;
1602 #endif
1603 if (frame < 2990 && frame+skip+STp->cur_frames+pending >= 2990)
1604 frame = 3000-skip;
1605 expected = frame+skip+STp->cur_frames+pending;
1606 #if DEBUG
1607 printk(OSST_DEB_MSG "%s:D: Position to fppos %d, re-write from fseq %d\n",
1608 name, frame+skip, STp->frame_seq_number-STp->cur_frames-pending);
1609 #endif
1610 osst_set_frame_position(STp, aSRpnt, frame + skip, 1);
1611 flag = 0;
1612 attempts--;
1613 schedule_timeout_interruptible(msecs_to_jiffies(100));
1614 }
1615 if (osst_get_frame_position(STp, aSRpnt) < 0) { /* additional write error */
1616 #if DEBUG
1617 printk(OSST_DEB_MSG "%s:D: Addl error, host %d, tape %d, buffer %d\n",
1618 name, STp->first_frame_position,
1619 STp->last_frame_position, STp->cur_frames);
1620 #endif
1621 frame = STp->last_frame_position;
1622 flag = 1;
1623 continue;
1624 }
1625 if (pending && STp->cur_frames < 50) {
1626
1627 memset(cmd, 0, MAX_COMMAND_SIZE);
1628 cmd[0] = WRITE_6;
1629 cmd[1] = 1;
1630 cmd[4] = 1;
1631 #if DEBUG
1632 printk(OSST_DEB_MSG "%s:D: About to write pending fseq %d at fppos %d\n",
1633 name, STp->frame_seq_number-1, STp->first_frame_position);
1634 #endif
1635 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, OS_FRAME_SIZE, DMA_TO_DEVICE,
1636 STp->timeout, MAX_RETRIES, 1);
1637 *aSRpnt = SRpnt;
1638
1639 if (STp->buffer->syscall_result) { /* additional write error */
1640 if ((SRpnt->sense[ 2] & 0x0f) == 13 &&
1641 SRpnt->sense[12] == 0 &&
1642 SRpnt->sense[13] == 2) {
1643 printk(KERN_ERR
1644 "%s:E: Volume overflow in write error recovery\n",
1645 name);
1646 break; /* hit end of tape = fail */
1647 }
1648 flag = 1;
1649 }
1650 else
1651 pending = 0;
1652
1653 continue;
1654 }
1655 if (STp->cur_frames == 0) {
1656 #if DEBUG
1657 debugging = dbg;
1658 printk(OSST_DEB_MSG "%s:D: Wait re-write finished\n", name);
1659 #endif
1660 if (STp->first_frame_position != expected) {
1661 printk(KERN_ERR "%s:A: Actual position %d - expected %d\n",
1662 name, STp->first_frame_position, expected);
1663 return (-EIO);
1664 }
1665 return 0;
1666 }
1667 #if DEBUG
1668 if (debugging) {
1669 printk(OSST_DEB_MSG "%s:D: Sleeping in re-write wait ready\n", name);
1670 printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name);
1671 debugging = 0;
1672 }
1673 #endif
1674 schedule_timeout_interruptible(msecs_to_jiffies(100));
1675 }
1676 printk(KERN_ERR "%s:E: Failed to find valid tape media\n", name);
1677 #if DEBUG
1678 debugging = dbg;
1679 #endif
1680 return (-EIO);
1681 }
1682
1683 /*
1684 * Error recovery algorithm for the OnStream tape.
1685 */
1686
1687 static int osst_write_error_recovery(struct osst_tape * STp, struct osst_request ** aSRpnt, int pending)
1688 {
1689 struct osst_request * SRpnt = * aSRpnt;
1690 struct st_partstat * STps = & STp->ps[STp->partition];
1691 char * name = tape_name(STp);
1692 int retval = 0;
1693 int rw_state;
1694 unsigned int frame, skip;
1695
1696 rw_state = STps->rw;
1697
1698 if ((SRpnt->sense[ 2] & 0x0f) != 3
1699 || SRpnt->sense[12] != 12
1700 || SRpnt->sense[13] != 0) {
1701 #if DEBUG
1702 printk(OSST_DEB_MSG "%s:D: Write error recovery cannot handle %02x:%02x:%02x\n", name,
1703 SRpnt->sense[2], SRpnt->sense[12], SRpnt->sense[13]);
1704 #endif
1705 return (-EIO);
1706 }
1707 frame = (SRpnt->sense[3] << 24) |
1708 (SRpnt->sense[4] << 16) |
1709 (SRpnt->sense[5] << 8) |
1710 SRpnt->sense[6];
1711 skip = SRpnt->sense[9];
1712
1713 #if DEBUG
1714 printk(OSST_DEB_MSG "%s:D: Detected physical bad frame at %u, advised to skip %d\n", name, frame, skip);
1715 #endif
1716 osst_get_frame_position(STp, aSRpnt);
1717 #if DEBUG
1718 printk(OSST_DEB_MSG "%s:D: reported frame positions: host = %d, tape = %d\n",
1719 name, STp->first_frame_position, STp->last_frame_position);
1720 #endif
1721 switch (STp->write_type) {
1722 case OS_WRITE_DATA:
1723 case OS_WRITE_EOD:
1724 case OS_WRITE_NEW_MARK:
1725 printk(KERN_WARNING
1726 "%s:I: Relocating %d buffered logical frames from position %u to %u\n",
1727 name, STp->cur_frames, frame, (frame + skip > 3000 && frame < 3000)?3000:frame + skip);
1728 if (STp->os_fw_rev >= 10600)
1729 retval = osst_reposition_and_retry(STp, aSRpnt, frame, skip, pending);
1730 else
1731 retval = osst_read_back_buffer_and_rewrite(STp, aSRpnt, frame, skip, pending);
1732 printk(KERN_WARNING "%s:%s: %sWrite error%srecovered\n", name,
1733 retval?"E" :"I",
1734 retval?"" :"Don't worry, ",
1735 retval?" not ":" ");
1736 break;
1737 case OS_WRITE_LAST_MARK:
1738 printk(KERN_ERR "%s:E: Bad frame in update last marker, fatal\n", name);
1739 osst_set_frame_position(STp, aSRpnt, frame + STp->cur_frames + pending, 0);
1740 retval = -EIO;
1741 break;
1742 case OS_WRITE_HEADER:
1743 printk(KERN_WARNING "%s:I: Bad frame in header partition, skipped\n", name);
1744 retval = osst_read_back_buffer_and_rewrite(STp, aSRpnt, frame, 1, pending);
1745 break;
1746 default:
1747 printk(KERN_INFO "%s:I: Bad frame in filler, ignored\n", name);
1748 osst_set_frame_position(STp, aSRpnt, frame + STp->cur_frames + pending, 0);
1749 }
1750 osst_get_frame_position(STp, aSRpnt);
1751 #if DEBUG
1752 printk(OSST_DEB_MSG "%s:D: Positioning complete, cur_frames %d, pos %d, tape pos %d\n",
1753 name, STp->cur_frames, STp->first_frame_position, STp->last_frame_position);
1754 printk(OSST_DEB_MSG "%s:D: next logical frame to write: %d\n", name, STp->logical_blk_num);
1755 #endif
1756 if (retval == 0) {
1757 STp->recover_count++;
1758 STp->recover_erreg++;
1759 } else
1760 STp->abort_count++;
1761
1762 STps->rw = rw_state;
1763 return retval;
1764 }
1765
1766 static int osst_space_over_filemarks_backward(struct osst_tape * STp, struct osst_request ** aSRpnt,
1767 int mt_op, int mt_count)
1768 {
1769 char * name = tape_name(STp);
1770 int cnt;
1771 int last_mark_ppos = -1;
1772
1773 #if DEBUG
1774 printk(OSST_DEB_MSG "%s:D: Reached space_over_filemarks_backwards %d %d\n", name, mt_op, mt_count);
1775 #endif
1776 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1777 #if DEBUG
1778 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks_bwd\n", name);
1779 #endif
1780 return -EIO;
1781 }
1782 if (STp->linux_media_version >= 4) {
1783 /*
1784 * direct lookup in header filemark list
1785 */
1786 cnt = ntohl(STp->buffer->aux->filemark_cnt);
1787 if (STp->header_ok &&
1788 STp->header_cache != NULL &&
1789 (cnt - mt_count) >= 0 &&
1790 (cnt - mt_count) < OS_FM_TAB_MAX &&
1791 (cnt - mt_count) < STp->filemark_cnt &&
1792 STp->header_cache->dat_fm_tab.fm_tab_ent[cnt-1] == STp->buffer->aux->last_mark_ppos)
1793
1794 last_mark_ppos = ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[cnt - mt_count]);
1795 #if DEBUG
1796 if (STp->header_cache == NULL || (cnt - mt_count) < 0 || (cnt - mt_count) >= OS_FM_TAB_MAX)
1797 printk(OSST_DEB_MSG "%s:D: Filemark lookup fail due to %s\n", name,
1798 STp->header_cache == NULL?"lack of header cache":"count out of range");
1799 else
1800 printk(OSST_DEB_MSG "%s:D: Filemark lookup: prev mark %d (%s), skip %d to %d\n",
1801 name, cnt,
1802 ((cnt == -1 && ntohl(STp->buffer->aux->last_mark_ppos) == -1) ||
1803 (STp->header_cache->dat_fm_tab.fm_tab_ent[cnt-1] ==
1804 STp->buffer->aux->last_mark_ppos))?"match":"error",
1805 mt_count, last_mark_ppos);
1806 #endif
1807 if (last_mark_ppos > 10 && last_mark_ppos < STp->eod_frame_ppos) {
1808 osst_position_tape_and_confirm(STp, aSRpnt, last_mark_ppos);
1809 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1810 #if DEBUG
1811 printk(OSST_DEB_MSG
1812 "%s:D: Couldn't get logical blk num in space_filemarks\n", name);
1813 #endif
1814 return (-EIO);
1815 }
1816 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
1817 printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n",
1818 name, last_mark_ppos);
1819 return (-EIO);
1820 }
1821 goto found;
1822 }
1823 #if DEBUG
1824 printk(OSST_DEB_MSG "%s:D: Reverting to scan filemark backwards\n", name);
1825 #endif
1826 }
1827 cnt = 0;
1828 while (cnt != mt_count) {
1829 last_mark_ppos = ntohl(STp->buffer->aux->last_mark_ppos);
1830 if (last_mark_ppos == -1)
1831 return (-EIO);
1832 #if DEBUG
1833 printk(OSST_DEB_MSG "%s:D: Positioning to last mark at %d\n", name, last_mark_ppos);
1834 #endif
1835 osst_position_tape_and_confirm(STp, aSRpnt, last_mark_ppos);
1836 cnt++;
1837 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1838 #if DEBUG
1839 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n", name);
1840 #endif
1841 return (-EIO);
1842 }
1843 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
1844 printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n",
1845 name, last_mark_ppos);
1846 return (-EIO);
1847 }
1848 }
1849 found:
1850 if (mt_op == MTBSFM) {
1851 STp->frame_seq_number++;
1852 STp->frame_in_buffer = 0;
1853 STp->buffer->buffer_bytes = 0;
1854 STp->buffer->read_pointer = 0;
1855 STp->logical_blk_num += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
1856 }
1857 return 0;
1858 }
1859
1860 /*
1861 * ADRL 1.1 compatible "slow" space filemarks fwd version
1862 *
1863 * Just scans for the filemark sequentially.
1864 */
1865 static int osst_space_over_filemarks_forward_slow(struct osst_tape * STp, struct osst_request ** aSRpnt,
1866 int mt_op, int mt_count)
1867 {
1868 int cnt = 0;
1869 #if DEBUG
1870 char * name = tape_name(STp);
1871
1872 printk(OSST_DEB_MSG "%s:D: Reached space_over_filemarks_forward_slow %d %d\n", name, mt_op, mt_count);
1873 #endif
1874 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1875 #if DEBUG
1876 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks_fwd\n", name);
1877 #endif
1878 return (-EIO);
1879 }
1880 while (1) {
1881 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1882 #if DEBUG
1883 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n", name);
1884 #endif
1885 return (-EIO);
1886 }
1887 if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_MARKER)
1888 cnt++;
1889 if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_EOD) {
1890 #if DEBUG
1891 printk(OSST_DEB_MSG "%s:D: space_fwd: EOD reached\n", name);
1892 #endif
1893 if (STp->first_frame_position > STp->eod_frame_ppos+1) {
1894 #if DEBUG
1895 printk(OSST_DEB_MSG "%s:D: EOD position corrected (%d=>%d)\n",
1896 name, STp->eod_frame_ppos, STp->first_frame_position-1);
1897 #endif
1898 STp->eod_frame_ppos = STp->first_frame_position-1;
1899 }
1900 return (-EIO);
1901 }
1902 if (cnt == mt_count)
1903 break;
1904 STp->frame_in_buffer = 0;
1905 }
1906 if (mt_op == MTFSF) {
1907 STp->frame_seq_number++;
1908 STp->frame_in_buffer = 0;
1909 STp->buffer->buffer_bytes = 0;
1910 STp->buffer->read_pointer = 0;
1911 STp->logical_blk_num += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
1912 }
1913 return 0;
1914 }
1915
1916 /*
1917 * Fast linux specific version of OnStream FSF
1918 */
1919 static int osst_space_over_filemarks_forward_fast(struct osst_tape * STp, struct osst_request ** aSRpnt,
1920 int mt_op, int mt_count)
1921 {
1922 char * name = tape_name(STp);
1923 int cnt = 0,
1924 next_mark_ppos = -1;
1925
1926 #if DEBUG
1927 printk(OSST_DEB_MSG "%s:D: Reached space_over_filemarks_forward_fast %d %d\n", name, mt_op, mt_count);
1928 #endif
1929 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1930 #if DEBUG
1931 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks_fwd\n", name);
1932 #endif
1933 return (-EIO);
1934 }
1935
1936 if (STp->linux_media_version >= 4) {
1937 /*
1938 * direct lookup in header filemark list
1939 */
1940 cnt = ntohl(STp->buffer->aux->filemark_cnt) - 1;
1941 if (STp->header_ok &&
1942 STp->header_cache != NULL &&
1943 (cnt + mt_count) < OS_FM_TAB_MAX &&
1944 (cnt + mt_count) < STp->filemark_cnt &&
1945 ((cnt == -1 && ntohl(STp->buffer->aux->last_mark_ppos) == -1) ||
1946 (STp->header_cache->dat_fm_tab.fm_tab_ent[cnt] == STp->buffer->aux->last_mark_ppos)))
1947
1948 next_mark_ppos = ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[cnt + mt_count]);
1949 #if DEBUG
1950 if (STp->header_cache == NULL || (cnt + mt_count) >= OS_FM_TAB_MAX)
1951 printk(OSST_DEB_MSG "%s:D: Filemark lookup fail due to %s\n", name,
1952 STp->header_cache == NULL?"lack of header cache":"count out of range");
1953 else
1954 printk(OSST_DEB_MSG "%s:D: Filemark lookup: prev mark %d (%s), skip %d to %d\n",
1955 name, cnt,
1956 ((cnt == -1 && ntohl(STp->buffer->aux->last_mark_ppos) == -1) ||
1957 (STp->header_cache->dat_fm_tab.fm_tab_ent[cnt] ==
1958 STp->buffer->aux->last_mark_ppos))?"match":"error",
1959 mt_count, next_mark_ppos);
1960 #endif
1961 if (next_mark_ppos <= 10 || next_mark_ppos > STp->eod_frame_ppos) {
1962 #if DEBUG
1963 printk(OSST_DEB_MSG "%s:D: Reverting to slow filemark space\n", name);
1964 #endif
1965 return osst_space_over_filemarks_forward_slow(STp, aSRpnt, mt_op, mt_count);
1966 } else {
1967 osst_position_tape_and_confirm(STp, aSRpnt, next_mark_ppos);
1968 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1969 #if DEBUG
1970 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n",
1971 name);
1972 #endif
1973 return (-EIO);
1974 }
1975 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
1976 printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n",
1977 name, next_mark_ppos);
1978 return (-EIO);
1979 }
1980 if (ntohl(STp->buffer->aux->filemark_cnt) != cnt + mt_count) {
1981 printk(KERN_WARNING "%s:W: Expected to find marker %d at ppos %d, not %d\n",
1982 name, cnt+mt_count, next_mark_ppos,
1983 ntohl(STp->buffer->aux->filemark_cnt));
1984 return (-EIO);
1985 }
1986 }
1987 } else {
1988 /*
1989 * Find nearest (usually previous) marker, then jump from marker to marker
1990 */
1991 while (1) {
1992 if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_MARKER)
1993 break;
1994 if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_EOD) {
1995 #if DEBUG
1996 printk(OSST_DEB_MSG "%s:D: space_fwd: EOD reached\n", name);
1997 #endif
1998 return (-EIO);
1999 }
2000 if (ntohl(STp->buffer->aux->filemark_cnt) == 0) {
2001 if (STp->first_mark_ppos == -1) {
2002 #if DEBUG
2003 printk(OSST_DEB_MSG "%s:D: Reverting to slow filemark space\n", name);
2004 #endif
2005 return osst_space_over_filemarks_forward_slow(STp, aSRpnt, mt_op, mt_count);
2006 }
2007 osst_position_tape_and_confirm(STp, aSRpnt, STp->first_mark_ppos);
2008 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
2009 #if DEBUG
2010 printk(OSST_DEB_MSG
2011 "%s:D: Couldn't get logical blk num in space_filemarks_fwd_fast\n",
2012 name);
2013 #endif
2014 return (-EIO);
2015 }
2016 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
2017 printk(KERN_WARNING "%s:W: Expected to find filemark at %d\n",
2018 name, STp->first_mark_ppos);
2019 return (-EIO);
2020 }
2021 } else {
2022 if (osst_space_over_filemarks_backward(STp, aSRpnt, MTBSF, 1) < 0)
2023 return (-EIO);
2024 mt_count++;
2025 }
2026 }
2027 cnt++;
2028 while (cnt != mt_count) {
2029 next_mark_ppos = ntohl(STp->buffer->aux->next_mark_ppos);
2030 if (!next_mark_ppos || next_mark_ppos > STp->eod_frame_ppos) {
2031 #if DEBUG
2032 printk(OSST_DEB_MSG "%s:D: Reverting to slow filemark space\n", name);
2033 #endif
2034 return osst_space_over_filemarks_forward_slow(STp, aSRpnt, mt_op, mt_count - cnt);
2035 }
2036 #if DEBUG
2037 else printk(OSST_DEB_MSG "%s:D: Positioning to next mark at %d\n", name, next_mark_ppos);
2038 #endif
2039 osst_position_tape_and_confirm(STp, aSRpnt, next_mark_ppos);
2040 cnt++;
2041 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
2042 #if DEBUG
2043 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n",
2044 name);
2045 #endif
2046 return (-EIO);
2047 }
2048 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
2049 printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n",
2050 name, next_mark_ppos);
2051 return (-EIO);
2052 }
2053 }
2054 }
2055 if (mt_op == MTFSF) {
2056 STp->frame_seq_number++;
2057 STp->frame_in_buffer = 0;
2058 STp->buffer->buffer_bytes = 0;
2059 STp->buffer->read_pointer = 0;
2060 STp->logical_blk_num += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
2061 }
2062 return 0;
2063 }
2064
2065 /*
2066 * In debug mode, we want to see as many errors as possible
2067 * to test the error recovery mechanism.
2068 */
2069 #if DEBUG
2070 static void osst_set_retries(struct osst_tape * STp, struct osst_request ** aSRpnt, int retries)
2071 {
2072 unsigned char cmd[MAX_COMMAND_SIZE];
2073 struct osst_request * SRpnt = * aSRpnt;
2074 char * name = tape_name(STp);
2075
2076 memset(cmd, 0, MAX_COMMAND_SIZE);
2077 cmd[0] = MODE_SELECT;
2078 cmd[1] = 0x10;
2079 cmd[4] = NUMBER_RETRIES_PAGE_LENGTH + MODE_HEADER_LENGTH;
2080
2081 (STp->buffer)->b_data[0] = cmd[4] - 1;
2082 (STp->buffer)->b_data[1] = 0; /* Medium Type - ignoring */
2083 (STp->buffer)->b_data[2] = 0; /* Reserved */
2084 (STp->buffer)->b_data[3] = 0; /* Block Descriptor Length */
2085 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 0] = NUMBER_RETRIES_PAGE | (1 << 7);
2086 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 1] = 2;
2087 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] = 4;
2088 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 3] = retries;
2089
2090 if (debugging)
2091 printk(OSST_DEB_MSG "%s:D: Setting number of retries on OnStream tape to %d\n", name, retries);
2092
2093 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1);
2094 *aSRpnt = SRpnt;
2095
2096 if ((STp->buffer)->syscall_result)
2097 printk (KERN_ERR "%s:D: Couldn't set retries to %d\n", name, retries);
2098 }
2099 #endif
2100
2101
2102 static int osst_write_filemark(struct osst_tape * STp, struct osst_request ** aSRpnt)
2103 {
2104 int result;
2105 int this_mark_ppos = STp->first_frame_position;
2106 int this_mark_lbn = STp->logical_blk_num;
2107 #if DEBUG
2108 char * name = tape_name(STp);
2109 #endif
2110
2111 if (STp->raw) return 0;
2112
2113 STp->write_type = OS_WRITE_NEW_MARK;
2114 #if DEBUG
2115 printk(OSST_DEB_MSG "%s:D: Writing Filemark %i at fppos %d (fseq %d, lblk %d)\n",
2116 name, STp->filemark_cnt, this_mark_ppos, STp->frame_seq_number, this_mark_lbn);
2117 #endif
2118 STp->dirty = 1;
2119 result = osst_flush_write_buffer(STp, aSRpnt);
2120 result |= osst_flush_drive_buffer(STp, aSRpnt);
2121 STp->last_mark_ppos = this_mark_ppos;
2122 STp->last_mark_lbn = this_mark_lbn;
2123 if (STp->header_cache != NULL && STp->filemark_cnt < OS_FM_TAB_MAX)
2124 STp->header_cache->dat_fm_tab.fm_tab_ent[STp->filemark_cnt] = htonl(this_mark_ppos);
2125 if (STp->filemark_cnt++ == 0)
2126 STp->first_mark_ppos = this_mark_ppos;
2127 return result;
2128 }
2129
2130 static int osst_write_eod(struct osst_tape * STp, struct osst_request ** aSRpnt)
2131 {
2132 int result;
2133 #if DEBUG
2134 char * name = tape_name(STp);
2135 #endif
2136
2137 if (STp->raw) return 0;
2138
2139 STp->write_type = OS_WRITE_EOD;
2140 STp->eod_frame_ppos = STp->first_frame_position;
2141 #if DEBUG
2142 printk(OSST_DEB_MSG "%s:D: Writing EOD at fppos %d (fseq %d, lblk %d)\n", name,
2143 STp->eod_frame_ppos, STp->frame_seq_number, STp->logical_blk_num);
2144 #endif
2145 STp->dirty = 1;
2146
2147 result = osst_flush_write_buffer(STp, aSRpnt);
2148 result |= osst_flush_drive_buffer(STp, aSRpnt);
2149 STp->eod_frame_lfa = --(STp->frame_seq_number);
2150 return result;
2151 }
2152
2153 static int osst_write_filler(struct osst_tape * STp, struct osst_request ** aSRpnt, int where, int count)
2154 {
2155 char * name = tape_name(STp);
2156
2157 #if DEBUG
2158 printk(OSST_DEB_MSG "%s:D: Reached onstream write filler group %d\n", name, where);
2159 #endif
2160 osst_wait_ready(STp, aSRpnt, 60 * 5, 0);
2161 osst_set_frame_position(STp, aSRpnt, where, 0);
2162 STp->write_type = OS_WRITE_FILLER;
2163 while (count--) {
2164 memcpy(STp->buffer->b_data, "Filler", 6);
2165 STp->buffer->buffer_bytes = 6;
2166 STp->dirty = 1;
2167 if (osst_flush_write_buffer(STp, aSRpnt)) {
2168 printk(KERN_INFO "%s:I: Couldn't write filler frame\n", name);
2169 return (-EIO);
2170 }
2171 }
2172 #if DEBUG
2173 printk(OSST_DEB_MSG "%s:D: Exiting onstream write filler group\n", name);
2174 #endif
2175 return osst_flush_drive_buffer(STp, aSRpnt);
2176 }
2177
2178 static int __osst_write_header(struct osst_tape * STp, struct osst_request ** aSRpnt, int where, int count)
2179 {
2180 char * name = tape_name(STp);
2181 int result;
2182
2183 #if DEBUG
2184 printk(OSST_DEB_MSG "%s:D: Reached onstream write header group %d\n", name, where);
2185 #endif
2186 osst_wait_ready(STp, aSRpnt, 60 * 5, 0);
2187 osst_set_frame_position(STp, aSRpnt, where, 0);
2188 STp->write_type = OS_WRITE_HEADER;
2189 while (count--) {
2190 osst_copy_to_buffer(STp->buffer, (unsigned char *)STp->header_cache);
2191 STp->buffer->buffer_bytes = sizeof(os_header_t);
2192 STp->dirty = 1;
2193 if (osst_flush_write_buffer(STp, aSRpnt)) {
2194 printk(KERN_INFO "%s:I: Couldn't write header frame\n", name);
2195 return (-EIO);
2196 }
2197 }
2198 result = osst_flush_drive_buffer(STp, aSRpnt);
2199 #if DEBUG
2200 printk(OSST_DEB_MSG "%s:D: Write onstream header group %s\n", name, result?"failed":"done");
2201 #endif
2202 return result;
2203 }
2204
2205 static int osst_write_header(struct osst_tape * STp, struct osst_request ** aSRpnt, int locate_eod)
2206 {
2207 os_header_t * header;
2208 int result;
2209 char * name = tape_name(STp);
2210
2211 #if DEBUG
2212 printk(OSST_DEB_MSG "%s:D: Writing tape header\n", name);
2213 #endif
2214 if (STp->raw) return 0;
2215
2216 if (STp->header_cache == NULL) {
2217 if ((STp->header_cache = (os_header_t *)vmalloc(sizeof(os_header_t))) == NULL) {
2218 printk(KERN_ERR "%s:E: Failed to allocate header cache\n", name);
2219 return (-ENOMEM);
2220 }
2221 memset(STp->header_cache, 0, sizeof(os_header_t));
2222 #if DEBUG
2223 printk(OSST_DEB_MSG "%s:D: Allocated and cleared memory for header cache\n", name);
2224 #endif
2225 }
2226 if (STp->header_ok) STp->update_frame_cntr++;
2227 else STp->update_frame_cntr = 0;
2228
2229 header = STp->header_cache;
2230 strcpy(header->ident_str, "ADR_SEQ");
2231 header->major_rev = 1;
2232 header->minor_rev = 4;
2233 header->ext_trk_tb_off = htons(17192);
2234 header->pt_par_num = 1;
2235 header->partition[0].partition_num = OS_DATA_PARTITION;
2236 header->partition[0].par_desc_ver = OS_PARTITION_VERSION;
2237 header->partition[0].wrt_pass_cntr = htons(STp->wrt_pass_cntr);
2238 header->partition[0].first_frame_ppos = htonl(STp->first_data_ppos);
2239 header->partition[0].last_frame_ppos = htonl(STp->capacity);
2240 header->partition[0].eod_frame_ppos = htonl(STp->eod_frame_ppos);
2241 header->cfg_col_width = htonl(20);
2242 header->dat_col_width = htonl(1500);
2243 header->qfa_col_width = htonl(0);
2244 header->ext_track_tb.nr_stream_part = 1;
2245 header->ext_track_tb.et_ent_sz = 32;
2246 header->ext_track_tb.dat_ext_trk_ey.et_part_num = 0;
2247 header->ext_track_tb.dat_ext_trk_ey.fmt = 1;
2248 header->ext_track_tb.dat_ext_trk_ey.fm_tab_off = htons(17736);
2249 header->ext_track_tb.dat_ext_trk_ey.last_hlb_hi = 0;
2250 header->ext_track_tb.dat_ext_trk_ey.last_hlb = htonl(STp->eod_frame_lfa);
2251 header->ext_track_tb.dat_ext_trk_ey.last_pp = htonl(STp->eod_frame_ppos);
2252 header->dat_fm_tab.fm_part_num = 0;
2253 header->dat_fm_tab.fm_tab_ent_sz = 4;
2254 header->dat_fm_tab.fm_tab_ent_cnt = htons(STp->filemark_cnt<OS_FM_TAB_MAX?
2255 STp->filemark_cnt:OS_FM_TAB_MAX);
2256
2257 result = __osst_write_header(STp, aSRpnt, 0xbae, 5);
2258 if (STp->update_frame_cntr == 0)
2259 osst_write_filler(STp, aSRpnt, 0xbb3, 5);
2260 result &= __osst_write_header(STp, aSRpnt, 5, 5);
2261
2262 if (locate_eod) {
2263 #if DEBUG
2264 printk(OSST_DEB_MSG "%s:D: Locating back to eod frame addr %d\n", name, STp->eod_frame_ppos);
2265 #endif
2266 osst_set_frame_position(STp, aSRpnt, STp->eod_frame_ppos, 0);
2267 }
2268 if (result)
2269 printk(KERN_ERR "%s:E: Write header failed\n", name);
2270 else {
2271 memcpy(STp->application_sig, "LIN4", 4);
2272 STp->linux_media = 1;
2273 STp->linux_media_version = 4;
2274 STp->header_ok = 1;
2275 }
2276 return result;
2277 }
2278
2279 static int osst_reset_header(struct osst_tape * STp, struct osst_request ** aSRpnt)
2280 {
2281 if (STp->header_cache != NULL)
2282 memset(STp->header_cache, 0, sizeof(os_header_t));
2283
2284 STp->logical_blk_num = STp->frame_seq_number = 0;
2285 STp->frame_in_buffer = 0;
2286 STp->eod_frame_ppos = STp->first_data_ppos = 0x0000000A;
2287 STp->filemark_cnt = 0;
2288 STp->first_mark_ppos = STp->last_mark_ppos = STp->last_mark_lbn = -1;
2289 return osst_write_header(STp, aSRpnt, 1);
2290 }
2291
2292 static int __osst_analyze_headers(struct osst_tape * STp, struct osst_request ** aSRpnt, int ppos)
2293 {
2294 char * name = tape_name(STp);
2295 os_header_t * header;
2296 os_aux_t * aux;
2297 char id_string[8];
2298 int linux_media_version,
2299 update_frame_cntr;
2300
2301 if (STp->raw)
2302 return 1;
2303
2304 if (ppos == 5 || ppos == 0xbae || STp->buffer->syscall_result) {
2305 if (osst_set_frame_position(STp, aSRpnt, ppos, 0))
2306 printk(KERN_WARNING "%s:W: Couldn't position tape\n", name);
2307 osst_wait_ready(STp, aSRpnt, 60 * 15, 0);
2308 if (osst_initiate_read (STp, aSRpnt)) {
2309 printk(KERN_WARNING "%s:W: Couldn't initiate read\n", name);
2310 return 0;
2311 }
2312 }
2313 if (osst_read_frame(STp, aSRpnt, 180)) {
2314 #if DEBUG
2315 printk(OSST_DEB_MSG "%s:D: Couldn't read header frame\n", name);
2316 #endif
2317 return 0;
2318 }
2319 header = (os_header_t *) STp->buffer->b_data; /* warning: only first segment addressable */
2320 aux = STp->buffer->aux;
2321 if (aux->frame_type != OS_FRAME_TYPE_HEADER) {
2322 #if DEBUG
2323 printk(OSST_DEB_MSG "%s:D: Skipping non-header frame (%d)\n", name, ppos);
2324 #endif
2325 return 0;
2326 }
2327 if (ntohl(aux->frame_seq_num) != 0 ||
2328 ntohl(aux->logical_blk_num) != 0 ||
2329 aux->partition.partition_num != OS_CONFIG_PARTITION ||
2330 ntohl(aux->partition.first_frame_ppos) != 0 ||
2331 ntohl(aux->partition.last_frame_ppos) != 0xbb7 ) {
2332 #if DEBUG
2333 printk(OSST_DEB_MSG "%s:D: Invalid header frame (%d,%d,%d,%d,%d)\n", name,
2334 ntohl(aux->frame_seq_num), ntohl(aux->logical_blk_num),
2335 aux->partition.partition_num, ntohl(aux->partition.first_frame_ppos),
2336 ntohl(aux->partition.last_frame_ppos));
2337 #endif
2338 return 0;
2339 }
2340 if (strncmp(header->ident_str, "ADR_SEQ", 7) != 0 &&
2341 strncmp(header->ident_str, "ADR-SEQ", 7) != 0) {
2342 strlcpy(id_string, header->ident_str, 8);
2343 #if DEBUG
2344 printk(OSST_DEB_MSG "%s:D: Invalid header identification string %s\n", name, id_string);
2345 #endif
2346 return 0;
2347 }
2348 update_frame_cntr = ntohl(aux->update_frame_cntr);
2349 if (update_frame_cntr < STp->update_frame_cntr) {
2350 #if DEBUG
2351 printk(OSST_DEB_MSG "%s:D: Skipping frame %d with update_frame_counter %d<%d\n",
2352 name, ppos, update_frame_cntr, STp->update_frame_cntr);
2353 #endif
2354 return 0;
2355 }
2356 if (header->major_rev != 1 || header->minor_rev != 4 ) {
2357 #if DEBUG
2358 printk(OSST_DEB_MSG "%s:D: %s revision %d.%d detected (1.4 supported)\n",
2359 name, (header->major_rev != 1 || header->minor_rev < 2 ||
2360 header->minor_rev > 4 )? "Invalid" : "Warning:",
2361 header->major_rev, header->minor_rev);
2362 #endif
2363 if (header->major_rev != 1 || header->minor_rev < 2 || header->minor_rev > 4)
2364 return 0;
2365 }
2366 #if DEBUG
2367 if (header->pt_par_num != 1)
2368 printk(KERN_INFO "%s:W: %d partitions defined, only one supported\n",
2369 name, header->pt_par_num);
2370 #endif
2371 memcpy(id_string, aux->application_sig, 4);
2372 id_string[4] = 0;
2373 if (memcmp(id_string, "LIN", 3) == 0) {
2374 STp->linux_media = 1;
2375 linux_media_version = id_string[3] - '0';
2376 if (linux_media_version != 4)
2377 printk(KERN_INFO "%s:I: Linux media version %d detected (current 4)\n",
2378 name, linux_media_version);
2379 } else {
2380 printk(KERN_WARNING "%s:W: Non Linux media detected (%s)\n", name, id_string);
2381 return 0;
2382 }
2383 if (linux_media_version < STp->linux_media_version) {
2384 #if DEBUG
2385 printk(OSST_DEB_MSG "%s:D: Skipping frame %d with linux_media_version %d\n",
2386 name, ppos, linux_media_version);
2387 #endif
2388 return 0;
2389 }
2390 if (linux_media_version > STp->linux_media_version) {
2391 #if DEBUG
2392 printk(OSST_DEB_MSG "%s:D: Frame %d sets linux_media_version to %d\n",
2393 name, ppos, linux_media_version);
2394 #endif
2395 memcpy(STp->application_sig, id_string, 5);
2396 STp->linux_media_version = linux_media_version;
2397 STp->update_frame_cntr = -1;
2398 }
2399 if (update_frame_cntr > STp->update_frame_cntr) {
2400 #if DEBUG
2401 printk(OSST_DEB_MSG "%s:D: Frame %d sets update_frame_counter to %d\n",
2402 name, ppos, update_frame_cntr);
2403 #endif
2404 if (STp->header_cache == NULL) {
2405 if ((STp->header_cache = (os_header_t *)vmalloc(sizeof(os_header_t))) == NULL) {
2406 printk(KERN_ERR "%s:E: Failed to allocate header cache\n", name);
2407 return 0;
2408 }
2409 #if DEBUG
2410 printk(OSST_DEB_MSG "%s:D: Allocated memory for header cache\n", name);
2411 #endif
2412 }
2413 osst_copy_from_buffer(STp->buffer, (unsigned char *)STp->header_cache);
2414 header = STp->header_cache; /* further accesses from cached (full) copy */
2415
2416 STp->wrt_pass_cntr = ntohs(header->partition[0].wrt_pass_cntr);
2417 STp->first_data_ppos = ntohl(header->partition[0].first_frame_ppos);
2418 STp->eod_frame_ppos = ntohl(header->partition[0].eod_frame_ppos);
2419 STp->eod_frame_lfa = ntohl(header->ext_track_tb.dat_ext_trk_ey.last_hlb);
2420 STp->filemark_cnt = ntohl(aux->filemark_cnt);
2421 STp->first_mark_ppos = ntohl(aux->next_mark_ppos);
2422 STp->last_mark_ppos = ntohl(aux->last_mark_ppos);
2423 STp->last_mark_lbn = ntohl(aux->last_mark_lbn);
2424 STp->update_frame_cntr = update_frame_cntr;
2425 #if DEBUG
2426 printk(OSST_DEB_MSG "%s:D: Detected write pass %d, update frame counter %d, filemark counter %d\n",
2427 name, STp->wrt_pass_cntr, STp->update_frame_cntr, STp->filemark_cnt);
2428 printk(OSST_DEB_MSG "%s:D: first data frame on tape = %d, last = %d, eod frame = %d\n", name,
2429 STp->first_data_ppos,
2430 ntohl(header->partition[0].last_frame_ppos),
2431 ntohl(header->partition[0].eod_frame_ppos));
2432 printk(OSST_DEB_MSG "%s:D: first mark on tape = %d, last = %d, eod frame = %d\n",
2433 name, STp->first_mark_ppos, STp->last_mark_ppos, STp->eod_frame_ppos);
2434 #endif
2435 if (header->minor_rev < 4 && STp->linux_media_version == 4) {
2436 #if DEBUG
2437 printk(OSST_DEB_MSG "%s:D: Moving filemark list to ADR 1.4 location\n", name);
2438 #endif
2439 memcpy((void *)header->dat_fm_tab.fm_tab_ent,
2440 (void *)header->old_filemark_list, sizeof(header->dat_fm_tab.fm_tab_ent));
2441 memset((void *)header->old_filemark_list, 0, sizeof(header->old_filemark_list));
2442 }
2443 if (header->minor_rev == 4 &&
2444 (header->ext_trk_tb_off != htons(17192) ||
2445 header->partition[0].partition_num != OS_DATA_PARTITION ||
2446 header->partition[0].par_desc_ver != OS_PARTITION_VERSION ||
2447 header->partition[0].last_frame_ppos != htonl(STp->capacity) ||
2448 header->cfg_col_width != htonl(20) ||
2449 header->dat_col_width != htonl(1500) ||
2450 header->qfa_col_width != htonl(0) ||
2451 header->ext_track_tb.nr_stream_part != 1 ||
2452 header->ext_track_tb.et_ent_sz != 32 ||
2453 header->ext_track_tb.dat_ext_trk_ey.et_part_num != OS_DATA_PARTITION ||
2454 header->ext_track_tb.dat_ext_trk_ey.fmt != 1 ||
2455 header->ext_track_tb.dat_ext_trk_ey.fm_tab_off != htons(17736) ||
2456 header->ext_track_tb.dat_ext_trk_ey.last_hlb_hi != 0 ||
2457 header->ext_track_tb.dat_ext_trk_ey.last_pp != htonl(STp->eod_frame_ppos) ||
2458 header->dat_fm_tab.fm_part_num != OS_DATA_PARTITION ||
2459 header->dat_fm_tab.fm_tab_ent_sz != 4 ||
2460 header->dat_fm_tab.fm_tab_ent_cnt !=
2461 htons(STp->filemark_cnt<OS_FM_TAB_MAX?STp->filemark_cnt:OS_FM_TAB_MAX)))
2462 printk(KERN_WARNING "%s:W: Failed consistency check ADR 1.4 format\n", name);
2463
2464 }
2465
2466 return 1;
2467 }
2468
2469 static int osst_analyze_headers(struct osst_tape * STp, struct osst_request ** aSRpnt)
2470 {
2471 int position, ppos;
2472 int first, last;
2473 int valid = 0;
2474 char * name = tape_name(STp);
2475
2476 position = osst_get_frame_position(STp, aSRpnt);
2477
2478 if (STp->raw) {
2479 STp->header_ok = STp->linux_media = 1;
2480 STp->linux_media_version = 0;
2481 return 1;
2482 }
2483 STp->header_ok = STp->linux_media = STp->linux_media_version = 0;
2484 STp->wrt_pass_cntr = STp->update_frame_cntr = -1;
2485 STp->eod_frame_ppos = STp->first_data_ppos = -1;
2486 STp->first_mark_ppos = STp->last_mark_ppos = STp->last_mark_lbn = -1;
2487 #if DEBUG
2488 printk(OSST_DEB_MSG "%s:D: Reading header\n", name);
2489 #endif
2490
2491 /* optimization for speed - if we are positioned at ppos 10, read second group first */
2492 /* TODO try the ADR 1.1 locations for the second group if we have no valid one yet... */
2493
2494 first = position==10?0xbae: 5;
2495 last = position==10?0xbb3:10;
2496
2497 for (ppos = first; ppos < last; ppos++)
2498 if (__osst_analyze_headers(STp, aSRpnt, ppos))
2499 valid = 1;
2500
2501 first = position==10? 5:0xbae;
2502 last = position==10?10:0xbb3;
2503
2504 for (ppos = first; ppos < last; ppos++)
2505 if (__osst_analyze_headers(STp, aSRpnt, ppos))
2506 valid = 1;
2507
2508 if (!valid) {
2509 printk(KERN_ERR "%s:E: Failed to find valid ADRL header, new media?\n", name);
2510 STp->eod_frame_ppos = STp->first_data_ppos = 0;
2511 osst_set_frame_position(STp, aSRpnt, 10, 0);
2512 return 0;
2513 }
2514 if (position <= STp->first_data_ppos) {
2515 position = STp->first_data_ppos;
2516 STp->ps[0].drv_file = STp->ps[0].drv_block = STp->frame_seq_number = STp->logical_blk_num = 0;
2517 }
2518 osst_set_frame_position(STp, aSRpnt, position, 0);
2519 STp->header_ok = 1;
2520
2521 return 1;
2522 }
2523
2524 static int osst_verify_position(struct osst_tape * STp, struct osst_request ** aSRpnt)
2525 {
2526 int frame_position = STp->first_frame_position;
2527 int frame_seq_numbr = STp->frame_seq_number;
2528 int logical_blk_num = STp->logical_blk_num;
2529 int halfway_frame = STp->frame_in_buffer;
2530 int read_pointer = STp->buffer->read_pointer;
2531 int prev_mark_ppos = -1;
2532 int actual_mark_ppos, i, n;
2533 #if DEBUG
2534 char * name = tape_name(STp);
2535
2536 printk(OSST_DEB_MSG "%s:D: Verify that the tape is really the one we think before writing\n", name);
2537 #endif
2538 osst_set_frame_position(STp, aSRpnt, frame_position - 1, 0);
2539 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
2540 #if DEBUG
2541 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in verify_position\n", name);
2542 #endif
2543 return (-EIO);
2544 }
2545 if (STp->linux_media_version >= 4) {
2546 for (i=0; i<STp->filemark_cnt; i++)
2547 if ((n=ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[i])) < frame_position)
2548 prev_mark_ppos = n;
2549 } else
2550 prev_mark_ppos = frame_position - 1; /* usually - we don't really know */
2551 actual_mark_ppos = STp->buffer->aux->frame_type == OS_FRAME_TYPE_MARKER ?
2552 frame_position - 1 : ntohl(STp->buffer->aux->last_mark_ppos);
2553 if (frame_position != STp->first_frame_position ||
2554 frame_seq_numbr != STp->frame_seq_number + (halfway_frame?0:1) ||
2555 prev_mark_ppos != actual_mark_ppos ) {
2556 #if DEBUG
2557 printk(OSST_DEB_MSG "%s:D: Block mismatch: fppos %d-%d, fseq %d-%d, mark %d-%d\n", name,
2558 STp->first_frame_position, frame_position,
2559 STp->frame_seq_number + (halfway_frame?0:1),
2560 frame_seq_numbr, actual_mark_ppos, prev_mark_ppos);
2561 #endif
2562 return (-EIO);
2563 }
2564 if (halfway_frame) {
2565 /* prepare buffer for append and rewrite on top of original */
2566 osst_set_frame_position(STp, aSRpnt, frame_position - 1, 0);
2567 STp->buffer->buffer_bytes = read_pointer;
2568 STp->ps[STp->partition].rw = ST_WRITING;
2569 STp->dirty = 1;
2570 }
2571 STp->frame_in_buffer = halfway_frame;
2572 STp->frame_seq_number = frame_seq_numbr;
2573 STp->logical_blk_num = logical_blk_num;
2574 return 0;
2575 }
2576
2577 /* Acc. to OnStream, the vers. numbering is the following:
2578 * X.XX for released versions (X=digit),
2579 * XXXY for unreleased versions (Y=letter)
2580 * Ordering 1.05 < 106A < 106B < ... < 106a < ... < 1.06
2581 * This fn makes monoton numbers out of this scheme ...
2582 */
2583 static unsigned int osst_parse_firmware_rev (const char * str)
2584 {
2585 if (str[1] == '.') {
2586 return (str[0]-'0')*10000
2587 +(str[2]-'0')*1000
2588 +(str[3]-'0')*100;
2589 } else {
2590 return (str[0]-'0')*10000
2591 +(str[1]-'0')*1000
2592 +(str[2]-'0')*100 - 100
2593 +(str[3]-'@');
2594 }
2595 }
2596
2597 /*
2598 * Configure the OnStream SCII tape drive for default operation
2599 */
2600 static int osst_configure_onstream(struct osst_tape *STp, struct osst_request ** aSRpnt)
2601 {
2602 unsigned char cmd[MAX_COMMAND_SIZE];
2603 char * name = tape_name(STp);
2604 struct osst_request * SRpnt = * aSRpnt;
2605 osst_mode_parameter_header_t * header;
2606 osst_block_size_page_t * bs;
2607 osst_capabilities_page_t * cp;
2608 osst_tape_paramtr_page_t * prm;
2609 int drive_buffer_size;
2610
2611 if (STp->ready != ST_READY) {
2612 #if DEBUG
2613 printk(OSST_DEB_MSG "%s:D: Not Ready\n", name);
2614 #endif
2615 return (-EIO);
2616 }
2617
2618 if (STp->os_fw_rev < 10600) {
2619 printk(KERN_INFO "%s:I: Old OnStream firmware revision detected (%s),\n", name, STp->device->rev);
2620 printk(KERN_INFO "%s:I: an upgrade to version 1.06 or above is recommended\n", name);
2621 }
2622
2623 /*
2624 * Configure 32.5KB (data+aux) frame size.
2625 * Get the current frame size from the block size mode page
2626 */
2627 memset(cmd, 0, MAX_COMMAND_SIZE);
2628 cmd[0] = MODE_SENSE;
2629 cmd[1] = 8;
2630 cmd[2] = BLOCK_SIZE_PAGE;
2631 cmd[4] = BLOCK_SIZE_PAGE_LENGTH + MODE_HEADER_LENGTH;
2632
2633 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1);
2634 if (SRpnt == NULL) {
2635 #if DEBUG
2636 printk(OSST_DEB_MSG "osst :D: Busy\n");
2637 #endif
2638 return (-EBUSY);
2639 }
2640 *aSRpnt = SRpnt;
2641 if ((STp->buffer)->syscall_result != 0) {
2642 printk (KERN_ERR "%s:E: Can't get tape block size mode page\n", name);
2643 return (-EIO);
2644 }
2645
2646 header = (osst_mode_parameter_header_t *) (STp->buffer)->b_data;
2647 bs = (osst_block_size_page_t *) ((STp->buffer)->b_data + sizeof(osst_mode_parameter_header_t) + header->bdl);
2648
2649 #if DEBUG
2650 printk(OSST_DEB_MSG "%s:D: 32KB play back: %s\n", name, bs->play32 ? "Yes" : "No");
2651 printk(OSST_DEB_MSG "%s:D: 32.5KB play back: %s\n", name, bs->play32_5 ? "Yes" : "No");
2652 printk(OSST_DEB_MSG "%s:D: 32KB record: %s\n", name, bs->record32 ? "Yes" : "No");
2653 printk(OSST_DEB_MSG "%s:D: 32.5KB record: %s\n", name, bs->record32_5 ? "Yes" : "No");
2654 #endif
2655
2656 /*
2657 * Configure default auto columns mode, 32.5KB transfer mode
2658 */
2659 bs->one = 1;
2660 bs->play32 = 0;
2661 bs->play32_5 = 1;
2662 bs->record32 = 0;
2663 bs->record32_5 = 1;
2664
2665 memset(cmd, 0, MAX_COMMAND_SIZE);
2666 cmd[0] = MODE_SELECT;
2667 cmd[1] = 0x10;
2668 cmd[4] = BLOCK_SIZE_PAGE_LENGTH + MODE_HEADER_LENGTH;
2669
2670 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1);
2671 *aSRpnt = SRpnt;
2672 if ((STp->buffer)->syscall_result != 0) {
2673 printk (KERN_ERR "%s:E: Couldn't set tape block size mode page\n", name);
2674 return (-EIO);
2675 }
2676
2677 #if DEBUG
2678 printk(KERN_INFO "%s:D: Drive Block Size changed to 32.5K\n", name);
2679 /*
2680 * In debug mode, we want to see as many errors as possible
2681 * to test the error recovery mechanism.
2682 */
2683 osst_set_retries(STp, aSRpnt, 0);
2684 SRpnt = * aSRpnt;
2685 #endif
2686
2687 /*
2688 * Set vendor name to 'LIN4' for "Linux support version 4".
2689 */
2690
2691 memset(cmd, 0, MAX_COMMAND_SIZE);
2692 cmd[0] = MODE_SELECT;
2693 cmd[1] = 0x10;
2694 cmd[4] = VENDOR_IDENT_PAGE_LENGTH + MODE_HEADER_LENGTH;
2695
2696 header->mode_data_length = VENDOR_IDENT_PAGE_LENGTH + MODE_HEADER_LENGTH - 1;
2697 header->medium_type = 0; /* Medium Type - ignoring */
2698 header->dsp = 0; /* Reserved */
2699 header->bdl = 0; /* Block Descriptor Length */
2700
2701 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 0] = VENDOR_IDENT_PAGE | (1 << 7);
2702 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 1] = 6;
2703 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] = 'L';
2704 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 3] = 'I';
2705 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 4] = 'N';
2706 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 5] = '4';
2707 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 6] = 0;
2708 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 7] = 0;
2709
2710 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1);
2711 *aSRpnt = SRpnt;
2712
2713 if ((STp->buffer)->syscall_result != 0) {
2714 printk (KERN_ERR "%s:E: Couldn't set vendor name to %s\n", name,
2715 (char *) ((STp->buffer)->b_data + MODE_HEADER_LENGTH + 2));
2716 return (-EIO);
2717 }
2718
2719 memset(cmd, 0, MAX_COMMAND_SIZE);
2720 cmd[0] = MODE_SENSE;
2721 cmd[1] = 8;
2722 cmd[2] = CAPABILITIES_PAGE;
2723 cmd[4] = CAPABILITIES_PAGE_LENGTH + MODE_HEADER_LENGTH;
2724
2725 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1);
2726 *aSRpnt = SRpnt;
2727
2728 if ((STp->buffer)->syscall_result != 0) {
2729 printk (KERN_ERR "%s:E: Can't get capabilities page\n", name);
2730 return (-EIO);
2731 }
2732
2733 header = (osst_mode_parameter_header_t *) (STp->buffer)->b_data;
2734 cp = (osst_capabilities_page_t *) ((STp->buffer)->b_data +
2735 sizeof(osst_mode_parameter_header_t) + header->bdl);
2736
2737 drive_buffer_size = ntohs(cp->buffer_size) / 2;
2738
2739 memset(cmd, 0, MAX_COMMAND_SIZE);
2740 cmd[0] = MODE_SENSE;
2741 cmd[1] = 8;
2742 cmd[2] = TAPE_PARAMTR_PAGE;
2743 cmd[4] = TAPE_PARAMTR_PAGE_LENGTH + MODE_HEADER_LENGTH;
2744
2745 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1);
2746 *aSRpnt = SRpnt;
2747
2748 if ((STp->buffer)->syscall_result != 0) {
2749 printk (KERN_ERR "%s:E: Can't get tape parameter page\n", name);
2750 return (-EIO);
2751 }
2752
2753 header = (osst_mode_parameter_header_t *) (STp->buffer)->b_data;
2754 prm = (osst_tape_paramtr_page_t *) ((STp->buffer)->b_data +
2755 sizeof(osst_mode_parameter_header_t) + header->bdl);
2756
2757 STp->density = prm->density;
2758 STp->capacity = ntohs(prm->segtrk) * ntohs(prm->trks);
2759 #if DEBUG
2760 printk(OSST_DEB_MSG "%s:D: Density %d, tape length: %dMB, drive buffer size: %dKB\n",
2761 name, STp->density, STp->capacity / 32, drive_buffer_size);
2762 #endif
2763
2764 return 0;
2765
2766 }
2767
2768
2769 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
2770 it messes up the block number). */
2771 static int cross_eof(struct osst_tape *STp, struct osst_request ** aSRpnt, int forward)
2772 {
2773 int result;
2774 char * name = tape_name(STp);
2775
2776 #if DEBUG
2777 if (debugging)
2778 printk(OSST_DEB_MSG "%s:D: Stepping over filemark %s.\n",
2779 name, forward ? "forward" : "backward");
2780 #endif
2781
2782 if (forward) {
2783 /* assumes that the filemark is already read by the drive, so this is low cost */
2784 result = osst_space_over_filemarks_forward_slow(STp, aSRpnt, MTFSF, 1);
2785 }
2786 else
2787 /* assumes this is only called if we just read the filemark! */
2788 result = osst_seek_logical_blk(STp, aSRpnt, STp->logical_blk_num - 1);
2789
2790 if (result < 0)
2791 printk(KERN_WARNING "%s:W: Stepping over filemark %s failed.\n",
2792 name, forward ? "forward" : "backward");
2793
2794 return result;
2795 }
2796
2797
2798 /* Get the tape position. */
2799
2800 static int osst_get_frame_position(struct osst_tape *STp, struct osst_request ** aSRpnt)
2801 {
2802 unsigned char scmd[MAX_COMMAND_SIZE];
2803 struct osst_request * SRpnt;
2804 int result = 0;
2805 char * name = tape_name(STp);
2806
2807 /* KG: We want to be able to use it for checking Write Buffer availability
2808 * and thus don't want to risk to overwrite anything. Exchange buffers ... */
2809 char mybuf[24];
2810 char * olddata = STp->buffer->b_data;
2811 int oldsize = STp->buffer->buffer_size;
2812
2813 if (STp->ready != ST_READY) return (-EIO);
2814
2815 memset (scmd, 0, MAX_COMMAND_SIZE);
2816 scmd[0] = READ_POSITION;
2817
2818 STp->buffer->b_data = mybuf; STp->buffer->buffer_size = 24;
2819 SRpnt = osst_do_scsi(*aSRpnt, STp, scmd, 20, DMA_FROM_DEVICE,
2820 STp->timeout, MAX_RETRIES, 1);
2821 if (!SRpnt) {
2822 STp->buffer->b_data = olddata; STp->buffer->buffer_size = oldsize;
2823 return (-EBUSY);
2824 }
2825 *aSRpnt = SRpnt;
2826
2827 if (STp->buffer->syscall_result)
2828 result = ((SRpnt->sense[2] & 0x0f) == 3) ? -EIO : -EINVAL; /* 3: Write Error */
2829
2830 if (result == -EINVAL)
2831 printk(KERN_ERR "%s:E: Can't read tape position.\n", name);
2832 else {
2833 if (result == -EIO) { /* re-read position - this needs to preserve media errors */
2834 unsigned char mysense[16];
2835 memcpy (mysense, SRpnt->sense, 16);
2836 memset (scmd, 0, MAX_COMMAND_SIZE);
2837 scmd[0] = READ_POSITION;
2838 STp->buffer->b_data = mybuf; STp->buffer->buffer_size = 24;
2839 SRpnt = osst_do_scsi(SRpnt, STp, scmd, 20, DMA_FROM_DEVICE,
2840 STp->timeout, MAX_RETRIES, 1);
2841 #if DEBUG
2842 printk(OSST_DEB_MSG "%s:D: Reread position, reason=[%02x:%02x:%02x], result=[%s%02x:%02x:%02x]\n",
2843 name, mysense[2], mysense[12], mysense[13], STp->buffer->syscall_result?"":"ok:",
2844 SRpnt->sense[2],SRpnt->sense[12],SRpnt->sense[13]);
2845 #endif
2846 if (!STp->buffer->syscall_result)
2847 memcpy (SRpnt->sense, mysense, 16);
2848 else
2849 printk(KERN_WARNING "%s:W: Double error in get position\n", name);
2850 }
2851 STp->first_frame_position = ((STp->buffer)->b_data[4] << 24)
2852 + ((STp->buffer)->b_data[5] << 16)
2853 + ((STp->buffer)->b_data[6] << 8)
2854 + (STp->buffer)->b_data[7];
2855 STp->last_frame_position = ((STp->buffer)->b_data[ 8] << 24)
2856 + ((STp->buffer)->b_data[ 9] << 16)
2857 + ((STp->buffer)->b_data[10] << 8)
2858 + (STp->buffer)->b_data[11];
2859 STp->cur_frames = (STp->buffer)->b_data[15];
2860 #if DEBUG
2861 if (debugging) {
2862 printk(OSST_DEB_MSG "%s:D: Drive Positions: host %d, tape %d%s, buffer %d\n", name,
2863 STp->first_frame_position, STp->last_frame_position,
2864 ((STp->buffer)->b_data[0]&0x80)?" (BOP)":
2865 ((STp->buffer)->b_data[0]&0x40)?" (EOP)":"",
2866 STp->cur_frames);
2867 }
2868 #endif
2869 if (STp->cur_frames == 0 && STp->first_frame_position != STp->last_frame_position) {
2870 #if DEBUG
2871 printk(OSST_DEB_MSG "%s:D: Correcting read position %d, %d, %d\n", name,
2872 STp->first_frame_position, STp->last_frame_position, STp->cur_frames);
2873 #endif
2874 STp->first_frame_position = STp->last_frame_position;
2875 }
2876 }
2877 STp->buffer->b_data = olddata; STp->buffer->buffer_size = oldsize;
2878
2879 return (result == 0 ? STp->first_frame_position : result);
2880 }
2881
2882
2883 /* Set the tape block */
2884 static int osst_set_frame_position(struct osst_tape *STp, struct osst_request ** aSRpnt, int ppos, int skip)
2885 {
2886 unsigned char scmd[MAX_COMMAND_SIZE];
2887 struct osst_request * SRpnt;
2888 struct st_partstat * STps;
2889 int result = 0;
2890 int pp = (ppos == 3000 && !skip)? 0 : ppos;
2891 char * name = tape_name(STp);
2892
2893 if (STp->ready != ST_READY) return (-EIO);
2894
2895 STps = &(STp->ps[STp->partition]);
2896
2897 if (ppos < 0 || ppos > STp->capacity) {
2898 printk(KERN_WARNING "%s:W: Reposition request %d out of range\n", name, ppos);
2899 pp = ppos = ppos < 0 ? 0 : (STp->capacity - 1);
2900 result = (-EINVAL);
2901 }
2902
2903 do {
2904 #if DEBUG
2905 if (debugging)
2906 printk(OSST_DEB_MSG "%s:D: Setting ppos to %d.\n", name, pp);
2907 #endif
2908 memset (scmd, 0, MAX_COMMAND_SIZE);
2909 scmd[0] = SEEK_10;
2910 scmd[1] = 1;
2911 scmd[3] = (pp >> 24);
2912 scmd[4] = (pp >> 16);
2913 scmd[5] = (pp >> 8);
2914 scmd[6] = pp;
2915 if (skip)
2916 scmd[9] = 0x80;
2917
2918 SRpnt = osst_do_scsi(*aSRpnt, STp, scmd, 0, DMA_NONE, STp->long_timeout,
2919 MAX_RETRIES, 1);
2920 if (!SRpnt)
2921 return (-EBUSY);
2922 *aSRpnt = SRpnt;
2923
2924 if ((STp->buffer)->syscall_result != 0) {
2925 #if DEBUG
2926 printk(OSST_DEB_MSG "%s:D: SEEK command from %d to %d failed.\n",
2927 name, STp->first_frame_position, pp);
2928 #endif
2929 result = (-EIO);
2930 }
2931 if (pp != ppos)
2932 osst_wait_ready(STp, aSRpnt, 5 * 60, OSST_WAIT_POSITION_COMPLETE);
2933 } while ((pp != ppos) && (pp = ppos));
2934 STp->first_frame_position = STp->last_frame_position = ppos;
2935 STps->eof = ST_NOEOF;
2936 STps->at_sm = 0;
2937 STps->rw = ST_IDLE;
2938 STp->frame_in_buffer = 0;
2939 return result;
2940 }
2941
2942 static int osst_write_trailer(struct osst_tape *STp, struct osst_request ** aSRpnt, int leave_at_EOT)
2943 {
2944 struct st_partstat * STps = &(STp->ps[STp->partition]);
2945 int result = 0;
2946
2947 if (STp->write_type != OS_WRITE_NEW_MARK) {
2948 /* true unless the user wrote the filemark for us */
2949 result = osst_flush_drive_buffer(STp, aSRpnt);
2950 if (result < 0) goto out;
2951 result = osst_write_filemark(STp, aSRpnt);
2952 if (result < 0) goto out;
2953
2954 if (STps->drv_file >= 0)
2955 STps->drv_file++ ;
2956 STps->drv_block = 0;
2957 }
2958 result = osst_write_eod(STp, aSRpnt);
2959 osst_write_header(STp, aSRpnt, leave_at_EOT);
2960
2961 STps->eof = ST_FM;
2962 out:
2963 return result;
2964 }
2965 \f
2966 /* osst versions of st functions - augmented and stripped to suit OnStream only */
2967
2968 /* Flush the write buffer (never need to write if variable blocksize). */
2969 static int osst_flush_write_buffer(struct osst_tape *STp, struct osst_request ** aSRpnt)
2970 {
2971 int offset, transfer, blks = 0;
2972 int result = 0;
2973 unsigned char cmd[MAX_COMMAND_SIZE];
2974 struct osst_request * SRpnt = *aSRpnt;
2975 struct st_partstat * STps;
2976 char * name = tape_name(STp);
2977
2978 if ((STp->buffer)->writing) {
2979 if (SRpnt == (STp->buffer)->last_SRpnt)
2980 #if DEBUG
2981 { printk(OSST_DEB_MSG
2982 "%s:D: aSRpnt points to osst_request that write_behind_check will release -- cleared\n", name);
2983 #endif
2984 *aSRpnt = SRpnt = NULL;
2985 #if DEBUG
2986 } else if (SRpnt)
2987 printk(OSST_DEB_MSG
2988 "%s:D: aSRpnt does not point to osst_request that write_behind_check will release -- strange\n", name);
2989 #endif
2990 osst_write_behind_check(STp);
2991 if ((STp->buffer)->syscall_result) {
2992 #if DEBUG
2993 if (debugging)
2994 printk(OSST_DEB_MSG "%s:D: Async write error (flush) %x.\n",
2995 name, (STp->buffer)->midlevel_result);
2996 #endif
2997 if ((STp->buffer)->midlevel_result == INT_MAX)
2998 return (-ENOSPC);
2999 return (-EIO);
3000 }
3001 }
3002
3003 result = 0;
3004 if (STp->dirty == 1) {
3005
3006 STp->write_count++;
3007 STps = &(STp->ps[STp->partition]);
3008 STps->rw = ST_WRITING;
3009 offset = STp->buffer->buffer_bytes;
3010 blks = (offset + STp->block_size - 1) / STp->block_size;
3011 transfer = OS_FRAME_SIZE;
3012
3013 if (offset < OS_DATA_SIZE)
3014 osst_zero_buffer_tail(STp->buffer);
3015
3016 if (STp->poll)
3017 if (osst_wait_frame (STp, aSRpnt, STp->first_frame_position, -50, 120))
3018 result = osst_recover_wait_frame(STp, aSRpnt, 1);
3019
3020 memset(cmd, 0, MAX_COMMAND_SIZE);
3021 cmd[0] = WRITE_6;
3022 cmd[1] = 1;
3023 cmd[4] = 1;
3024
3025 switch (STp->write_type) {
3026 case OS_WRITE_DATA:
3027 #if DEBUG
3028 if (debugging)
3029 printk(OSST_DEB_MSG "%s:D: Writing %d blocks to frame %d, lblks %d-%d\n",
3030 name, blks, STp->frame_seq_number,
3031 STp->logical_blk_num - blks, STp->logical_blk_num - 1);
3032 #endif
3033 osst_init_aux(STp, OS_FRAME_TYPE_DATA, STp->frame_seq_number++,
3034 STp->logical_blk_num - blks, STp->block_size, blks);
3035 break;
3036 case OS_WRITE_EOD:
3037 osst_init_aux(STp, OS_FRAME_TYPE_EOD, STp->frame_seq_number++,
3038 STp->logical_blk_num, 0, 0);
3039 break;
3040 case OS_WRITE_NEW_MARK:
3041 osst_init_aux(STp, OS_FRAME_TYPE_MARKER, STp->frame_seq_number++,
3042 STp->logical_blk_num++, 0, blks=1);
3043 break;
3044 case OS_WRITE_HEADER:
3045 osst_init_aux(STp, OS_FRAME_TYPE_HEADER, 0, 0, 0, blks=0);
3046 break;
3047 default: /* probably FILLER */
3048 osst_init_aux(STp, OS_FRAME_TYPE_FILL, 0, 0, 0, 0);
3049 }
3050 #if DEBUG
3051 if (debugging)
3052 printk(OSST_DEB_MSG "%s:D: Flushing %d bytes, Transfering %d bytes in %d lblocks.\n",
3053 name, offset, transfer, blks);
3054 #endif
3055
3056 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
3057 STp->timeout, MAX_RETRIES, 1);
3058 *aSRpnt = SRpnt;
3059 if (!SRpnt)
3060 return (-EBUSY);
3061
3062 if ((STp->buffer)->syscall_result != 0) {
3063 #if DEBUG
3064 printk(OSST_DEB_MSG
3065 "%s:D: write sense [0]=0x%02x [2]=%02x [12]=%02x [13]=%02x\n",
3066 name, SRpnt->sense[0], SRpnt->sense[2],
3067 SRpnt->sense[12], SRpnt->sense[13]);
3068 #endif
3069 if ((SRpnt->sense[0] & 0x70) == 0x70 &&
3070 (SRpnt->sense[2] & 0x40) && /* FIXME - SC-30 drive doesn't assert EOM bit */
3071 (SRpnt->sense[2] & 0x0f) == NO_SENSE) {
3072 STp->dirty = 0;
3073 (STp->buffer)->buffer_bytes = 0;
3074 result = (-ENOSPC);
3075 }
3076 else {
3077 if (osst_write_error_recovery(STp, aSRpnt, 1)) {
3078 printk(KERN_ERR "%s:E: Error on flush write.\n", name);
3079 result = (-EIO);
3080 }
3081 }
3082 STps->drv_block = (-1); /* FIXME - even if write recovery succeeds? */
3083 }
3084 else {
3085 STp->first_frame_position++;
3086 STp->dirty = 0;
3087 (STp->buffer)->buffer_bytes = 0;
3088 }
3089 }
3090 #if DEBUG
3091 printk(OSST_DEB_MSG "%s:D: Exit flush write buffer with code %d\n", name, result);
3092 #endif
3093 return result;
3094 }
3095
3096
3097 /* Flush the tape buffer. The tape will be positioned correctly unless
3098 seek_next is true. */
3099 static int osst_flush_buffer(struct osst_tape * STp, struct osst_request ** aSRpnt, int seek_next)
3100 {
3101 struct st_partstat * STps;
3102 int backspace = 0, result = 0;
3103 #if DEBUG
3104 char * name = tape_name(STp);
3105 #endif
3106
3107 /*
3108 * If there was a bus reset, block further access
3109 * to this device.
3110 */
3111 if( STp->pos_unknown)
3112 return (-EIO);
3113
3114 if (STp->ready != ST_READY)
3115 return 0;
3116
3117 STps = &(STp->ps[STp->partition]);
3118 if (STps->rw == ST_WRITING || STp->dirty) { /* Writing */
3119 STp->write_type = OS_WRITE_DATA;
3120 return osst_flush_write_buffer(STp, aSRpnt);
3121 }
3122 if (STp->block_size == 0)
3123 return 0;
3124
3125 #if DEBUG
3126 printk(OSST_DEB_MSG "%s:D: Reached flush (read) buffer\n", name);
3127 #endif
3128
3129 if (!STp->can_bsr) {
3130 backspace = ((STp->buffer)->buffer_bytes + (STp->buffer)->read_pointer) / STp->block_size -
3131 ((STp->buffer)->read_pointer + STp->block_size - 1 ) / STp->block_size ;
3132 (STp->buffer)->buffer_bytes = 0;
3133 (STp->buffer)->read_pointer = 0;
3134 STp->frame_in_buffer = 0; /* FIXME is this relevant w. OSST? */
3135 }
3136
3137 if (!seek_next) {
3138 if (STps->eof == ST_FM_HIT) {
3139 result = cross_eof(STp, aSRpnt, 0); /* Back over the EOF hit */
3140 if (!result)
3141 STps->eof = ST_NOEOF;
3142 else {
3143 if (STps->drv_file >= 0)
3144 STps->drv_file++;
3145 STps->drv_block = 0;
3146 }
3147 }
3148 if (!result && backspace > 0) /* TODO -- design and run a test case for this */
3149 result = osst_seek_logical_blk(STp, aSRpnt, STp->logical_blk_num - backspace);
3150 }
3151 else if (STps->eof == ST_FM_HIT) {
3152 if (STps->drv_file >= 0)
3153 STps->drv_file++;
3154 STps->drv_block = 0;
3155 STps->eof = ST_NOEOF;
3156 }
3157
3158 return result;
3159 }
3160
3161 static int osst_write_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, int synchronous)
3162 {
3163 unsigned char cmd[MAX_COMMAND_SIZE];
3164 struct osst_request * SRpnt;
3165 int blks;
3166 #if DEBUG
3167 char * name = tape_name(STp);
3168 #endif
3169
3170 if ((!STp-> raw) && (STp->first_frame_position == 0xbae)) { /* _must_ preserve buffer! */
3171 #if DEBUG
3172 printk(OSST_DEB_MSG "%s:D: Reaching config partition.\n", name);
3173 #endif
3174 if (osst_flush_drive_buffer(STp, aSRpnt) < 0) {
3175 return (-EIO);
3176 }
3177 /* error recovery may have bumped us past the header partition */
3178 if (osst_get_frame_position(STp, aSRpnt) < 0xbb8) {
3179 #if DEBUG
3180 printk(OSST_DEB_MSG "%s:D: Skipping over config partition.\n", name);
3181 #endif
3182 osst_position_tape_and_confirm(STp, aSRpnt, 0xbb8);
3183 }
3184 }
3185
3186 if (STp->poll)
3187 if (osst_wait_frame (STp, aSRpnt, STp->first_frame_position, -48, 120))
3188 if (osst_recover_wait_frame(STp, aSRpnt, 1))
3189 return (-EIO);
3190
3191 // osst_build_stats(STp, &SRpnt);
3192
3193 STp->ps[STp->partition].rw = ST_WRITING;
3194 STp->write_type = OS_WRITE_DATA;
3195
3196 memset(cmd, 0, MAX_COMMAND_SIZE);
3197 cmd[0] = WRITE_6;
3198 cmd[1] = 1;
3199 cmd[4] = 1; /* one frame at a time... */
3200 blks = STp->buffer->buffer_bytes / STp->block_size;
3201 #if DEBUG
3202 if (debugging)
3203 printk(OSST_DEB_MSG "%s:D: Writing %d blocks to frame %d, lblks %d-%d\n", name, blks,
3204 STp->frame_seq_number, STp->logical_blk_num - blks, STp->logical_blk_num - 1);
3205 #endif
3206 osst_init_aux(STp, OS_FRAME_TYPE_DATA, STp->frame_seq_number++,
3207 STp->logical_blk_num - blks, STp->block_size, blks);
3208
3209 #if DEBUG
3210 if (!synchronous)
3211 STp->write_pending = 1;
3212 #endif
3213 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, OS_FRAME_SIZE, DMA_TO_DEVICE, STp->timeout,
3214 MAX_RETRIES, synchronous);
3215 if (!SRpnt)
3216 return (-EBUSY);
3217 *aSRpnt = SRpnt;
3218
3219 if (synchronous) {
3220 if (STp->buffer->syscall_result != 0) {
3221 #if DEBUG
3222 if (debugging)
3223 printk(OSST_DEB_MSG "%s:D: Error on write:\n", name);
3224 #endif
3225 if ((SRpnt->sense[0] & 0x70) == 0x70 &&
3226 (SRpnt->sense[2] & 0x40)) {
3227 if ((SRpnt->sense[2] & 0x0f) == VOLUME_OVERFLOW)
3228 return (-ENOSPC);
3229 }
3230 else {
3231 if (osst_write_error_recovery(STp, aSRpnt, 1))
3232 return (-EIO);
3233 }
3234 }
3235 else
3236 STp->first_frame_position++;
3237 }
3238
3239 STp->write_count++;
3240
3241 return 0;
3242 }
3243
3244 /* Lock or unlock the drive door. Don't use when struct osst_request allocated. */
3245 static int do_door_lock(struct osst_tape * STp, int do_lock)
3246 {
3247 int retval, cmd;
3248
3249 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
3250 #if DEBUG
3251 printk(OSST_DEB_MSG "%s:D: %socking drive door.\n", tape_name(STp), do_lock ? "L" : "Unl");
3252 #endif
3253 retval = scsi_ioctl(STp->device, cmd, NULL);
3254 if (!retval) {
3255 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
3256 }
3257 else {
3258 STp->door_locked = ST_LOCK_FAILS;
3259 }
3260 return retval;
3261 }
3262
3263 /* Set the internal state after reset */
3264 static void reset_state(struct osst_tape *STp)
3265 {
3266 int i;
3267 struct st_partstat *STps;
3268
3269 STp->pos_unknown = 0;
3270 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3271 STps = &(STp->ps[i]);
3272 STps->rw = ST_IDLE;
3273 STps->eof = ST_NOEOF;
3274 STps->at_sm = 0;
3275 STps->last_block_valid = 0;
3276 STps->drv_block = -1;
3277 STps->drv_file = -1;
3278 }
3279 }
3280
3281 \f
3282 /* Entry points to osst */
3283
3284 /* Write command */
3285 static ssize_t osst_write(struct file * filp, const char __user * buf, size_t count, loff_t *ppos)
3286 {
3287 ssize_t total, retval = 0;
3288 ssize_t i, do_count, blks, transfer;
3289 int write_threshold;
3290 int doing_write = 0;
3291 const char __user * b_point;
3292 struct osst_request * SRpnt = NULL;
3293 struct st_modedef * STm;
3294 struct st_partstat * STps;
3295 struct osst_tape * STp = filp->private_data;
3296 char * name = tape_name(STp);
3297
3298
3299 if (down_interruptible(&STp->lock))
3300 return (-ERESTARTSYS);
3301
3302 /*
3303 * If we are in the middle of error recovery, don't let anyone
3304 * else try and use this device. Also, if error recovery fails, it
3305 * may try and take the device offline, in which case all further
3306 * access to the device is prohibited.
3307 */
3308 if( !scsi_block_when_processing_errors(STp->device) ) {
3309 retval = (-ENXIO);
3310 goto out;
3311 }
3312
3313 if (STp->ready != ST_READY) {
3314 if (STp->ready == ST_NO_TAPE)
3315 retval = (-ENOMEDIUM);
3316 else
3317 retval = (-EIO);
3318 goto out;
3319 }
3320 STm = &(STp->modes[STp->current_mode]);
3321 if (!STm->defined) {
3322 retval = (-ENXIO);
3323 goto out;
3324 }
3325 if (count == 0)
3326 goto out;
3327
3328 /*
3329 * If there was a bus reset, block further access
3330 * to this device.
3331 */
3332 if (STp->pos_unknown) {
3333 retval = (-EIO);
3334 goto out;
3335 }
3336
3337 #if DEBUG
3338 if (!STp->in_use) {
3339 printk(OSST_DEB_MSG "%s:D: Incorrect device.\n", name);
3340 retval = (-EIO);
3341 goto out;
3342 }
3343 #endif
3344
3345 if (STp->write_prot) {
3346 retval = (-EACCES);
3347 goto out;
3348 }
3349
3350 /* Write must be integral number of blocks */
3351 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
3352 printk(KERN_ERR "%s:E: Write (%Zd bytes) not multiple of tape block size (%d%c).\n",
3353 name, count, STp->block_size<1024?
3354 STp->block_size:STp->block_size/1024, STp->block_size<1024?'b':'k');
3355 retval = (-EINVAL);
3356 goto out;
3357 }
3358
3359 if (STp->first_frame_position >= STp->capacity - OSST_EOM_RESERVE) {
3360 printk(KERN_ERR "%s:E: Write truncated at EOM early warning (frame %d).\n",
3361 name, STp->first_frame_position);
3362 retval = (-ENOSPC);
3363 goto out;
3364 }
3365
3366 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && !do_door_lock(STp, 1))
3367 STp->door_locked = ST_LOCKED_AUTO;
3368
3369 STps = &(STp->ps[STp->partition]);
3370
3371 if (STps->rw == ST_READING) {
3372 #if DEBUG
3373 printk(OSST_DEB_MSG "%s:D: Switching from read to write at file %d, block %d\n", name,
3374 STps->drv_file, STps->drv_block);
3375 #endif
3376 retval = osst_flush_buffer(STp, &SRpnt, 0);
3377 if (retval)
3378 goto out;
3379 STps->rw = ST_IDLE;
3380 }
3381 if (STps->rw != ST_WRITING) {
3382 /* Are we totally rewriting this tape? */
3383 if (!STp->header_ok ||
3384 (STp->first_frame_position == STp->first_data_ppos && STps->drv_block < 0) ||
3385 (STps->drv_file == 0 && STps->drv_block == 0)) {
3386 STp->wrt_pass_cntr++;
3387 #if DEBUG
3388 printk(OSST_DEB_MSG "%s:D: Allocating next write pass counter: %d\n",
3389 name, STp->wrt_pass_cntr);
3390 #endif
3391 osst_reset_header(STp, &SRpnt);
3392 STps->drv_file = STps->drv_block = 0;
3393 }
3394 /* Do we know where we'll be writing on the tape? */
3395 else {
3396 if ((STp->fast_open && osst_verify_position(STp, &SRpnt)) ||
3397 STps->drv_file < 0 || STps->drv_block < 0) {
3398 if (STp->first_frame_position == STp->eod_frame_ppos) { /* at EOD */
3399 STps->drv_file = STp->filemark_cnt;
3400 STps->drv_block = 0;
3401 }
3402 else {
3403 /* We have no idea where the tape is positioned - give up */
3404 #if DEBUG
3405 printk(OSST_DEB_MSG
3406 "%s:D: Cannot write at indeterminate position.\n", name);
3407 #endif
3408 retval = (-EIO);
3409 goto out;
3410 }
3411 }
3412 if ((STps->drv_file + STps->drv_block) > 0 && STps->drv_file < STp->filemark_cnt) {
3413 STp->filemark_cnt = STps->drv_file;
3414 STp->last_mark_ppos =
3415 ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[STp->filemark_cnt-1]);
3416 printk(KERN_WARNING
3417 "%s:W: Overwriting file %d with old write pass counter %d\n",
3418 name, STps->drv_file, STp->wrt_pass_cntr);
3419 printk(KERN_WARNING
3420 "%s:W: may lead to stale data being accepted on reading back!\n",
3421 name);
3422 #if DEBUG
3423 printk(OSST_DEB_MSG
3424 "%s:D: resetting filemark count to %d and last mark ppos,lbn to %d,%d\n",
3425 name, STp->filemark_cnt, STp->last_mark_ppos, STp->last_mark_lbn);
3426 #endif
3427 }
3428 }
3429 STp->fast_open = 0;
3430 }
3431 if (!STp->header_ok) {
3432 #if DEBUG
3433 printk(OSST_DEB_MSG "%s:D: Write cannot proceed without valid headers\n", name);
3434 #endif
3435 retval = (-EIO);
3436 goto out;
3437 }
3438
3439 if ((STp->buffer)->writing) {
3440 if (SRpnt) printk(KERN_ERR "%s:A: Not supposed to have SRpnt at line %d\n", name, __LINE__);
3441 osst_write_behind_check(STp);
3442 if ((STp->buffer)->syscall_result) {
3443 #if DEBUG
3444 if (debugging)
3445 printk(OSST_DEB_MSG "%s:D: Async write error (write) %x.\n", name,
3446 (STp->buffer)->midlevel_result);
3447 #endif
3448 if ((STp->buffer)->midlevel_result == INT_MAX)
3449 STps->eof = ST_EOM_OK;
3450 else
3451 STps->eof = ST_EOM_ERROR;
3452 }
3453 }
3454 if (STps->eof == ST_EOM_OK) {
3455 retval = (-ENOSPC);
3456 goto out;
3457 }
3458 else if (STps->eof == ST_EOM_ERROR) {
3459 retval = (-EIO);
3460 goto out;
3461 }
3462
3463 /* Check the buffer readability in cases where copy_user might catch
3464 the problems after some tape movement. */
3465 if ((copy_from_user(&i, buf, 1) != 0 ||
3466 copy_from_user(&i, buf + count - 1, 1) != 0)) {
3467 retval = (-EFAULT);
3468 goto out;
3469 }
3470
3471 if (!STm->do_buffer_writes) {
3472 write_threshold = 1;
3473 }
3474 else
3475 write_threshold = (STp->buffer)->buffer_blocks * STp->block_size;
3476 if (!STm->do_async_writes)
3477 write_threshold--;
3478
3479 total = count;
3480 #if DEBUG
3481 if (debugging)
3482 printk(OSST_DEB_MSG "%s:D: Writing %d bytes to file %d block %d lblk %d fseq %d fppos %d\n",
3483 name, (int) count, STps->drv_file, STps->drv_block,
3484 STp->logical_blk_num, STp->frame_seq_number, STp->first_frame_position);
3485 #endif
3486 b_point = buf;
3487 while ((STp->buffer)->buffer_bytes + count > write_threshold)
3488 {
3489 doing_write = 1;
3490 do_count = (STp->buffer)->buffer_blocks * STp->block_size -
3491 (STp->buffer)->buffer_bytes;
3492 if (do_count > count)
3493 do_count = count;
3494
3495 i = append_to_buffer(b_point, STp->buffer, do_count);
3496 if (i) {
3497 retval = i;
3498 goto out;
3499 }
3500
3501 blks = do_count / STp->block_size;
3502 STp->logical_blk_num += blks; /* logical_blk_num is incremented as data is moved from user */
3503
3504 i = osst_write_frame(STp, &SRpnt, 1);
3505
3506 if (i == (-ENOSPC)) {
3507 transfer = STp->buffer->writing; /* FIXME -- check this logic */
3508 if (transfer <= do_count) {
3509 filp->f_pos += do_count - transfer;
3510 count -= do_count - transfer;
3511 if (STps->drv_block >= 0) {
3512 STps->drv_block += (do_count - transfer) / STp->block_size;
3513 }
3514 STps->eof = ST_EOM_OK;
3515 retval = (-ENOSPC); /* EOM within current request */
3516 #if DEBUG
3517 if (debugging)
3518 printk(OSST_DEB_MSG "%s:D: EOM with %d bytes unwritten.\n",
3519 name, (int) transfer);
3520 #endif
3521 }
3522 else {
3523 STps->eof = ST_EOM_ERROR;
3524 STps->drv_block = (-1); /* Too cautious? */
3525 retval = (-EIO); /* EOM for old data */
3526 #if DEBUG
3527 if (debugging)
3528 printk(OSST_DEB_MSG "%s:D: EOM with lost data.\n", name);
3529 #endif
3530 }
3531 }
3532 else
3533 retval = i;
3534
3535 if (retval < 0) {
3536 if (SRpnt != NULL) {
3537 osst_release_request(SRpnt);
3538 SRpnt = NULL;
3539 }
3540 STp->buffer->buffer_bytes = 0;
3541 STp->dirty = 0;
3542 if (count < total)
3543 retval = total - count;
3544 goto out;
3545 }
3546
3547 filp->f_pos += do_count;
3548 b_point += do_count;
3549 count -= do_count;
3550 if (STps->drv_block >= 0) {
3551 STps->drv_block += blks;
3552 }
3553 STp->buffer->buffer_bytes = 0;
3554 STp->dirty = 0;
3555 } /* end while write threshold exceeded */
3556
3557 if (count != 0) {
3558 STp->dirty = 1;
3559 i = append_to_buffer(b_point, STp->buffer, count);
3560 if (i) {
3561 retval = i;
3562 goto out;
3563 }
3564 blks = count / STp->block_size;
3565 STp->logical_blk_num += blks;
3566 if (STps->drv_block >= 0) {
3567 STps->drv_block += blks;
3568 }
3569 filp->f_pos += count;
3570 count = 0;
3571 }
3572
3573 if (doing_write && (STp->buffer)->syscall_result != 0) {
3574 retval = (STp->buffer)->syscall_result;
3575 goto out;
3576 }
3577
3578 if (STm->do_async_writes && ((STp->buffer)->buffer_bytes >= STp->write_threshold)) {
3579 /* Schedule an asynchronous write */
3580 (STp->buffer)->writing = ((STp->buffer)->buffer_bytes /
3581 STp->block_size) * STp->block_size;
3582 STp->dirty = !((STp->buffer)->writing ==
3583 (STp->buffer)->buffer_bytes);
3584
3585 i = osst_write_frame(STp, &SRpnt, 0);
3586 if (i < 0) {
3587 retval = (-EIO);
3588 goto out;
3589 }
3590 SRpnt = NULL; /* Prevent releasing this request! */
3591 }
3592 STps->at_sm &= (total == 0);
3593 if (total > 0)
3594 STps->eof = ST_NOEOF;
3595
3596 retval = total;
3597
3598 out:
3599 if (SRpnt != NULL) osst_release_request(SRpnt);
3600
3601 up(&STp->lock);
3602
3603 return retval;
3604 }
3605
3606
3607 /* Read command */
3608 static ssize_t osst_read(struct file * filp, char __user * buf, size_t count, loff_t *ppos)
3609 {
3610 ssize_t total, retval = 0;
3611 ssize_t i, transfer;
3612 int special;
3613 struct st_modedef * STm;
3614 struct st_partstat * STps;
3615 struct osst_request * SRpnt = NULL;
3616 struct osst_tape * STp = filp->private_data;
3617 char * name = tape_name(STp);
3618
3619
3620 if (down_interruptible(&STp->lock))
3621 return (-ERESTARTSYS);
3622
3623 /*
3624 * If we are in the middle of error recovery, don't let anyone
3625 * else try and use this device. Also, if error recovery fails, it
3626 * may try and take the device offline, in which case all further
3627 * access to the device is prohibited.
3628 */
3629 if( !scsi_block_when_processing_errors(STp->device) ) {
3630 retval = (-ENXIO);
3631 goto out;
3632 }
3633
3634 if (STp->ready != ST_READY) {
3635 if (STp->ready == ST_NO_TAPE)
3636 retval = (-ENOMEDIUM);
3637 else
3638 retval = (-EIO);
3639 goto out;
3640 }
3641 STm = &(STp->modes[STp->current_mode]);
3642 if (!STm->defined) {
3643 retval = (-ENXIO);
3644 goto out;
3645 }
3646 #if DEBUG
3647 if (!STp->in_use) {
3648 printk(OSST_DEB_MSG "%s:D: Incorrect device.\n", name);
3649 retval = (-EIO);
3650 goto out;
3651 }
3652 #endif
3653 /* Must have initialized medium */
3654 if (!STp->header_ok) {
3655 retval = (-EIO);
3656 goto out;
3657 }
3658
3659 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && !do_door_lock(STp, 1))
3660 STp->door_locked = ST_LOCKED_AUTO;
3661
3662 STps = &(STp->ps[STp->partition]);
3663 if (STps->rw == ST_WRITING) {
3664 retval = osst_flush_buffer(STp, &SRpnt, 0);
3665 if (retval)
3666 goto out;
3667 STps->rw = ST_IDLE;
3668 /* FIXME -- this may leave the tape without EOD and up2date headers */
3669 }
3670
3671 if ((count % STp->block_size) != 0) {
3672 printk(KERN_WARNING
3673 "%s:W: Read (%Zd bytes) not multiple of tape block size (%d%c).\n", name, count,
3674 STp->block_size<1024?STp->block_size:STp->block_size/1024, STp->block_size<1024?'b':'k');
3675 }
3676
3677 #if DEBUG
3678 if (debugging && STps->eof != ST_NOEOF)
3679 printk(OSST_DEB_MSG "%s:D: EOF/EOM flag up (%d). Bytes %d\n", name,
3680 STps->eof, (STp->buffer)->buffer_bytes);
3681 #endif
3682 if ((STp->buffer)->buffer_bytes == 0 &&
3683 STps->eof >= ST_EOD_1) {
3684 if (STps->eof < ST_EOD) {
3685 STps->eof += 1;
3686 retval = 0;
3687 goto out;
3688 }
3689 retval = (-EIO); /* EOM or Blank Check */
3690 goto out;
3691 }
3692
3693 /* Check the buffer writability before any tape movement. Don't alter
3694 buffer data. */
3695 if (copy_from_user(&i, buf, 1) != 0 ||
3696 copy_to_user (buf, &i, 1) != 0 ||
3697 copy_from_user(&i, buf + count - 1, 1) != 0 ||
3698 copy_to_user (buf + count - 1, &i, 1) != 0) {
3699 retval = (-EFAULT);
3700 goto out;
3701 }
3702
3703 /* Loop until enough data in buffer or a special condition found */
3704 for (total = 0, special = 0; total < count - STp->block_size + 1 && !special; ) {
3705
3706 /* Get new data if the buffer is empty */
3707 if ((STp->buffer)->buffer_bytes == 0) {
3708 if (STps->eof == ST_FM_HIT)
3709 break;
3710 special = osst_get_logical_frame(STp, &SRpnt, STp->frame_seq_number, 0);
3711 if (special < 0) { /* No need to continue read */
3712 STp->frame_in_buffer = 0;
3713 retval = special;
3714 goto out;
3715 }
3716 }
3717
3718 /* Move the data from driver buffer to user buffer */
3719 if ((STp->buffer)->buffer_bytes > 0) {
3720 #if DEBUG
3721 if (debugging && STps->eof != ST_NOEOF)
3722 printk(OSST_DEB_MSG "%s:D: EOF up (%d). Left %d, needed %d.\n", name,
3723 STps->eof, (STp->buffer)->buffer_bytes, (int) (count - total));
3724 #endif
3725 /* force multiple of block size, note block_size may have been adjusted */
3726 transfer = (((STp->buffer)->buffer_bytes < count - total ?
3727 (STp->buffer)->buffer_bytes : count - total)/
3728 STp->block_size) * STp->block_size;
3729
3730 if (transfer == 0) {
3731 printk(KERN_WARNING
3732 "%s:W: Nothing can be transfered, requested %Zd, tape block size (%d%c).\n",
3733 name, count, STp->block_size < 1024?
3734 STp->block_size:STp->block_size/1024,
3735 STp->block_size<1024?'b':'k');
3736 break;
3737 }
3738 i = from_buffer(STp->buffer, buf, transfer);
3739 if (i) {
3740 retval = i;
3741 goto out;
3742 }
3743 STp->logical_blk_num += transfer / STp->block_size;
3744 STps->drv_block += transfer / STp->block_size;
3745 filp->f_pos += transfer;
3746 buf += transfer;
3747 total += transfer;
3748 }
3749
3750 if ((STp->buffer)->buffer_bytes == 0) {
3751 #if DEBUG
3752 if (debugging)
3753 printk(OSST_DEB_MSG "%s:D: Finished with frame %d\n",
3754 name, STp->frame_seq_number);
3755 #endif
3756 STp->frame_in_buffer = 0;
3757 STp->frame_seq_number++; /* frame to look for next time */
3758 }
3759 } /* for (total = 0, special = 0; total < count && !special; ) */
3760
3761 /* Change the eof state if no data from tape or buffer */
3762 if (total == 0) {
3763 if (STps->eof == ST_FM_HIT) {
3764 STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD_2:ST_FM;
3765 STps->drv_block = 0;
3766 if (STps->drv_file >= 0)
3767 STps->drv_file++;
3768 }
3769 else if (STps->eof == ST_EOD_1) {
3770 STps->eof = ST_EOD_2;
3771 if (STps->drv_block > 0 && STps->drv_file >= 0)
3772 STps->drv_file++;
3773 STps->drv_block = 0;
3774 }
3775 else if (STps->eof == ST_EOD_2)
3776 STps->eof = ST_EOD;
3777 }
3778 else if (STps->eof == ST_FM)
3779 STps->eof = ST_NOEOF;
3780
3781 retval = total;
3782
3783 out:
3784 if (SRpnt != NULL) osst_release_request(SRpnt);
3785
3786 up(&STp->lock);
3787
3788 return retval;
3789 }
3790
3791
3792 /* Set the driver options */
3793 static void osst_log_options(struct osst_tape *STp, struct st_modedef *STm, char *name)
3794 {
3795 printk(KERN_INFO
3796 "%s:I: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
3797 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
3798 STm->do_read_ahead);
3799 printk(KERN_INFO
3800 "%s:I: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
3801 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
3802 printk(KERN_INFO
3803 "%s:I: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
3804 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
3805 STp->scsi2_logical);
3806 printk(KERN_INFO
3807 "%s:I: sysv: %d\n", name, STm->sysv);
3808 #if DEBUG
3809 printk(KERN_INFO
3810 "%s:D: debugging: %d\n",
3811 name, debugging);
3812 #endif
3813 }
3814
3815
3816 static int osst_set_options(struct osst_tape *STp, long options)
3817 {
3818 int value;
3819 long code;
3820 struct st_modedef * STm;
3821 char * name = tape_name(STp);
3822
3823 STm = &(STp->modes[STp->current_mode]);
3824 if (!STm->defined) {
3825 memcpy(STm, &(STp->modes[0]), sizeof(*STm));
3826 modes_defined = 1;
3827 #if DEBUG
3828 if (debugging)
3829 printk(OSST_DEB_MSG "%s:D: Initialized mode %d definition from mode 0\n",
3830 name, STp->current_mode);
3831 #endif
3832 }
3833
3834 code = options & MT_ST_OPTIONS;
3835 if (code == MT_ST_BOOLEANS) {
3836 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
3837 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
3838 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
3839 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
3840 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
3841 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
3842 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
3843 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
3844 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
3845 if ((STp->device)->scsi_level >= SCSI_2)
3846 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
3847 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
3848 STm->sysv = (options & MT_ST_SYSV) != 0;
3849 #if DEBUG
3850 debugging = (options & MT_ST_DEBUGGING) != 0;
3851 #endif
3852 osst_log_options(STp, STm, name);
3853 }
3854 else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
3855 value = (code == MT_ST_SETBOOLEANS);
3856 if ((options & MT_ST_BUFFER_WRITES) != 0)
3857 STm->do_buffer_writes = value;
3858 if ((options & MT_ST_ASYNC_WRITES) != 0)
3859 STm->do_async_writes = value;
3860 if ((options & MT_ST_DEF_WRITES) != 0)
3861 STm->defaults_for_writes = value;
3862 if ((options & MT_ST_READ_AHEAD) != 0)
3863 STm->do_read_ahead = value;
3864 if ((options & MT_ST_TWO_FM) != 0)
3865 STp->two_fm = value;
3866 if ((options & MT_ST_FAST_MTEOM) != 0)
3867 STp->fast_mteom = value;
3868 if ((options & MT_ST_AUTO_LOCK) != 0)
3869 STp->do_auto_lock = value;
3870 if ((options & MT_ST_CAN_BSR) != 0)
3871 STp->can_bsr = value;
3872 if ((options & MT_ST_NO_BLKLIMS) != 0)
3873 STp->omit_blklims = value;
3874 if ((STp->device)->scsi_level >= SCSI_2 &&
3875 (options & MT_ST_CAN_PARTITIONS) != 0)
3876 STp->can_partitions = value;
3877 if ((options & MT_ST_SCSI2LOGICAL) != 0)
3878 STp->scsi2_logical = value;
3879 if ((options & MT_ST_SYSV) != 0)
3880 STm->sysv = value;
3881 #if DEBUG
3882 if ((options & MT_ST_DEBUGGING) != 0)
3883 debugging = value;
3884 #endif
3885 osst_log_options(STp, STm, name);
3886 }
3887 else if (code == MT_ST_WRITE_THRESHOLD) {
3888 value = (options & ~MT_ST_OPTIONS) * ST_KILOBYTE;
3889 if (value < 1 || value > osst_buffer_size) {
3890 printk(KERN_WARNING "%s:W: Write threshold %d too small or too large.\n",
3891 name, value);
3892 return (-EIO);
3893 }
3894 STp->write_threshold = value;
3895 printk(KERN_INFO "%s:I: Write threshold set to %d bytes.\n",
3896 name, value);
3897 }
3898 else if (code == MT_ST_DEF_BLKSIZE) {
3899 value = (options & ~MT_ST_OPTIONS);
3900 if (value == ~MT_ST_OPTIONS) {
3901 STm->default_blksize = (-1);
3902 printk(KERN_INFO "%s:I: Default block size disabled.\n", name);
3903 }
3904 else {
3905 if (value < 512 || value > OS_DATA_SIZE || OS_DATA_SIZE % value) {
3906 printk(KERN_WARNING "%s:W: Default block size cannot be set to %d.\n",
3907 name, value);
3908 return (-EINVAL);
3909 }
3910 STm->default_blksize = value;
3911 printk(KERN_INFO "%s:I: Default block size set to %d bytes.\n",
3912 name, STm->default_blksize);
3913 }
3914 }
3915 else if (code == MT_ST_TIMEOUTS) {
3916 value = (options & ~MT_ST_OPTIONS);
3917 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
3918 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
3919 printk(KERN_INFO "%s:I: Long timeout set to %d seconds.\n", name,
3920 (value & ~MT_ST_SET_LONG_TIMEOUT));
3921 }
3922 else {
3923 STp->timeout = value * HZ;
3924 printk(KERN_INFO "%s:I: Normal timeout set to %d seconds.\n", name, value);
3925 }
3926 }
3927 else if (code == MT_ST_DEF_OPTIONS) {
3928 code = (options & ~MT_ST_CLEAR_DEFAULT);
3929 value = (options & MT_ST_CLEAR_DEFAULT);
3930 if (code == MT_ST_DEF_DENSITY) {
3931 if (value == MT_ST_CLEAR_DEFAULT) {
3932 STm->default_density = (-1);
3933 printk(KERN_INFO "%s:I: Density default disabled.\n", name);
3934 }
3935 else {
3936 STm->default_density = value & 0xff;
3937 printk(KERN_INFO "%s:I: Density default set to %x\n",
3938 name, STm->default_density);
3939 }
3940 }
3941 else if (code == MT_ST_DEF_DRVBUFFER) {
3942 if (value == MT_ST_CLEAR_DEFAULT) {
3943 STp->default_drvbuffer = 0xff;
3944 printk(KERN_INFO "%s:I: Drive buffer default disabled.\n", name);
3945 }
3946 else {
3947 STp->default_drvbuffer = value & 7;
3948 printk(KERN_INFO "%s:I: Drive buffer default set to %x\n",
3949 name, STp->default_drvbuffer);
3950 }
3951 }
3952 else if (code == MT_ST_DEF_COMPRESSION) {
3953 if (value == MT_ST_CLEAR_DEFAULT) {
3954 STm->default_compression = ST_DONT_TOUCH;
3955 printk(KERN_INFO "%s:I: Compression default disabled.\n", name);
3956 }
3957 else {
3958 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
3959 printk(KERN_INFO "%s:I: Compression default set to %x\n",
3960 name, (value & 1));
3961 }
3962 }
3963 }
3964 else
3965 return (-EIO);
3966
3967 return 0;
3968 }
3969
3970
3971 /* Internal ioctl function */
3972 static int osst_int_ioctl(struct osst_tape * STp, struct osst_request ** aSRpnt,
3973 unsigned int cmd_in, unsigned long arg)
3974 {
3975 int timeout;
3976 long ltmp;
3977 int i, ioctl_result;
3978 int chg_eof = 1;
3979 unsigned char cmd[MAX_COMMAND_SIZE];
3980 struct osst_request * SRpnt = * aSRpnt;
3981 struct st_partstat * STps;
3982 int fileno, blkno, at_sm, frame_seq_numbr, logical_blk_num;
3983 int datalen = 0, direction = DMA_NONE;
3984 char * name = tape_name(STp);
3985
3986 if (STp->ready != ST_READY && cmd_in != MTLOAD) {
3987 if (STp->ready == ST_NO_TAPE)
3988 return (-ENOMEDIUM);
3989 else
3990 return (-EIO);
3991 }
3992 timeout = STp->long_timeout;
3993 STps = &(STp->ps[STp->partition]);
3994 fileno = STps->drv_file;
3995 blkno = STps->drv_block;
3996 at_sm = STps->at_sm;
3997 frame_seq_numbr = STp->frame_seq_number;
3998 logical_blk_num = STp->logical_blk_num;
3999
4000 memset(cmd, 0, MAX_COMMAND_SIZE);
4001 switch (cmd_in) {
4002 case MTFSFM:
4003 chg_eof = 0; /* Changed from the FSF after this */
4004 case MTFSF:
4005 if (STp->raw)
4006 return (-EIO);
4007 if (STp->linux_media)
4008 ioctl_result = osst_space_over_filemarks_forward_fast(STp, &SRpnt, cmd_in, arg);
4009 else
4010 ioctl_result = osst_space_over_filemarks_forward_slow(STp, &SRpnt, cmd_in, arg);
4011 if (fileno >= 0)
4012 fileno += arg;
4013 blkno = 0;
4014 at_sm &= (arg == 0);
4015 goto os_bypass;
4016
4017 case MTBSF:
4018 chg_eof = 0; /* Changed from the FSF after this */
4019 case MTBSFM:
4020 if (STp->raw)
4021 return (-EIO);
4022 ioctl_result = osst_space_over_filemarks_backward(STp, &SRpnt, cmd_in, arg);
4023 if (fileno >= 0)
4024 fileno -= arg;
4025 blkno = (-1); /* We can't know the block number */
4026 at_sm &= (arg == 0);
4027 goto os_bypass;
4028
4029 case MTFSR:
4030 case MTBSR:
4031 #if DEBUG
4032 if (debugging)
4033 printk(OSST_DEB_MSG "%s:D: Skipping %lu blocks %s from logical block %d\n",
4034 name, arg, cmd_in==MTFSR?"forward":"backward", logical_blk_num);
4035 #endif
4036 if (cmd_in == MTFSR) {
4037 logical_blk_num += arg;
4038 if (blkno >= 0) blkno += arg;
4039 }
4040 else {
4041 logical_blk_num -= arg;
4042 if (blkno >= 0) blkno -= arg;
4043 }
4044 ioctl_result = osst_seek_logical_blk(STp, &SRpnt, logical_blk_num);
4045 fileno = STps->drv_file;
4046 blkno = STps->drv_block;
4047 at_sm &= (arg == 0);
4048 goto os_bypass;
4049
4050 case MTFSS:
4051 cmd[0] = SPACE;
4052 cmd[1] = 0x04; /* Space Setmarks */ /* FIXME -- OS can't do this? */
4053 cmd[2] = (arg >> 16);
4054 cmd[3] = (arg >> 8);
4055 cmd[4] = arg;
4056 #if DEBUG
4057 if (debugging)
4058 printk(OSST_DEB_MSG "%s:D: Spacing tape forward %d setmarks.\n", name,
4059 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
4060 #endif
4061 if (arg != 0) {
4062 blkno = fileno = (-1);
4063 at_sm = 1;
4064 }
4065 break;
4066 case MTBSS:
4067 cmd[0] = SPACE;
4068 cmd[1] = 0x04; /* Space Setmarks */ /* FIXME -- OS can't do this? */
4069 ltmp = (-arg);
4070 cmd[2] = (ltmp >> 16);
4071 cmd[3] = (ltmp >> 8);
4072 cmd[4] = ltmp;
4073 #if DEBUG
4074 if (debugging) {
4075 if (cmd[2] & 0x80)
4076 ltmp = 0xff000000;
4077 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
4078 printk(OSST_DEB_MSG "%s:D: Spacing tape backward %ld setmarks.\n",
4079 name, (-ltmp));
4080 }
4081 #endif
4082 if (arg != 0) {
4083 blkno = fileno = (-1);
4084 at_sm = 1;
4085 }
4086 break;
4087 case MTWEOF:
4088 if ((STps->rw == ST_WRITING || STp->dirty) && !STp->pos_unknown) {
4089 STp->write_type = OS_WRITE_DATA;
4090 ioctl_result = osst_flush_write_buffer(STp, &SRpnt);
4091 } else
4092 ioctl_result = 0;
4093 #if DEBUG
4094 if (debugging)
4095 printk(OSST_DEB_MSG "%s:D: Writing %ld filemark(s).\n", name, arg);
4096 #endif
4097 for (i=0; i<arg; i++)
4098 ioctl_result |= osst_write_filemark(STp, &SRpnt);
4099 if (fileno >= 0) fileno += arg;
4100 if (blkno >= 0) blkno = 0;
4101 goto os_bypass;
4102
4103 case MTWSM:
4104 if (STp->write_prot)
4105 return (-EACCES);
4106 if (!STp->raw)
4107 return 0;
4108 cmd[0] = WRITE_FILEMARKS; /* FIXME -- need OS version */
4109 if (cmd_in == MTWSM)
4110 cmd[1] = 2;
4111 cmd[2] = (arg >> 16);
4112 cmd[3] = (arg >> 8);
4113 cmd[4] = arg;
4114 timeout = STp->timeout;
4115 #if DEBUG
4116 if (debugging)
4117 printk(OSST_DEB_MSG "%s:D: Writing %d setmark(s).\n", name,
4118 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
4119 #endif
4120 if (fileno >= 0)
4121 fileno += arg;
4122 blkno = 0;
4123 at_sm = (cmd_in == MTWSM);
4124 break;
4125 case MTOFFL:
4126 case MTLOAD:
4127 case MTUNLOAD:
4128 case MTRETEN:
4129 cmd[0] = START_STOP;
4130 cmd[1] = 1; /* Don't wait for completion */
4131 if (cmd_in == MTLOAD) {
4132 if (STp->ready == ST_NO_TAPE)
4133 cmd[4] = 4; /* open tray */
4134 else
4135 cmd[4] = 1; /* load */
4136 }
4137 if (cmd_in == MTRETEN)
4138 cmd[4] = 3; /* retension then mount */
4139 if (cmd_in == MTOFFL)
4140 cmd[4] = 4; /* rewind then eject */
4141 timeout = STp->timeout;
4142 #if DEBUG
4143 if (debugging) {
4144 switch (cmd_in) {
4145 case MTUNLOAD:
4146 printk(OSST_DEB_MSG "%s:D: Unloading tape.\n", name);
4147 break;
4148 case MTLOAD:
4149 printk(OSST_DEB_MSG "%s:D: Loading tape.\n", name);
4150 break;
4151 case MTRETEN:
4152 printk(OSST_DEB_MSG "%s:D: Retensioning tape.\n", name);
4153 break;
4154 case MTOFFL:
4155 printk(OSST_DEB_MSG "%s:D: Ejecting tape.\n", name);
4156 break;
4157 }
4158 }
4159 #endif
4160 fileno = blkno = at_sm = frame_seq_numbr = logical_blk_num = 0 ;
4161 break;
4162 case MTNOP:
4163 #if DEBUG
4164 if (debugging)
4165 printk(OSST_DEB_MSG "%s:D: No-op on tape.\n", name);
4166 #endif
4167 return 0; /* Should do something ? */
4168 break;
4169 case MTEOM:
4170 #if DEBUG
4171 if (debugging)
4172 printk(OSST_DEB_MSG "%s:D: Spacing to end of recorded medium.\n", name);
4173 #endif
4174 if ((osst_position_tape_and_confirm(STp, &SRpnt, STp->eod_frame_ppos) < 0) ||
4175 (osst_get_logical_frame(STp, &SRpnt, -1, 0) < 0)) {
4176 ioctl_result = -EIO;
4177 goto os_bypass;
4178 }
4179 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_EOD) {
4180 #if DEBUG
4181 printk(OSST_DEB_MSG "%s:D: No EOD frame found where expected.\n", name);
4182 #endif
4183 ioctl_result = -EIO;
4184 goto os_bypass;
4185 }
4186 ioctl_result = osst_set_frame_position(STp, &SRpnt, STp->eod_frame_ppos, 0);
4187 fileno = STp->filemark_cnt;
4188 blkno = at_sm = 0;
4189 goto os_bypass;
4190
4191 case MTERASE:
4192 if (STp->write_prot)
4193 return (-EACCES);
4194 ioctl_result = osst_reset_header(STp, &SRpnt);
4195 i = osst_write_eod(STp, &SRpnt);
4196 if (i < ioctl_result) ioctl_result = i;
4197 i = osst_position_tape_and_confirm(STp, &SRpnt, STp->eod_frame_ppos);
4198 if (i < ioctl_result) ioctl_result = i;
4199 fileno = blkno = at_sm = 0 ;
4200 goto os_bypass;
4201
4202 case MTREW:
4203 cmd[0] = REZERO_UNIT; /* rewind */
4204 cmd[1] = 1;
4205 #if DEBUG
4206 if (debugging)
4207 printk(OSST_DEB_MSG "%s:D: Rewinding tape, Immed=%d.\n", name, cmd[1]);
4208 #endif
4209 fileno = blkno = at_sm = frame_seq_numbr = logical_blk_num = 0 ;
4210 break;
4211
4212 case MTSETBLK: /* Set block length */
4213 if ((STps->drv_block == 0 ) &&
4214 !STp->dirty &&
4215 ((STp->buffer)->buffer_bytes == 0) &&
4216 ((arg & MT_ST_BLKSIZE_MASK) >= 512 ) &&
4217 ((arg & MT_ST_BLKSIZE_MASK) <= OS_DATA_SIZE) &&
4218 !(OS_DATA_SIZE % (arg & MT_ST_BLKSIZE_MASK)) ) {
4219 /*
4220 * Only allowed to change the block size if you opened the
4221 * device at the beginning of a file before writing anything.
4222 * Note, that when reading, changing block_size is futile,
4223 * as the size used when writing overrides it.
4224 */
4225 STp->block_size = (arg & MT_ST_BLKSIZE_MASK);
4226 printk(KERN_INFO "%s:I: Block size set to %d bytes.\n",
4227 name, STp->block_size);
4228 return 0;
4229 }
4230 case MTSETDENSITY: /* Set tape density */
4231 case MTSETDRVBUFFER: /* Set drive buffering */
4232 case SET_DENS_AND_BLK: /* Set density and block size */
4233 chg_eof = 0;
4234 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
4235 return (-EIO); /* Not allowed if data in buffer */
4236 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
4237 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
4238 (arg & MT_ST_BLKSIZE_MASK) != STp->block_size ) {
4239 printk(KERN_WARNING "%s:W: Illegal to set block size to %d%s.\n",
4240 name, (int)(arg & MT_ST_BLKSIZE_MASK),
4241 (OS_DATA_SIZE % (arg & MT_ST_BLKSIZE_MASK))?"":" now");
4242 return (-EINVAL);
4243 }
4244 return 0; /* FIXME silently ignore if block size didn't change */
4245
4246 default:
4247 return (-ENOSYS);
4248 }
4249
4250 SRpnt = osst_do_scsi(SRpnt, STp, cmd, datalen, direction, timeout, MAX_RETRIES, 1);
4251
4252 ioctl_result = (STp->buffer)->syscall_result;
4253
4254 if (!SRpnt) {
4255 #if DEBUG
4256 printk(OSST_DEB_MSG "%s:D: Couldn't exec scsi cmd for IOCTL\n", name);
4257 #endif
4258 return ioctl_result;
4259 }
4260
4261 if (!ioctl_result) { /* SCSI command successful */
4262 STp->frame_seq_number = frame_seq_numbr;
4263 STp->logical_blk_num = logical_blk_num;
4264 }
4265
4266 os_bypass:
4267 #if DEBUG
4268 if (debugging)
4269 printk(OSST_DEB_MSG "%s:D: IOCTL (%d) Result=%d\n", name, cmd_in, ioctl_result);
4270 #endif
4271
4272 if (!ioctl_result) { /* success */
4273
4274 if (cmd_in == MTFSFM) {
4275 fileno--;
4276 blkno--;
4277 }
4278 if (cmd_in == MTBSFM) {
4279 fileno++;
4280 blkno++;
4281 }
4282 STps->drv_block = blkno;
4283 STps->drv_file = fileno;
4284 STps->at_sm = at_sm;
4285
4286 if (cmd_in == MTEOM)
4287 STps->eof = ST_EOD;
4288 else if ((cmd_in == MTFSFM || cmd_in == MTBSF) && STps->eof == ST_FM_HIT) {
4289 ioctl_result = osst_seek_logical_blk(STp, &SRpnt, STp->logical_blk_num-1);
4290 STps->drv_block++;
4291 STp->logical_blk_num++;
4292 STp->frame_seq_number++;
4293 STp->frame_in_buffer = 0;
4294 STp->buffer->read_pointer = 0;
4295 }
4296 else if (cmd_in == MTFSF)
4297 STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD:ST_FM;
4298 else if (chg_eof)
4299 STps->eof = ST_NOEOF;
4300
4301 if (cmd_in == MTOFFL || cmd_in == MTUNLOAD)
4302 STp->rew_at_close = 0;
4303 else if (cmd_in == MTLOAD) {
4304 for (i=0; i < ST_NBR_PARTITIONS; i++) {
4305 STp->ps[i].rw = ST_IDLE;
4306 STp->ps[i].last_block_valid = 0;/* FIXME - where else is this field maintained? */
4307 }
4308 STp->partition = 0;
4309 }
4310
4311 if (cmd_in == MTREW) {
4312 ioctl_result = osst_position_tape_and_confirm(STp, &SRpnt, STp->first_data_ppos);
4313 if (ioctl_result > 0)
4314 ioctl_result = 0;
4315 }
4316
4317 } else if (cmd_in == MTBSF || cmd_in == MTBSFM ) {
4318 if (osst_position_tape_and_confirm(STp, &SRpnt, STp->first_data_ppos) < 0)
4319 STps->drv_file = STps->drv_block = -1;
4320 else
4321 STps->drv_file = STps->drv_block = 0;
4322 STps->eof = ST_NOEOF;
4323 } else if (cmd_in == MTFSF || cmd_in == MTFSFM) {
4324 if (osst_position_tape_and_confirm(STp, &SRpnt, STp->eod_frame_ppos) < 0)
4325 STps->drv_file = STps->drv_block = -1;
4326 else {
4327 STps->drv_file = STp->filemark_cnt;
4328 STps->drv_block = 0;
4329 }
4330 STps->eof = ST_EOD;
4331 } else if (cmd_in == MTBSR || cmd_in == MTFSR || cmd_in == MTWEOF || cmd_in == MTEOM) {
4332 STps->drv_file = STps->drv_block = (-1);
4333 STps->eof = ST_NOEOF;
4334 STp->header_ok = 0;
4335 } else if (cmd_in == MTERASE) {
4336 STp->header_ok = 0;
4337 } else if (SRpnt) { /* SCSI command was not completely successful. */
4338 if (SRpnt->sense[2] & 0x40) {
4339 STps->eof = ST_EOM_OK;
4340 STps->drv_block = 0;
4341 }
4342 if (chg_eof)
4343 STps->eof = ST_NOEOF;
4344
4345 if ((SRpnt->sense[2] & 0x0f) == BLANK_CHECK)
4346 STps->eof = ST_EOD;
4347
4348 if (cmd_in == MTLOAD && osst_wait_for_medium(STp, &SRpnt, 60))
4349 ioctl_result = osst_wait_ready(STp, &SRpnt, 5 * 60, OSST_WAIT_POSITION_COMPLETE);
4350 }
4351 *aSRpnt = SRpnt;
4352
4353 return ioctl_result;
4354 }
4355
4356
4357 /* Open the device */
4358 static int os_scsi_tape_open(struct inode * inode, struct file * filp)
4359 {
4360 unsigned short flags;
4361 int i, b_size, new_session = 0, retval = 0;
4362 unsigned char cmd[MAX_COMMAND_SIZE];
4363 struct osst_request * SRpnt = NULL;
4364 struct osst_tape * STp;
4365 struct st_modedef * STm;
4366 struct st_partstat * STps;
4367 char * name;
4368 int dev = TAPE_NR(inode);
4369 int mode = TAPE_MODE(inode);
4370
4371 /*
4372 * We really want to do nonseekable_open(inode, filp); here, but some
4373 * versions of tar incorrectly call lseek on tapes and bail out if that
4374 * fails. So we disallow pread() and pwrite(), but permit lseeks.
4375 */
4376 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
4377
4378 write_lock(&os_scsi_tapes_lock);
4379 if (dev >= osst_max_dev || os_scsi_tapes == NULL ||
4380 (STp = os_scsi_tapes[dev]) == NULL || !STp->device) {
4381 write_unlock(&os_scsi_tapes_lock);
4382 return (-ENXIO);
4383 }
4384
4385 name = tape_name(STp);
4386
4387 if (STp->in_use) {
4388 write_unlock(&os_scsi_tapes_lock);
4389 #if DEBUG
4390 printk(OSST_DEB_MSG "%s:D: Device already in use.\n", name);
4391 #endif
4392 return (-EBUSY);
4393 }
4394 if (scsi_device_get(STp->device)) {
4395 write_unlock(&os_scsi_tapes_lock);
4396 #if DEBUG
4397 printk(OSST_DEB_MSG "%s:D: Failed scsi_device_get.\n", name);
4398 #endif
4399 return (-ENXIO);
4400 }
4401 filp->private_data = STp;
4402 STp->in_use = 1;
4403 write_unlock(&os_scsi_tapes_lock);
4404 STp->rew_at_close = TAPE_REWIND(inode);
4405
4406 if( !scsi_block_when_processing_errors(STp->device) ) {
4407 return -ENXIO;
4408 }
4409
4410 if (mode != STp->current_mode) {
4411 #if DEBUG
4412 if (debugging)
4413 printk(OSST_DEB_MSG "%s:D: Mode change from %d to %d.\n",
4414 name, STp->current_mode, mode);
4415 #endif
4416 new_session = 1;
4417 STp->current_mode = mode;
4418 }
4419 STm = &(STp->modes[STp->current_mode]);
4420
4421 flags = filp->f_flags;
4422 STp->write_prot = ((flags & O_ACCMODE) == O_RDONLY);
4423
4424 STp->raw = TAPE_IS_RAW(inode);
4425 if (STp->raw)
4426 STp->header_ok = 0;
4427
4428 /* Allocate data segments for this device's tape buffer */
4429 if (!enlarge_buffer(STp->buffer, STp->restr_dma)) {
4430 printk(KERN_ERR "%s:E: Unable to allocate memory segments for tape buffer.\n", name);
4431 retval = (-EOVERFLOW);
4432 goto err_out;
4433 }
4434 if (STp->buffer->buffer_size >= OS_FRAME_SIZE) {
4435 for (i = 0, b_size = 0;
4436 (i < STp->buffer->sg_segs) && ((b_size + STp->buffer->sg[i].length) <= OS_DATA_SIZE);
4437 b_size += STp->buffer->sg[i++].length);
4438 STp->buffer->aux = (os_aux_t *) (page_address(STp->buffer->sg[i].page) + OS_DATA_SIZE - b_size);
4439 #if DEBUG
4440 printk(OSST_DEB_MSG "%s:D: b_data points to %p in segment 0 at %p\n", name,
4441 STp->buffer->b_data, page_address(STp->buffer->sg[0].page));
4442 printk(OSST_DEB_MSG "%s:D: AUX points to %p in segment %d at %p\n", name,
4443 STp->buffer->aux, i, page_address(STp->buffer->sg[i].page));
4444 #endif
4445 } else {
4446 STp->buffer->aux = NULL; /* this had better never happen! */
4447 printk(KERN_NOTICE "%s:A: Framesize %d too large for buffer.\n", name, OS_FRAME_SIZE);
4448 retval = (-EIO);
4449 goto err_out;
4450 }
4451 STp->buffer->writing = 0;
4452 STp->buffer->syscall_result = 0;
4453 STp->dirty = 0;
4454 for (i=0; i < ST_NBR_PARTITIONS; i++) {
4455 STps = &(STp->ps[i]);
4456 STps->rw = ST_IDLE;
4457 }
4458 STp->ready = ST_READY;
4459 #if DEBUG
4460 STp->nbr_waits = STp->nbr_finished = 0;
4461 #endif
4462
4463 memset (cmd, 0, MAX_COMMAND_SIZE);
4464 cmd[0] = TEST_UNIT_READY;
4465
4466 SRpnt = osst_do_scsi(NULL, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
4467 if (!SRpnt) {
4468 retval = (STp->buffer)->syscall_result; /* FIXME - valid? */
4469 goto err_out;
4470 }
4471 if ((SRpnt->sense[0] & 0x70) == 0x70 &&
4472 (SRpnt->sense[2] & 0x0f) == NOT_READY &&
4473 SRpnt->sense[12] == 4 ) {
4474 #if DEBUG
4475 printk(OSST_DEB_MSG "%s:D: Unit not ready, cause %x\n", name, SRpnt->sense[13]);
4476 #endif
4477 if (filp->f_flags & O_NONBLOCK) {
4478 retval = -EAGAIN;
4479 goto err_out;
4480 }
4481 if (SRpnt->sense[13] == 2) { /* initialize command required (LOAD) */
4482 memset (cmd, 0, MAX_COMMAND_SIZE);
4483 cmd[0] = START_STOP;
4484 cmd[1] = 1;
4485 cmd[4] = 1;
4486 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
4487 STp->timeout, MAX_RETRIES, 1);
4488 }
4489 osst_wait_ready(STp, &SRpnt, (SRpnt->sense[13]==1?15:3) * 60, 0);
4490 }
4491 if ((SRpnt->sense[0] & 0x70) == 0x70 &&
4492 (SRpnt->sense[2] & 0x0f) == UNIT_ATTENTION) { /* New media? */
4493 #if DEBUG
4494 printk(OSST_DEB_MSG "%s:D: Unit wants attention\n", name);
4495 #endif
4496 STp->header_ok = 0;
4497
4498 for (i=0; i < 10; i++) {
4499
4500 memset (cmd, 0, MAX_COMMAND_SIZE);
4501 cmd[0] = TEST_UNIT_READY;
4502
4503 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
4504 STp->timeout, MAX_RETRIES, 1);
4505 if ((SRpnt->sense[0] & 0x70) != 0x70 ||
4506 (SRpnt->sense[2] & 0x0f) != UNIT_ATTENTION)
4507 break;
4508 }
4509
4510 STp->pos_unknown = 0;
4511 STp->partition = STp->new_partition = 0;
4512 if (STp->can_partitions)
4513 STp->nbr_partitions = 1; /* This guess will be updated later if necessary */
4514 for (i=0; i < ST_NBR_PARTITIONS; i++) {
4515 STps = &(STp->ps[i]);
4516 STps->rw = ST_IDLE; /* FIXME - seems to be redundant... */
4517 STps->eof = ST_NOEOF;
4518 STps->at_sm = 0;
4519 STps->last_block_valid = 0;
4520 STps->drv_block = 0;
4521 STps->drv_file = 0 ;
4522 }
4523 new_session = 1;
4524 STp->recover_count = 0;
4525 STp->abort_count = 0;
4526 }
4527 /*
4528 * if we have valid headers from before, and the drive/tape seem untouched,
4529 * open without reconfiguring and re-reading the headers
4530 */
4531 if (!STp->buffer->syscall_result && STp->header_ok &&
4532 !SRpnt->result && SRpnt->sense[0] == 0) {
4533
4534 memset(cmd, 0, MAX_COMMAND_SIZE);
4535 cmd[0] = MODE_SENSE;
4536 cmd[1] = 8;
4537 cmd[2] = VENDOR_IDENT_PAGE;
4538 cmd[4] = VENDOR_IDENT_PAGE_LENGTH + MODE_HEADER_LENGTH;
4539
4540 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1);
4541
4542 if (STp->buffer->syscall_result ||
4543 STp->buffer->b_data[MODE_HEADER_LENGTH + 2] != 'L' ||
4544 STp->buffer->b_data[MODE_HEADER_LENGTH + 3] != 'I' ||
4545 STp->buffer->b_data[MODE_HEADER_LENGTH + 4] != 'N' ||
4546 STp->buffer->b_data[MODE_HEADER_LENGTH + 5] != '4' ) {
4547 #if DEBUG
4548 printk(OSST_DEB_MSG "%s:D: Signature was changed to %c%c%c%c\n", name,
4549 STp->buffer->b_data[MODE_HEADER_LENGTH + 2],
4550 STp->buffer->b_data[MODE_HEADER_LENGTH + 3],
4551 STp->buffer->b_data[MODE_HEADER_LENGTH + 4],
4552 STp->buffer->b_data[MODE_HEADER_LENGTH + 5]);
4553 #endif
4554 STp->header_ok = 0;
4555 }
4556 i = STp->first_frame_position;
4557 if (STp->header_ok && i == osst_get_frame_position(STp, &SRpnt)) {
4558 if (STp->door_locked == ST_UNLOCKED) {
4559 if (do_door_lock(STp, 1))
4560 printk(KERN_INFO "%s:I: Can't lock drive door\n", name);
4561 else
4562 STp->door_locked = ST_LOCKED_AUTO;
4563 }
4564 if (!STp->frame_in_buffer) {
4565 STp->block_size = (STm->default_blksize > 0) ?
4566 STm->default_blksize : OS_DATA_SIZE;
4567 STp->buffer->buffer_bytes = STp->buffer->read_pointer = 0;
4568 }
4569 STp->buffer->buffer_blocks = OS_DATA_SIZE / STp->block_size;
4570 STp->fast_open = 1;
4571 osst_release_request(SRpnt);
4572 return 0;
4573 }
4574 #if DEBUG
4575 if (i != STp->first_frame_position)
4576 printk(OSST_DEB_MSG "%s:D: Tape position changed from %d to %d\n",
4577 name, i, STp->first_frame_position);
4578 #endif
4579 STp->header_ok = 0;
4580 }
4581 STp->fast_open = 0;
4582
4583 if ((STp->buffer)->syscall_result != 0 && /* in all error conditions except no medium */
4584 (SRpnt->sense[2] != 2 || SRpnt->sense[12] != 0x3A) ) {
4585
4586 memset(cmd, 0, MAX_COMMAND_SIZE);
4587 cmd[0] = MODE_SELECT;
4588 cmd[1] = 0x10;
4589 cmd[4] = 4 + MODE_HEADER_LENGTH;
4590
4591 (STp->buffer)->b_data[0] = cmd[4] - 1;
4592 (STp->buffer)->b_data[1] = 0; /* Medium Type - ignoring */
4593 (STp->buffer)->b_data[2] = 0; /* Reserved */
4594 (STp->buffer)->b_data[3] = 0; /* Block Descriptor Length */
4595 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 0] = 0x3f;
4596 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 1] = 1;
4597 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] = 2;
4598 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 3] = 3;
4599
4600 #if DEBUG
4601 printk(OSST_DEB_MSG "%s:D: Applying soft reset\n", name);
4602 #endif
4603 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1);
4604
4605 STp->header_ok = 0;
4606
4607 for (i=0; i < 10; i++) {
4608
4609 memset (cmd, 0, MAX_COMMAND_SIZE);
4610 cmd[0] = TEST_UNIT_READY;
4611
4612 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
4613 STp->timeout, MAX_RETRIES, 1);
4614 if ((SRpnt->sense[0] & 0x70) != 0x70 ||
4615 (SRpnt->sense[2] & 0x0f) == NOT_READY)
4616 break;
4617
4618 if ((SRpnt->sense[2] & 0x0f) == UNIT_ATTENTION) {
4619 STp->pos_unknown = 0;
4620 STp->partition = STp->new_partition = 0;
4621 if (STp->can_partitions)
4622 STp->nbr_partitions = 1; /* This guess will be updated later if necessary */
4623 for (i=0; i < ST_NBR_PARTITIONS; i++) {
4624 STps = &(STp->ps[i]);
4625 STps->rw = ST_IDLE;
4626 STps->eof = ST_NOEOF;
4627 STps->at_sm = 0;
4628 STps->last_block_valid = 0;
4629 STps->drv_block = 0;
4630 STps->drv_file = 0 ;
4631 }
4632 new_session = 1;
4633 }
4634 }
4635 }
4636
4637 if (osst_wait_ready(STp, &SRpnt, 15 * 60, 0)) /* FIXME - not allowed with NOBLOCK */
4638 printk(KERN_INFO "%s:I: Device did not become Ready in open\n", name);
4639
4640 if ((STp->buffer)->syscall_result != 0) {
4641 if ((STp->device)->scsi_level >= SCSI_2 &&
4642 (SRpnt->sense[0] & 0x70) == 0x70 &&
4643 (SRpnt->sense[2] & 0x0f) == NOT_READY &&
4644 SRpnt->sense[12] == 0x3a) { /* Check ASC */
4645 STp->ready = ST_NO_TAPE;
4646 } else
4647 STp->ready = ST_NOT_READY;
4648 osst_release_request(SRpnt);
4649 SRpnt = NULL;
4650 STp->density = 0; /* Clear the erroneous "residue" */
4651 STp->write_prot = 0;
4652 STp->block_size = 0;
4653 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
4654 STp->partition = STp->new_partition = 0;
4655 STp->door_locked = ST_UNLOCKED;
4656 return 0;
4657 }
4658
4659 osst_configure_onstream(STp, &SRpnt);
4660
4661 STp->block_size = STp->raw ? OS_FRAME_SIZE : (
4662 (STm->default_blksize > 0) ? STm->default_blksize : OS_DATA_SIZE);
4663 STp->buffer->buffer_blocks = STp->raw ? 1 : OS_DATA_SIZE / STp->block_size;
4664 STp->buffer->buffer_bytes =
4665 STp->buffer->read_pointer =
4666 STp->frame_in_buffer = 0;
4667
4668 #if DEBUG
4669 if (debugging)
4670 printk(OSST_DEB_MSG "%s:D: Block size: %d, frame size: %d, buffer size: %d (%d blocks).\n",
4671 name, STp->block_size, OS_FRAME_SIZE, (STp->buffer)->buffer_size,
4672 (STp->buffer)->buffer_blocks);
4673 #endif
4674
4675 if (STp->drv_write_prot) {
4676 STp->write_prot = 1;
4677 #if DEBUG
4678 if (debugging)
4679 printk(OSST_DEB_MSG "%s:D: Write protected\n", name);
4680 #endif
4681 if ((flags & O_ACCMODE) == O_WRONLY || (flags & O_ACCMODE) == O_RDWR) {
4682 retval = (-EROFS);
4683 goto err_out;
4684 }
4685 }
4686
4687 if (new_session) { /* Change the drive parameters for the new mode */
4688 #if DEBUG
4689 if (debugging)
4690 printk(OSST_DEB_MSG "%s:D: New Session\n", name);
4691 #endif
4692 STp->density_changed = STp->blksize_changed = 0;
4693 STp->compression_changed = 0;
4694 }
4695
4696 /*
4697 * properly position the tape and check the ADR headers
4698 */
4699 if (STp->door_locked == ST_UNLOCKED) {
4700 if (do_door_lock(STp, 1))
4701 printk(KERN_INFO "%s:I: Can't lock drive door\n", name);
4702 else
4703 STp->door_locked = ST_LOCKED_AUTO;
4704 }
4705
4706 osst_analyze_headers(STp, &SRpnt);
4707
4708 osst_release_request(SRpnt);
4709 SRpnt = NULL;
4710
4711 return 0;
4712
4713 err_out:
4714 if (SRpnt != NULL)
4715 osst_release_request(SRpnt);
4716 normalize_buffer(STp->buffer);
4717 STp->header_ok = 0;
4718 STp->in_use = 0;
4719 scsi_device_put(STp->device);
4720
4721 return retval;
4722 }
4723
4724
4725 /* Flush the tape buffer before close */
4726 static int os_scsi_tape_flush(struct file * filp)
4727 {
4728 int result = 0, result2;
4729 struct osst_tape * STp = filp->private_data;
4730 struct st_modedef * STm = &(STp->modes[STp->current_mode]);
4731 struct st_partstat * STps = &(STp->ps[STp->partition]);
4732 struct osst_request * SRpnt = NULL;
4733 char * name = tape_name(STp);
4734
4735 if (file_count(filp) > 1)
4736 return 0;
4737
4738 if ((STps->rw == ST_WRITING || STp->dirty) && !STp->pos_unknown) {
4739 STp->write_type = OS_WRITE_DATA;
4740 result = osst_flush_write_buffer(STp, &SRpnt);
4741 if (result != 0 && result != (-ENOSPC))
4742 goto out;
4743 }
4744 if ( STps->rw >= ST_WRITING && !STp->pos_unknown) {
4745
4746 #if DEBUG
4747 if (debugging) {
4748 printk(OSST_DEB_MSG "%s:D: File length %ld bytes.\n",
4749 name, (long)(filp->f_pos));
4750 printk(OSST_DEB_MSG "%s:D: Async write waits %d, finished %d.\n",
4751 name, STp->nbr_waits, STp->nbr_finished);
4752 }
4753 #endif
4754 result = osst_write_trailer(STp, &SRpnt, !(STp->rew_at_close));
4755 #if DEBUG
4756 if (debugging)
4757 printk(OSST_DEB_MSG "%s:D: Buffer flushed, %d EOF(s) written\n",
4758 name, 1+STp->two_fm);
4759 #endif
4760 }
4761 else if (!STp->rew_at_close) {
4762 STps = &(STp->ps[STp->partition]);
4763 if (!STm->sysv || STps->rw != ST_READING) {
4764 if (STp->can_bsr)
4765 result = osst_flush_buffer(STp, &SRpnt, 0); /* this is the default path */
4766 else if (STps->eof == ST_FM_HIT) {
4767 result = cross_eof(STp, &SRpnt, 0);
4768 if (result) {
4769 if (STps->drv_file >= 0)
4770 STps->drv_file++;
4771 STps->drv_block = 0;
4772 STps->eof = ST_FM;
4773 }
4774 else
4775 STps->eof = ST_NOEOF;
4776 }
4777 }
4778 else if ((STps->eof == ST_NOEOF &&
4779 !(result = cross_eof(STp, &SRpnt, 1))) ||
4780 STps->eof == ST_FM_HIT) {
4781 if (STps->drv_file >= 0)
4782 STps->drv_file++;
4783 STps->drv_block = 0;
4784 STps->eof = ST_FM;
4785 }
4786 }
4787
4788 out:
4789 if (STp->rew_at_close) {
4790 result2 = osst_position_tape_and_confirm(STp, &SRpnt, STp->first_data_ppos);
4791 STps->drv_file = STps->drv_block = STp->frame_seq_number = STp->logical_blk_num = 0;
4792 if (result == 0 && result2 < 0)
4793 result = result2;
4794 }
4795 if (SRpnt) osst_release_request(SRpnt);
4796
4797 if (STp->abort_count || STp->recover_count) {
4798 printk(KERN_INFO "%s:I:", name);
4799 if (STp->abort_count)
4800 printk(" %d unrecovered errors", STp->abort_count);
4801 if (STp->recover_count)
4802 printk(" %d recovered errors", STp->recover_count);
4803 if (STp->write_count)
4804 printk(" in %d frames written", STp->write_count);
4805 if (STp->read_count)
4806 printk(" in %d frames read", STp->read_count);
4807 printk("\n");
4808 STp->recover_count = 0;
4809 STp->abort_count = 0;
4810 }
4811 STp->write_count = 0;
4812 STp->read_count = 0;
4813
4814 return result;
4815 }
4816
4817
4818 /* Close the device and release it */
4819 static int os_scsi_tape_close(struct inode * inode, struct file * filp)
4820 {
4821 int result = 0;
4822 struct osst_tape * STp = filp->private_data;
4823
4824 if (STp->door_locked == ST_LOCKED_AUTO)
4825 do_door_lock(STp, 0);
4826
4827 if (STp->raw)
4828 STp->header_ok = 0;
4829
4830 normalize_buffer(STp->buffer);
4831 write_lock(&os_scsi_tapes_lock);
4832 STp->in_use = 0;
4833 write_unlock(&os_scsi_tapes_lock);
4834
4835 scsi_device_put(STp->device);
4836
4837 return result;
4838 }
4839
4840
4841 /* The ioctl command */
4842 static int osst_ioctl(struct inode * inode,struct file * file,
4843 unsigned int cmd_in, unsigned long arg)
4844 {
4845 int i, cmd_nr, cmd_type, retval = 0;
4846 unsigned int blk;
4847 struct st_modedef * STm;
4848 struct st_partstat * STps;
4849 struct osst_request * SRpnt = NULL;
4850 struct osst_tape * STp = file->private_data;
4851 char * name = tape_name(STp);
4852 void __user * p = (void __user *)arg;
4853
4854 if (down_interruptible(&STp->lock))
4855 return -ERESTARTSYS;
4856
4857 #if DEBUG
4858 if (debugging && !STp->in_use) {
4859 printk(OSST_DEB_MSG "%s:D: Incorrect device.\n", name);
4860 retval = (-EIO);
4861 goto out;
4862 }
4863 #endif
4864 STm = &(STp->modes[STp->current_mode]);
4865 STps = &(STp->ps[STp->partition]);
4866
4867 /*
4868 * If we are in the middle of error recovery, don't let anyone
4869 * else try and use this device. Also, if error recovery fails, it
4870 * may try and take the device offline, in which case all further
4871 * access to the device is prohibited.
4872 */
4873 if( !scsi_block_when_processing_errors(STp->device) ) {
4874 retval = (-ENXIO);
4875 goto out;
4876 }
4877
4878 cmd_type = _IOC_TYPE(cmd_in);
4879 cmd_nr = _IOC_NR(cmd_in);
4880 #if DEBUG
4881 printk(OSST_DEB_MSG "%s:D: Ioctl %d,%d in %s mode\n", name,
4882 cmd_type, cmd_nr, STp->raw?"raw":"normal");
4883 #endif
4884 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
4885 struct mtop mtc;
4886 int auto_weof = 0;
4887
4888 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
4889 retval = (-EINVAL);
4890 goto out;
4891 }
4892
4893 i = copy_from_user((char *) &mtc, p, sizeof(struct mtop));
4894 if (i) {
4895 retval = (-EFAULT);
4896 goto out;
4897 }
4898
4899 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
4900 printk(KERN_WARNING "%s:W: MTSETDRVBUFFER only allowed for root.\n", name);
4901 retval = (-EPERM);
4902 goto out;
4903 }
4904
4905 if (!STm->defined && (mtc.mt_op != MTSETDRVBUFFER && (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
4906 retval = (-ENXIO);
4907 goto out;
4908 }
4909
4910 if (!STp->pos_unknown) {
4911
4912 if (STps->eof == ST_FM_HIT) {
4913 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM|| mtc.mt_op == MTEOM) {
4914 mtc.mt_count -= 1;
4915 if (STps->drv_file >= 0)
4916 STps->drv_file += 1;
4917 }
4918 else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
4919 mtc.mt_count += 1;
4920 if (STps->drv_file >= 0)
4921 STps->drv_file += 1;
4922 }
4923 }
4924
4925 if (mtc.mt_op == MTSEEK) {
4926 /* Old position must be restored if partition will be changed */
4927 i = !STp->can_partitions || (STp->new_partition != STp->partition);
4928 }
4929 else {
4930 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
4931 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
4932 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
4933 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
4934 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
4935 mtc.mt_op == MTCOMPRESSION;
4936 }
4937 i = osst_flush_buffer(STp, &SRpnt, i);
4938 if (i < 0) {
4939 retval = i;
4940 goto out;
4941 }
4942 }
4943 else {
4944 /*
4945 * If there was a bus reset, block further access
4946 * to this device. If the user wants to rewind the tape,
4947 * then reset the flag and allow access again.
4948 */
4949 if(mtc.mt_op != MTREW &&
4950 mtc.mt_op != MTOFFL &&
4951 mtc.mt_op != MTRETEN &&
4952 mtc.mt_op != MTERASE &&
4953 mtc.mt_op != MTSEEK &&
4954 mtc.mt_op != MTEOM) {
4955 retval = (-EIO);
4956 goto out;
4957 }
4958 reset_state(STp);
4959 /* remove this when the midlevel properly clears was_reset */
4960 STp->device->was_reset = 0;
4961 }
4962
4963 if (mtc.mt_op != MTCOMPRESSION && mtc.mt_op != MTLOCK &&
4964 mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
4965 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTSETDRVBUFFER &&
4966 mtc.mt_op != MTMKPART && mtc.mt_op != MTSETPART &&
4967 mtc.mt_op != MTWEOF && mtc.mt_op != MTWSM ) {
4968
4969 /*
4970 * The user tells us to move to another position on the tape.
4971 * If we were appending to the tape content, that would leave
4972 * the tape without proper end, in that case write EOD and
4973 * update the header to reflect its position.
4974 */
4975 #if DEBUG
4976 printk(KERN_WARNING "%s:D: auto_weod %s at ffp=%d,efp=%d,fsn=%d,lbn=%d,fn=%d,bn=%d\n", name,
4977 STps->rw >= ST_WRITING ? "write" : STps->rw == ST_READING ? "read" : "idle",
4978 STp->first_frame_position, STp->eod_frame_ppos, STp->frame_seq_number,
4979 STp->logical_blk_num, STps->drv_file, STps->drv_block );
4980 #endif
4981 if (STps->rw >= ST_WRITING && STp->first_frame_position >= STp->eod_frame_ppos) {
4982 auto_weof = ((STp->write_type != OS_WRITE_NEW_MARK) &&
4983 !(mtc.mt_op == MTREW || mtc.mt_op == MTOFFL));
4984 i = osst_write_trailer(STp, &SRpnt,
4985 !(mtc.mt_op == MTREW || mtc.mt_op == MTOFFL));
4986 #if DEBUG
4987 printk(KERN_WARNING "%s:D: post trailer xeof=%d,ffp=%d,efp=%d,fsn=%d,lbn=%d,fn=%d,bn=%d\n",
4988 name, auto_weof, STp->first_frame_position, STp->eod_frame_ppos,
4989 STp->frame_seq_number, STp->logical_blk_num, STps->drv_file, STps->drv_block );
4990 #endif
4991 if (i < 0) {
4992 retval = i;
4993 goto out;
4994 }
4995 }
4996 STps->rw = ST_IDLE;
4997 }
4998
4999 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
5000 do_door_lock(STp, 0); /* Ignore result! */
5001
5002 if (mtc.mt_op == MTSETDRVBUFFER &&
5003 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
5004 retval = osst_set_options(STp, mtc.mt_count);
5005 goto out;
5006 }
5007
5008 if (mtc.mt_op == MTSETPART) {
5009 if (mtc.mt_count >= STp->nbr_partitions)
5010 retval = -EINVAL;
5011 else {
5012 STp->new_partition = mtc.mt_count;
5013 retval = 0;
5014 }
5015 goto out;
5016 }
5017
5018 if (mtc.mt_op == MTMKPART) {
5019 if (!STp->can_partitions) {
5020 retval = (-EINVAL);
5021 goto out;
5022 }
5023 if ((i = osst_int_ioctl(STp, &SRpnt, MTREW, 0)) < 0 /*||
5024 (i = partition_tape(inode, mtc.mt_count)) < 0*/) {
5025 retval = i;
5026 goto out;
5027 }
5028 for (i=0; i < ST_NBR_PARTITIONS; i++) {
5029 STp->ps[i].rw = ST_IDLE;
5030 STp->ps[i].at_sm = 0;
5031 STp->ps[i].last_block_valid = 0;
5032 }
5033 STp->partition = STp->new_partition = 0;
5034 STp->nbr_partitions = 1; /* Bad guess ?-) */
5035 STps->drv_block = STps->drv_file = 0;
5036 retval = 0;
5037 goto out;
5038 }
5039
5040 if (mtc.mt_op == MTSEEK) {
5041 if (STp->raw)
5042 i = osst_set_frame_position(STp, &SRpnt, mtc.mt_count, 0);
5043 else
5044 i = osst_seek_sector(STp, &SRpnt, mtc.mt_count);
5045 if (!STp->can_partitions)
5046 STp->ps[0].rw = ST_IDLE;
5047 retval = i;
5048 goto out;
5049 }
5050
5051 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
5052 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
5053 goto out;
5054 }
5055
5056 if (auto_weof)
5057 cross_eof(STp, &SRpnt, 0);
5058
5059 if (mtc.mt_op == MTCOMPRESSION)
5060 retval = -EINVAL; /* OnStream drives don't have compression hardware */
5061 else
5062 /* MTBSF MTBSFM MTBSR MTBSS MTEOM MTERASE MTFSF MTFSFB MTFSR MTFSS
5063 * MTLOAD MTOFFL MTRESET MTRETEN MTREW MTUNLOAD MTWEOF MTWSM */
5064 retval = osst_int_ioctl(STp, &SRpnt, mtc.mt_op, mtc.mt_count);
5065 goto out;
5066 }
5067
5068 if (!STm->defined) {
5069 retval = (-ENXIO);
5070 goto out;
5071 }
5072
5073 if ((i = osst_flush_buffer(STp, &SRpnt, 0)) < 0) {
5074 retval = i;
5075 goto out;
5076 }
5077
5078 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
5079 struct mtget mt_status;
5080
5081 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
5082 retval = (-EINVAL);
5083 goto out;
5084 }
5085
5086 mt_status.mt_type = MT_ISONSTREAM_SC;
5087 mt_status.mt_erreg = STp->recover_erreg << MT_ST_SOFTERR_SHIFT;
5088 mt_status.mt_dsreg =
5089 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
5090 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
5091 mt_status.mt_blkno = STps->drv_block;
5092 mt_status.mt_fileno = STps->drv_file;
5093 if (STp->block_size != 0) {
5094 if (STps->rw == ST_WRITING)
5095 mt_status.mt_blkno += (STp->buffer)->buffer_bytes / STp->block_size;
5096 else if (STps->rw == ST_READING)
5097 mt_status.mt_blkno -= ((STp->buffer)->buffer_bytes +
5098 STp->block_size - 1) / STp->block_size;
5099 }
5100
5101 mt_status.mt_gstat = 0;
5102 if (STp->drv_write_prot)
5103 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
5104 if (mt_status.mt_blkno == 0) {
5105 if (mt_status.mt_fileno == 0)
5106 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
5107 else
5108 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
5109 }
5110 mt_status.mt_resid = STp->partition;
5111 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
5112 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
5113 else if (STps->eof >= ST_EOM_OK)
5114 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
5115 if (STp->density == 1)
5116 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
5117 else if (STp->density == 2)
5118 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
5119 else if (STp->density == 3)
5120 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
5121 if (STp->ready == ST_READY)
5122 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
5123 if (STp->ready == ST_NO_TAPE)
5124 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
5125 if (STps->at_sm)
5126 mt_status.mt_gstat |= GMT_SM(0xffffffff);
5127 if (STm->do_async_writes || (STm->do_buffer_writes && STp->block_size != 0) ||
5128 STp->drv_buffer != 0)
5129 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
5130
5131 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
5132 if (i) {
5133 retval = (-EFAULT);
5134 goto out;
5135 }
5136
5137 STp->recover_erreg = 0; /* Clear after read */
5138 retval = 0;
5139 goto out;
5140 } /* End of MTIOCGET */
5141
5142 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
5143 struct mtpos mt_pos;
5144
5145 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
5146 retval = (-EINVAL);
5147 goto out;
5148 }
5149 if (STp->raw)
5150 blk = osst_get_frame_position(STp, &SRpnt);
5151 else
5152 blk = osst_get_sector(STp, &SRpnt);
5153 if (blk < 0) {
5154 retval = blk;
5155 goto out;
5156 }
5157 mt_pos.mt_blkno = blk;
5158 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
5159 if (i)
5160 retval = -EFAULT;
5161 goto out;
5162 }
5163 if (SRpnt) osst_release_request(SRpnt);
5164
5165 up(&STp->lock);
5166
5167 return scsi_ioctl(STp->device, cmd_in, p);
5168
5169 out:
5170 if (SRpnt) osst_release_request(SRpnt);
5171
5172 up(&STp->lock);
5173
5174 return retval;
5175 }
5176
5177 #ifdef CONFIG_COMPAT
5178 static long osst_compat_ioctl(struct file * file, unsigned int cmd_in, unsigned long arg)
5179 {
5180 struct osst_tape *STp = file->private_data;
5181 struct scsi_device *sdev = STp->device;
5182 int ret = -ENOIOCTLCMD;
5183 if (sdev->host->hostt->compat_ioctl) {
5184
5185 ret = sdev->host->hostt->compat_ioctl(sdev, cmd_in, (void __user *)arg);
5186
5187 }
5188 return ret;
5189 }
5190 #endif
5191
5192
5193 \f
5194 /* Memory handling routines */
5195
5196 /* Try to allocate a new tape buffer skeleton. Caller must not hold os_scsi_tapes_lock */
5197 static struct osst_buffer * new_tape_buffer( int from_initialization, int need_dma, int max_sg )
5198 {
5199 int i;
5200 gfp_t priority;
5201 struct osst_buffer *tb;
5202
5203 if (from_initialization)
5204 priority = GFP_ATOMIC;
5205 else
5206 priority = GFP_KERNEL;
5207
5208 i = sizeof(struct osst_buffer) + (osst_max_sg_segs - 1) * sizeof(struct scatterlist);
5209 tb = (struct osst_buffer *)kmalloc(i, priority);
5210 if (!tb) {
5211 printk(KERN_NOTICE "osst :I: Can't allocate new tape buffer.\n");
5212 return NULL;
5213 }
5214 memset(tb, 0, i);
5215 tb->sg_segs = tb->orig_sg_segs = 0;
5216 tb->use_sg = max_sg;
5217 tb->in_use = 1;
5218 tb->dma = need_dma;
5219 tb->buffer_size = 0;
5220 #if DEBUG
5221 if (debugging)
5222 printk(OSST_DEB_MSG
5223 "osst :D: Allocated tape buffer skeleton (%d bytes, %d segments, dma: %d).\n",
5224 i, max_sg, need_dma);
5225 #endif
5226 return tb;
5227 }
5228
5229 /* Try to allocate a temporary (while a user has the device open) enlarged tape buffer */
5230 static int enlarge_buffer(struct osst_buffer *STbuffer, int need_dma)
5231 {
5232 int segs, nbr, max_segs, b_size, order, got;
5233 gfp_t priority;
5234
5235 if (STbuffer->buffer_size >= OS_FRAME_SIZE)
5236 return 1;
5237
5238 if (STbuffer->sg_segs) {
5239 printk(KERN_WARNING "osst :A: Buffer not previously normalized.\n");
5240 normalize_buffer(STbuffer);
5241 }
5242 /* See how many segments we can use -- need at least two */
5243 nbr = max_segs = STbuffer->use_sg;
5244 if (nbr <= 2)
5245 return 0;
5246
5247 priority = GFP_KERNEL /* | __GFP_NOWARN */;
5248 if (need_dma)
5249 priority |= GFP_DMA;
5250
5251 /* Try to allocate the first segment up to OS_DATA_SIZE and the others
5252 big enough to reach the goal (code assumes no segments in place) */
5253 for (b_size = OS_DATA_SIZE, order = OSST_FIRST_ORDER; b_size >= PAGE_SIZE; order--, b_size /= 2) {
5254 STbuffer->sg[0].page = alloc_pages(priority, order);
5255 STbuffer->sg[0].offset = 0;
5256 if (STbuffer->sg[0].page != NULL) {
5257 STbuffer->sg[0].length = b_size;
5258 STbuffer->b_data = page_address(STbuffer->sg[0].page);
5259 break;
5260 }
5261 }
5262 if (STbuffer->sg[0].page == NULL) {
5263 printk(KERN_NOTICE "osst :I: Can't allocate tape buffer main segment.\n");
5264 return 0;
5265 }
5266 /* Got initial segment of 'bsize,order', continue with same size if possible, except for AUX */
5267 for (segs=STbuffer->sg_segs=1, got=b_size;
5268 segs < max_segs && got < OS_FRAME_SIZE; ) {
5269 STbuffer->sg[segs].page =
5270 alloc_pages(priority, (OS_FRAME_SIZE - got <= PAGE_SIZE) ? 0 : order);
5271 STbuffer->sg[segs].offset = 0;
5272 if (STbuffer->sg[segs].page == NULL) {
5273 if (OS_FRAME_SIZE - got <= (max_segs - segs) * b_size / 2 && order) {
5274 b_size /= 2; /* Large enough for the rest of the buffers */
5275 order--;
5276 continue;
5277 }
5278 printk(KERN_WARNING "osst :W: Failed to enlarge buffer to %d bytes.\n",
5279 OS_FRAME_SIZE);
5280 #if DEBUG
5281 STbuffer->buffer_size = got;
5282 #endif
5283 normalize_buffer(STbuffer);
5284 return 0;
5285 }
5286 STbuffer->sg[segs].length = (OS_FRAME_SIZE - got <= PAGE_SIZE / 2) ? (OS_FRAME_SIZE - got) : b_size;
5287 got += STbuffer->sg[segs].length;
5288 STbuffer->buffer_size = got;
5289 STbuffer->sg_segs = ++segs;
5290 }
5291 #if DEBUG
5292 if (debugging) {
5293 printk(OSST_DEB_MSG
5294 "osst :D: Expanded tape buffer (%d bytes, %d->%d segments, dma: %d, at: %p).\n",
5295 got, STbuffer->orig_sg_segs, STbuffer->sg_segs, need_dma, STbuffer->b_data);
5296 printk(OSST_DEB_MSG
5297 "osst :D: segment sizes: first %d at %p, last %d bytes at %p.\n",
5298 STbuffer->sg[0].length, page_address(STbuffer->sg[0].page),
5299 STbuffer->sg[segs-1].length, page_address(STbuffer->sg[segs-1].page));
5300 }
5301 #endif
5302
5303 return 1;
5304 }
5305
5306
5307 /* Release the segments */
5308 static void normalize_buffer(struct osst_buffer *STbuffer)
5309 {
5310 int i, order, b_size;
5311
5312 for (i=0; i < STbuffer->sg_segs; i++) {
5313
5314 for (b_size = PAGE_SIZE, order = 0;
5315 b_size < STbuffer->sg[i].length;
5316 b_size *= 2, order++);
5317
5318 __free_pages(STbuffer->sg[i].page, order);
5319 STbuffer->buffer_size -= STbuffer->sg[i].length;
5320 }
5321 #if DEBUG
5322 if (debugging && STbuffer->orig_sg_segs < STbuffer->sg_segs)
5323 printk(OSST_DEB_MSG "osst :D: Buffer at %p normalized to %d bytes (segs %d).\n",
5324 STbuffer->b_data, STbuffer->buffer_size, STbuffer->sg_segs);
5325 #endif
5326 STbuffer->sg_segs = STbuffer->orig_sg_segs = 0;
5327 }
5328
5329
5330 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
5331 negative error code. */
5332 static int append_to_buffer(const char __user *ubp, struct osst_buffer *st_bp, int do_count)
5333 {
5334 int i, cnt, res, offset;
5335
5336 for (i=0, offset=st_bp->buffer_bytes;
5337 i < st_bp->sg_segs && offset >= st_bp->sg[i].length; i++)
5338 offset -= st_bp->sg[i].length;
5339 if (i == st_bp->sg_segs) { /* Should never happen */
5340 printk(KERN_WARNING "osst :A: Append_to_buffer offset overflow.\n");
5341 return (-EIO);
5342 }
5343 for ( ; i < st_bp->sg_segs && do_count > 0; i++) {
5344 cnt = st_bp->sg[i].length - offset < do_count ?
5345 st_bp->sg[i].length - offset : do_count;
5346 res = copy_from_user(page_address(st_bp->sg[i].page) + offset, ubp, cnt);
5347 if (res)
5348 return (-EFAULT);
5349 do_count -= cnt;
5350 st_bp->buffer_bytes += cnt;
5351 ubp += cnt;
5352 offset = 0;
5353 }
5354 if (do_count) { /* Should never happen */
5355 printk(KERN_WARNING "osst :A: Append_to_buffer overflow (left %d).\n",
5356 do_count);
5357 return (-EIO);
5358 }
5359 return 0;
5360 }
5361
5362
5363 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
5364 negative error code. */
5365 static int from_buffer(struct osst_buffer *st_bp, char __user *ubp, int do_count)
5366 {
5367 int i, cnt, res, offset;
5368
5369 for (i=0, offset=st_bp->read_pointer;
5370 i < st_bp->sg_segs && offset >= st_bp->sg[i].length; i++)
5371 offset -= st_bp->sg[i].length;
5372 if (i == st_bp->sg_segs) { /* Should never happen */
5373 printk(KERN_WARNING "osst :A: From_buffer offset overflow.\n");
5374 return (-EIO);
5375 }
5376 for ( ; i < st_bp->sg_segs && do_count > 0; i++) {
5377 cnt = st_bp->sg[i].length - offset < do_count ?
5378 st_bp->sg[i].length - offset : do_count;
5379 res = copy_to_user(ubp, page_address(st_bp->sg[i].page) + offset, cnt);
5380 if (res)
5381 return (-EFAULT);
5382 do_count -= cnt;
5383 st_bp->buffer_bytes -= cnt;
5384 st_bp->read_pointer += cnt;
5385 ubp += cnt;
5386 offset = 0;
5387 }
5388 if (do_count) { /* Should never happen */
5389 printk(KERN_WARNING "osst :A: From_buffer overflow (left %d).\n", do_count);
5390 return (-EIO);
5391 }
5392 return 0;
5393 }
5394
5395 /* Sets the tail of the buffer after fill point to zero.
5396 Returns zero (success) or negative error code. */
5397 static int osst_zero_buffer_tail(struct osst_buffer *st_bp)
5398 {
5399 int i, offset, do_count, cnt;
5400
5401 for (i = 0, offset = st_bp->buffer_bytes;
5402 i < st_bp->sg_segs && offset >= st_bp->sg[i].length; i++)
5403 offset -= st_bp->sg[i].length;
5404 if (i == st_bp->sg_segs) { /* Should never happen */
5405 printk(KERN_WARNING "osst :A: Zero_buffer offset overflow.\n");
5406 return (-EIO);
5407 }
5408 for (do_count = OS_DATA_SIZE - st_bp->buffer_bytes;
5409 i < st_bp->sg_segs && do_count > 0; i++) {
5410 cnt = st_bp->sg[i].length - offset < do_count ?
5411 st_bp->sg[i].length - offset : do_count ;
5412 memset(page_address(st_bp->sg[i].page) + offset, 0, cnt);
5413 do_count -= cnt;
5414 offset = 0;
5415 }
5416 if (do_count) { /* Should never happen */
5417 printk(KERN_WARNING "osst :A: Zero_buffer overflow (left %d).\n", do_count);
5418 return (-EIO);
5419 }
5420 return 0;
5421 }
5422
5423 /* Copy a osst 32K chunk of memory into the buffer.
5424 Returns zero (success) or negative error code. */
5425 static int osst_copy_to_buffer(struct osst_buffer *st_bp, unsigned char *ptr)
5426 {
5427 int i, cnt, do_count = OS_DATA_SIZE;
5428
5429 for (i = 0; i < st_bp->sg_segs && do_count > 0; i++) {
5430 cnt = st_bp->sg[i].length < do_count ?
5431 st_bp->sg[i].length : do_count ;
5432 memcpy(page_address(st_bp->sg[i].page), ptr, cnt);
5433 do_count -= cnt;
5434 ptr += cnt;
5435 }
5436 if (do_count || i != st_bp->sg_segs-1) { /* Should never happen */
5437 printk(KERN_WARNING "osst :A: Copy_to_buffer overflow (left %d at sg %d).\n",
5438 do_count, i);
5439 return (-EIO);
5440 }
5441 return 0;
5442 }
5443
5444 /* Copy a osst 32K chunk of memory from the buffer.
5445 Returns zero (success) or negative error code. */
5446 static int osst_copy_from_buffer(struct osst_buffer *st_bp, unsigned char *ptr)
5447 {
5448 int i, cnt, do_count = OS_DATA_SIZE;
5449
5450 for (i = 0; i < st_bp->sg_segs && do_count > 0; i++) {
5451 cnt = st_bp->sg[i].length < do_count ?
5452 st_bp->sg[i].length : do_count ;
5453 memcpy(ptr, page_address(st_bp->sg[i].page), cnt);
5454 do_count -= cnt;
5455 ptr += cnt;
5456 }
5457 if (do_count || i != st_bp->sg_segs-1) { /* Should never happen */
5458 printk(KERN_WARNING "osst :A: Copy_from_buffer overflow (left %d at sg %d).\n",
5459 do_count, i);
5460 return (-EIO);
5461 }
5462 return 0;
5463 }
5464
5465 \f
5466 /* Module housekeeping */
5467
5468 static void validate_options (void)
5469 {
5470 if (max_dev > 0)
5471 osst_max_dev = max_dev;
5472 if (write_threshold_kbs > 0)
5473 osst_write_threshold = write_threshold_kbs * ST_KILOBYTE;
5474 if (osst_write_threshold > osst_buffer_size)
5475 osst_write_threshold = osst_buffer_size;
5476 if (max_sg_segs >= OSST_FIRST_SG)
5477 osst_max_sg_segs = max_sg_segs;
5478 #if DEBUG
5479 printk(OSST_DEB_MSG "osst :D: max tapes %d, write threshold %d, max s/g segs %d.\n",
5480 osst_max_dev, osst_write_threshold, osst_max_sg_segs);
5481 #endif
5482 }
5483
5484 #ifndef MODULE
5485 /* Set the boot options. Syntax: osst=xxx,yyy,...
5486 where xxx is write threshold in 1024 byte blocks,
5487 and yyy is number of s/g segments to use. */
5488 static int __init osst_setup (char *str)
5489 {
5490 int i, ints[5];
5491 char *stp;
5492
5493 stp = get_options(str, ARRAY_SIZE(ints), ints);
5494
5495 if (ints[0] > 0) {
5496 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
5497 *parms[i].val = ints[i + 1];
5498 } else {
5499 while (stp != NULL) {
5500 for (i = 0; i < ARRAY_SIZE(parms); i++) {
5501 int len = strlen(parms[i].name);
5502 if (!strncmp(stp, parms[i].name, len) &&
5503 (*(stp + len) == ':' || *(stp + len) == '=')) {
5504 *parms[i].val =
5505 simple_strtoul(stp + len + 1, NULL, 0);
5506 break;
5507 }
5508 }
5509 if (i >= sizeof(parms) / sizeof(struct osst_dev_parm))
5510 printk(KERN_INFO "osst :I: Illegal parameter in '%s'\n",
5511 stp);
5512 stp = strchr(stp, ',');
5513 if (stp)
5514 stp++;
5515 }
5516 }
5517
5518 return 1;
5519 }
5520
5521 __setup("osst=", osst_setup);
5522
5523 #endif
5524
5525 static struct file_operations osst_fops = {
5526 .owner = THIS_MODULE,
5527 .read = osst_read,
5528 .write = osst_write,
5529 .ioctl = osst_ioctl,
5530 #ifdef CONFIG_COMPAT
5531 .compat_ioctl = osst_compat_ioctl,
5532 #endif
5533 .open = os_scsi_tape_open,
5534 .flush = os_scsi_tape_flush,
5535 .release = os_scsi_tape_close,
5536 };
5537
5538 static int osst_supports(struct scsi_device * SDp)
5539 {
5540 struct osst_support_data {
5541 char *vendor;
5542 char *model;
5543 char *rev;
5544 char *driver_hint; /* Name of the correct driver, NULL if unknown */
5545 };
5546
5547 static struct osst_support_data support_list[] = {
5548 /* {"XXX", "Yy-", "", NULL}, example */
5549 SIGS_FROM_OSST,
5550 {NULL, }};
5551
5552 struct osst_support_data *rp;
5553
5554 /* We are willing to drive OnStream SC-x0 as well as the
5555 * * IDE, ParPort, FireWire, USB variants, if accessible by
5556 * * emulation layer (ide-scsi, usb-storage, ...) */
5557
5558 for (rp=&(support_list[0]); rp->vendor != NULL; rp++)
5559 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
5560 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
5561 !strncmp(rp->rev, SDp->rev, strlen(rp->rev)))
5562 return 1;
5563 return 0;
5564 }
5565
5566 /*
5567 * sysfs support for osst driver parameter information
5568 */
5569
5570 static ssize_t osst_version_show(struct device_driver *ddd, char *buf)
5571 {
5572 return snprintf(buf, PAGE_SIZE, "%s\n", osst_version);
5573 }
5574
5575 static DRIVER_ATTR(version, S_IRUGO, osst_version_show, NULL);
5576
5577 static void osst_create_driverfs_files(struct device_driver *driverfs)
5578 {
5579 driver_create_file(driverfs, &driver_attr_version);
5580 }
5581
5582 static void osst_remove_driverfs_files(struct device_driver *driverfs)
5583 {
5584 driver_remove_file(driverfs, &driver_attr_version);
5585 }
5586
5587 /*
5588 * sysfs support for accessing ADR header information
5589 */
5590
5591 static ssize_t osst_adr_rev_show(struct class_device *class_dev, char *buf)
5592 {
5593 struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
5594 ssize_t l = 0;
5595
5596 if (STp && STp->header_ok && STp->linux_media)
5597 l = snprintf(buf, PAGE_SIZE, "%d.%d\n", STp->header_cache->major_rev, STp->header_cache->minor_rev);
5598 return l;
5599 }
5600
5601 CLASS_DEVICE_ATTR(ADR_rev, S_IRUGO, osst_adr_rev_show, NULL);
5602
5603 static ssize_t osst_linux_media_version_show(struct class_device *class_dev, char *buf)
5604 {
5605 struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
5606 ssize_t l = 0;
5607
5608 if (STp && STp->header_ok && STp->linux_media)
5609 l = snprintf(buf, PAGE_SIZE, "LIN%d\n", STp->linux_media_version);
5610 return l;
5611 }
5612
5613 CLASS_DEVICE_ATTR(media_version, S_IRUGO, osst_linux_media_version_show, NULL);
5614
5615 static ssize_t osst_capacity_show(struct class_device *class_dev, char *buf)
5616 {
5617 struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
5618 ssize_t l = 0;
5619
5620 if (STp && STp->header_ok && STp->linux_media)
5621 l = snprintf(buf, PAGE_SIZE, "%d\n", STp->capacity);
5622 return l;
5623 }
5624
5625 CLASS_DEVICE_ATTR(capacity, S_IRUGO, osst_capacity_show, NULL);
5626
5627 static ssize_t osst_first_data_ppos_show(struct class_device *class_dev, char *buf)
5628 {
5629 struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
5630 ssize_t l = 0;
5631
5632 if (STp && STp->header_ok && STp->linux_media)
5633 l = snprintf(buf, PAGE_SIZE, "%d\n", STp->first_data_ppos);
5634 return l;
5635 }
5636
5637 CLASS_DEVICE_ATTR(BOT_frame, S_IRUGO, osst_first_data_ppos_show, NULL);
5638
5639 static ssize_t osst_eod_frame_ppos_show(struct class_device *class_dev, char *buf)
5640 {
5641 struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
5642 ssize_t l = 0;
5643
5644 if (STp && STp->header_ok && STp->linux_media)
5645 l = snprintf(buf, PAGE_SIZE, "%d\n", STp->eod_frame_ppos);
5646 return l;
5647 }
5648
5649 CLASS_DEVICE_ATTR(EOD_frame, S_IRUGO, osst_eod_frame_ppos_show, NULL);
5650
5651 static ssize_t osst_filemark_cnt_show(struct class_device *class_dev, char *buf)
5652 {
5653 struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
5654 ssize_t l = 0;
5655
5656 if (STp && STp->header_ok && STp->linux_media)
5657 l = snprintf(buf, PAGE_SIZE, "%d\n", STp->filemark_cnt);
5658 return l;
5659 }
5660
5661 CLASS_DEVICE_ATTR(file_count, S_IRUGO, osst_filemark_cnt_show, NULL);
5662
5663 static struct class *osst_sysfs_class;
5664
5665 static int osst_sysfs_valid = 0;
5666
5667 static void osst_sysfs_init(void)
5668 {
5669 osst_sysfs_class = class_create(THIS_MODULE, "onstream_tape");
5670 if ( IS_ERR(osst_sysfs_class) )
5671 printk(KERN_WARNING "osst :W: Unable to register sysfs class\n");
5672 else
5673 osst_sysfs_valid = 1;
5674 }
5675
5676 static void osst_sysfs_add(dev_t dev, struct device *device, struct osst_tape * STp, char * name)
5677 {
5678 struct class_device *osst_class_member;
5679
5680 if (!osst_sysfs_valid) return;
5681
5682 osst_class_member = class_device_create(osst_sysfs_class, NULL, dev, device, "%s", name);
5683 if (IS_ERR(osst_class_member)) {
5684 printk(KERN_WARNING "osst :W: Unable to add sysfs class member %s\n", name);
5685 return;
5686 }
5687 class_set_devdata(osst_class_member, STp);
5688 class_device_create_file(osst_class_member, &class_device_attr_ADR_rev);
5689 class_device_create_file(osst_class_member, &class_device_attr_media_version);
5690 class_device_create_file(osst_class_member, &class_device_attr_capacity);
5691 class_device_create_file(osst_class_member, &class_device_attr_BOT_frame);
5692 class_device_create_file(osst_class_member, &class_device_attr_EOD_frame);
5693 class_device_create_file(osst_class_member, &class_device_attr_file_count);
5694 }
5695
5696 static void osst_sysfs_destroy(dev_t dev)
5697 {
5698 if (!osst_sysfs_valid) return;
5699
5700 class_device_destroy(osst_sysfs_class, dev);
5701 }
5702
5703 static void osst_sysfs_cleanup(void)
5704 {
5705 if (osst_sysfs_valid) {
5706 class_destroy(osst_sysfs_class);
5707 osst_sysfs_valid = 0;
5708 }
5709 }
5710
5711 /*
5712 * osst startup / cleanup code
5713 */
5714
5715 static int osst_probe(struct device *dev)
5716 {
5717 struct scsi_device * SDp = to_scsi_device(dev);
5718 struct osst_tape * tpnt;
5719 struct st_modedef * STm;
5720 struct st_partstat * STps;
5721 struct osst_buffer * buffer;
5722 struct gendisk * drive;
5723 int i, dev_num;
5724
5725 if (SDp->type != TYPE_TAPE || !osst_supports(SDp))
5726 return -ENODEV;
5727
5728 drive = alloc_disk(1);
5729 if (!drive) {
5730 printk(KERN_ERR "osst :E: Out of memory. Device not attached.\n");
5731 return -ENODEV;
5732 }
5733
5734 /* if this is the first attach, build the infrastructure */
5735 write_lock(&os_scsi_tapes_lock);
5736 if (os_scsi_tapes == NULL) {
5737 os_scsi_tapes =
5738 (struct osst_tape **)kmalloc(osst_max_dev * sizeof(struct osst_tape *),
5739 GFP_ATOMIC);
5740 if (os_scsi_tapes == NULL) {
5741 write_unlock(&os_scsi_tapes_lock);
5742 printk(KERN_ERR "osst :E: Unable to allocate array for OnStream SCSI tapes.\n");
5743 goto out_put_disk;
5744 }
5745 for (i=0; i < osst_max_dev; ++i) os_scsi_tapes[i] = NULL;
5746 }
5747
5748 if (osst_nr_dev >= osst_max_dev) {
5749 write_unlock(&os_scsi_tapes_lock);
5750 printk(KERN_ERR "osst :E: Too many tape devices (max. %d).\n", osst_max_dev);
5751 goto out_put_disk;
5752 }
5753
5754 /* find a free minor number */
5755 for (i=0; os_scsi_tapes[i] && i<osst_max_dev; i++);
5756 if(i >= osst_max_dev) panic ("Scsi_devices corrupt (osst)");
5757 dev_num = i;
5758
5759 /* allocate a struct osst_tape for this device */
5760 tpnt = (struct osst_tape *)kmalloc(sizeof(struct osst_tape), GFP_ATOMIC);
5761 if (tpnt == NULL) {
5762 write_unlock(&os_scsi_tapes_lock);
5763 printk(KERN_ERR "osst :E: Can't allocate device descriptor, device not attached.\n");
5764 goto out_put_disk;
5765 }
5766 memset(tpnt, 0, sizeof(struct osst_tape));
5767
5768 /* allocate a buffer for this device */
5769 i = SDp->host->sg_tablesize;
5770 if (osst_max_sg_segs < i)
5771 i = osst_max_sg_segs;
5772 buffer = new_tape_buffer(1, SDp->host->unchecked_isa_dma, i);
5773 if (buffer == NULL) {
5774 write_unlock(&os_scsi_tapes_lock);
5775 printk(KERN_ERR "osst :E: Unable to allocate a tape buffer, device not attached.\n");
5776 kfree(tpnt);
5777 goto out_put_disk;
5778 }
5779 os_scsi_tapes[dev_num] = tpnt;
5780 tpnt->buffer = buffer;
5781 tpnt->device = SDp;
5782 drive->private_data = &tpnt->driver;
5783 sprintf(drive->disk_name, "osst%d", dev_num);
5784 tpnt->driver = &osst_template;
5785 tpnt->drive = drive;
5786 tpnt->in_use = 0;
5787 tpnt->capacity = 0xfffff;
5788 tpnt->dirty = 0;
5789 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
5790 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
5791 tpnt->density = 0;
5792 tpnt->do_auto_lock = OSST_AUTO_LOCK;
5793 tpnt->can_bsr = OSST_IN_FILE_POS;
5794 tpnt->can_partitions = 0;
5795 tpnt->two_fm = OSST_TWO_FM;
5796 tpnt->fast_mteom = OSST_FAST_MTEOM;
5797 tpnt->scsi2_logical = OSST_SCSI2LOGICAL; /* FIXME */
5798 tpnt->write_threshold = osst_write_threshold;
5799 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
5800 tpnt->partition = 0;
5801 tpnt->new_partition = 0;
5802 tpnt->nbr_partitions = 0;
5803 tpnt->min_block = 512;
5804 tpnt->max_block = OS_DATA_SIZE;
5805 tpnt->timeout = OSST_TIMEOUT;
5806 tpnt->long_timeout = OSST_LONG_TIMEOUT;
5807
5808 /* Recognize OnStream tapes */
5809 /* We don't need to test for OnStream, as this has been done in detect () */
5810 tpnt->os_fw_rev = osst_parse_firmware_rev (SDp->rev);
5811 tpnt->omit_blklims = 1;
5812
5813 tpnt->poll = (strncmp(SDp->model, "DI-", 3) == 0) ||
5814 (strncmp(SDp->model, "FW-", 3) == 0) || OSST_FW_NEED_POLL(tpnt->os_fw_rev,SDp);
5815 tpnt->frame_in_buffer = 0;
5816 tpnt->header_ok = 0;
5817 tpnt->linux_media = 0;
5818 tpnt->header_cache = NULL;
5819
5820 for (i=0; i < ST_NBR_MODES; i++) {
5821 STm = &(tpnt->modes[i]);
5822 STm->defined = 0;
5823 STm->sysv = OSST_SYSV;
5824 STm->defaults_for_writes = 0;
5825 STm->do_async_writes = OSST_ASYNC_WRITES;
5826 STm->do_buffer_writes = OSST_BUFFER_WRITES;
5827 STm->do_read_ahead = OSST_READ_AHEAD;
5828 STm->default_compression = ST_DONT_TOUCH;
5829 STm->default_blksize = 512;
5830 STm->default_density = (-1); /* No forced density */
5831 }
5832
5833 for (i=0; i < ST_NBR_PARTITIONS; i++) {
5834 STps = &(tpnt->ps[i]);
5835 STps->rw = ST_IDLE;
5836 STps->eof = ST_NOEOF;
5837 STps->at_sm = 0;
5838 STps->last_block_valid = 0;
5839 STps->drv_block = (-1);
5840 STps->drv_file = (-1);
5841 }
5842
5843 tpnt->current_mode = 0;
5844 tpnt->modes[0].defined = 1;
5845 tpnt->modes[2].defined = 1;
5846 tpnt->density_changed = tpnt->compression_changed = tpnt->blksize_changed = 0;
5847
5848 init_MUTEX(&tpnt->lock);
5849 osst_nr_dev++;
5850 write_unlock(&os_scsi_tapes_lock);
5851 {
5852 char name[8];
5853 /* Rewind entry */
5854 osst_sysfs_add(MKDEV(OSST_MAJOR, dev_num), dev, tpnt, tape_name(tpnt));
5855 /* No-rewind entry */
5856 snprintf(name, 8, "%s%s", "n", tape_name(tpnt));
5857 osst_sysfs_add(MKDEV(OSST_MAJOR, dev_num + 128), dev, tpnt, name);
5858 }
5859
5860 sdev_printk(KERN_INFO, SDp,
5861 "osst :I: Attached OnStream %.5s tape as %s\n",
5862 SDp->model, tape_name(tpnt));
5863
5864 return 0;
5865
5866 out_put_disk:
5867 put_disk(drive);
5868 return -ENODEV;
5869 };
5870
5871 static int osst_remove(struct device *dev)
5872 {
5873 struct scsi_device * SDp = to_scsi_device(dev);
5874 struct osst_tape * tpnt;
5875 int i;
5876
5877 if ((SDp->type != TYPE_TAPE) || (osst_nr_dev <= 0))
5878 return 0;
5879
5880 write_lock(&os_scsi_tapes_lock);
5881 for(i=0; i < osst_max_dev; i++) {
5882 if((tpnt = os_scsi_tapes[i]) && (tpnt->device == SDp)) {
5883 osst_sysfs_destroy(MKDEV(OSST_MAJOR, i));
5884 osst_sysfs_destroy(MKDEV(OSST_MAJOR, i+128));
5885 tpnt->device = NULL;
5886 put_disk(tpnt->drive);
5887 os_scsi_tapes[i] = NULL;
5888 osst_nr_dev--;
5889 write_unlock(&os_scsi_tapes_lock);
5890 vfree(tpnt->header_cache);
5891 if (tpnt->buffer) {
5892 normalize_buffer(tpnt->buffer);
5893 kfree(tpnt->buffer);
5894 }
5895 kfree(tpnt);
5896 return 0;
5897 }
5898 }
5899 write_unlock(&os_scsi_tapes_lock);
5900 return 0;
5901 }
5902
5903 static int __init init_osst(void)
5904 {
5905 printk(KERN_INFO "osst :I: Tape driver with OnStream support version %s\nosst :I: %s\n", osst_version, cvsid);
5906
5907 validate_options();
5908 osst_sysfs_init();
5909
5910 if ((register_chrdev(OSST_MAJOR,"osst", &osst_fops) < 0) || scsi_register_driver(&osst_template.gendrv)) {
5911 printk(KERN_ERR "osst :E: Unable to register major %d for OnStream tapes\n", OSST_MAJOR);
5912 osst_sysfs_cleanup();
5913 return 1;
5914 }
5915 osst_create_driverfs_files(&osst_template.gendrv);
5916
5917 return 0;
5918 }
5919
5920 static void __exit exit_osst (void)
5921 {
5922 int i;
5923 struct osst_tape * STp;
5924
5925 osst_remove_driverfs_files(&osst_template.gendrv);
5926 scsi_unregister_driver(&osst_template.gendrv);
5927 unregister_chrdev(OSST_MAJOR, "osst");
5928 osst_sysfs_cleanup();
5929
5930 if (os_scsi_tapes) {
5931 for (i=0; i < osst_max_dev; ++i) {
5932 if (!(STp = os_scsi_tapes[i])) continue;
5933 /* This is defensive, supposed to happen during detach */
5934 vfree(STp->header_cache);
5935 if (STp->buffer) {
5936 normalize_buffer(STp->buffer);
5937 kfree(STp->buffer);
5938 }
5939 put_disk(STp->drive);
5940 kfree(STp);
5941 }
5942 kfree(os_scsi_tapes);
5943 }
5944 printk(KERN_INFO "osst :I: Unloaded.\n");
5945 }
5946
5947 module_init(init_osst);
5948 module_exit(exit_osst);
Community contributions to the Openmoko Kernel