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