]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/s390/char/tape_std.c
1 // SPDX-License-Identifier: GPL-2.0
3 * standard tape device functions for ibm tapes.
5 * S390 and zSeries version
6 * Copyright IBM Corp. 2001, 2002
7 * Author(s): Carsten Otte <cotte@de.ibm.com>
8 * Michael Holzheu <holzheu@de.ibm.com>
9 * Tuan Ngo-Anh <ngoanh@de.ibm.com>
10 * Martin Schwidefsky <schwidefsky@de.ibm.com>
11 * Stefan Bader <shbader@de.ibm.com>
14 #define KMSG_COMPONENT "tape"
15 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
17 #include <linux/stddef.h>
18 #include <linux/kernel.h>
19 #include <linux/bio.h>
20 #include <linux/timer.h>
22 #include <asm/types.h>
23 #include <asm/idals.h>
24 #include <asm/ebcdic.h>
25 #include <asm/tape390.h>
27 #define TAPE_DBF_AREA tape_core_dbf
36 tape_std_assign_timeout(unsigned long data
)
38 struct tape_request
* request
;
39 struct tape_device
* device
;
42 request
= (struct tape_request
*) data
;
43 device
= request
->device
;
46 DBF_EVENT(3, "%08x: Assignment timeout. Device busy.\n",
48 rc
= tape_cancel_io(device
, request
);
50 DBF_EVENT(3, "(%08x): Assign timeout: Cancel failed with rc = "
51 "%i\n", device
->cdev_id
, rc
);
55 tape_std_assign(struct tape_device
*device
)
58 struct timer_list timeout
;
59 struct tape_request
*request
;
61 request
= tape_alloc_request(2, 11);
63 return PTR_ERR(request
);
65 request
->op
= TO_ASSIGN
;
66 tape_ccw_cc(request
->cpaddr
, ASSIGN
, 11, request
->cpdata
);
67 tape_ccw_end(request
->cpaddr
+ 1, NOP
, 0, NULL
);
70 * The assign command sometimes blocks if the device is assigned
71 * to another host (actually this shouldn't happen but it does).
72 * So we set up a timeout for this call.
74 init_timer_on_stack(&timeout
);
75 timeout
.function
= tape_std_assign_timeout
;
76 timeout
.data
= (unsigned long) request
;
77 timeout
.expires
= jiffies
+ 2 * HZ
;
80 rc
= tape_do_io_interruptible(device
, request
);
82 del_timer_sync(&timeout
);
83 destroy_timer_on_stack(&timeout
);
86 DBF_EVENT(3, "%08x: assign failed - device might be busy\n",
89 DBF_EVENT(3, "%08x: Tape assigned\n", device
->cdev_id
);
91 tape_free_request(request
);
99 tape_std_unassign (struct tape_device
*device
)
102 struct tape_request
*request
;
104 if (device
->tape_state
== TS_NOT_OPER
) {
105 DBF_EVENT(3, "(%08x): Can't unassign device\n",
110 request
= tape_alloc_request(2, 11);
112 return PTR_ERR(request
);
114 request
->op
= TO_UNASSIGN
;
115 tape_ccw_cc(request
->cpaddr
, UNASSIGN
, 11, request
->cpdata
);
116 tape_ccw_end(request
->cpaddr
+ 1, NOP
, 0, NULL
);
118 if ((rc
= tape_do_io(device
, request
)) != 0) {
119 DBF_EVENT(3, "%08x: Unassign failed\n", device
->cdev_id
);
121 DBF_EVENT(3, "%08x: Tape unassigned\n", device
->cdev_id
);
123 tape_free_request(request
);
128 * TAPE390_DISPLAY: Show a string on the tape display.
131 tape_std_display(struct tape_device
*device
, struct display_struct
*disp
)
133 struct tape_request
*request
;
136 request
= tape_alloc_request(2, 17);
137 if (IS_ERR(request
)) {
138 DBF_EVENT(3, "TAPE: load display failed\n");
139 return PTR_ERR(request
);
141 request
->op
= TO_DIS
;
143 *(unsigned char *) request
->cpdata
= disp
->cntrl
;
144 DBF_EVENT(5, "TAPE: display cntrl=%04x\n", disp
->cntrl
);
145 memcpy(((unsigned char *) request
->cpdata
) + 1, disp
->message1
, 8);
146 memcpy(((unsigned char *) request
->cpdata
) + 9, disp
->message2
, 8);
147 ASCEBC(((unsigned char*) request
->cpdata
) + 1, 16);
149 tape_ccw_cc(request
->cpaddr
, LOAD_DISPLAY
, 17, request
->cpdata
);
150 tape_ccw_end(request
->cpaddr
+ 1, NOP
, 0, NULL
);
152 rc
= tape_do_io_interruptible(device
, request
);
153 tape_free_request(request
);
161 tape_std_read_block_id(struct tape_device
*device
, __u64
*id
)
163 struct tape_request
*request
;
166 request
= tape_alloc_request(3, 8);
168 return PTR_ERR(request
);
169 request
->op
= TO_RBI
;
171 tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1, device
->modeset_byte
);
172 tape_ccw_cc(request
->cpaddr
+ 1, READ_BLOCK_ID
, 8, request
->cpdata
);
173 tape_ccw_end(request
->cpaddr
+ 2, NOP
, 0, NULL
);
175 rc
= tape_do_io(device
, request
);
177 /* Get result from read buffer. */
178 *id
= *(__u64
*) request
->cpdata
;
179 tape_free_request(request
);
184 tape_std_terminate_write(struct tape_device
*device
)
188 if(device
->required_tapemarks
== 0)
191 DBF_LH(5, "tape%d: terminate write %dxEOF\n", device
->first_minor
,
192 device
->required_tapemarks
);
194 rc
= tape_mtop(device
, MTWEOF
, device
->required_tapemarks
);
198 device
->required_tapemarks
= 0;
199 return tape_mtop(device
, MTBSR
, 1);
203 * MTLOAD: Loads the tape.
204 * The default implementation just wait until the tape medium state changes
208 tape_std_mtload(struct tape_device
*device
, int count
)
210 return wait_event_interruptible(device
->state_change_wq
,
211 (device
->medium_state
== MS_LOADED
));
215 * MTSETBLK: Set block size.
218 tape_std_mtsetblk(struct tape_device
*device
, int count
)
220 struct idal_buffer
*new;
222 DBF_LH(6, "tape_std_mtsetblk(%d)\n", count
);
225 * Just set block_size to 0. tapechar_read/tapechar_write
226 * will realloc the idal buffer if a bigger one than the
229 device
->char_data
.block_size
= 0;
232 if (device
->char_data
.idal_buf
!= NULL
&&
233 device
->char_data
.idal_buf
->size
== count
)
234 /* We already have a idal buffer of that size. */
237 if (count
> MAX_BLOCKSIZE
) {
238 DBF_EVENT(3, "Invalid block size (%d > %d) given.\n",
239 count
, MAX_BLOCKSIZE
);
243 /* Allocate a new idal buffer. */
244 new = idal_buffer_alloc(count
, 0);
247 if (device
->char_data
.idal_buf
!= NULL
)
248 idal_buffer_free(device
->char_data
.idal_buf
);
249 device
->char_data
.idal_buf
= new;
250 device
->char_data
.block_size
= count
;
252 DBF_LH(6, "new blocksize is %d\n", device
->char_data
.block_size
);
258 * MTRESET: Set block size to 0.
261 tape_std_mtreset(struct tape_device
*device
, int count
)
263 DBF_EVENT(6, "TCHAR:devreset:\n");
264 device
->char_data
.block_size
= 0;
269 * MTFSF: Forward space over 'count' file marks. The tape is positioned
270 * at the EOT (End of Tape) side of the file mark.
273 tape_std_mtfsf(struct tape_device
*device
, int mt_count
)
275 struct tape_request
*request
;
278 request
= tape_alloc_request(mt_count
+ 2, 0);
280 return PTR_ERR(request
);
281 request
->op
= TO_FSF
;
283 ccw
= tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1,
284 device
->modeset_byte
);
285 ccw
= tape_ccw_repeat(ccw
, FORSPACEFILE
, mt_count
);
286 ccw
= tape_ccw_end(ccw
, NOP
, 0, NULL
);
289 return tape_do_io_free(device
, request
);
293 * MTFSR: Forward space over 'count' tape blocks (blocksize is set
297 tape_std_mtfsr(struct tape_device
*device
, int mt_count
)
299 struct tape_request
*request
;
303 request
= tape_alloc_request(mt_count
+ 2, 0);
305 return PTR_ERR(request
);
306 request
->op
= TO_FSB
;
308 ccw
= tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1,
309 device
->modeset_byte
);
310 ccw
= tape_ccw_repeat(ccw
, FORSPACEBLOCK
, mt_count
);
311 ccw
= tape_ccw_end(ccw
, NOP
, 0, NULL
);
314 rc
= tape_do_io(device
, request
);
315 if (rc
== 0 && request
->rescnt
> 0) {
316 DBF_LH(3, "FSR over tapemark\n");
319 tape_free_request(request
);
325 * MTBSR: Backward space over 'count' tape blocks.
326 * (blocksize is set via MTSETBLK.
329 tape_std_mtbsr(struct tape_device
*device
, int mt_count
)
331 struct tape_request
*request
;
335 request
= tape_alloc_request(mt_count
+ 2, 0);
337 return PTR_ERR(request
);
338 request
->op
= TO_BSB
;
340 ccw
= tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1,
341 device
->modeset_byte
);
342 ccw
= tape_ccw_repeat(ccw
, BACKSPACEBLOCK
, mt_count
);
343 ccw
= tape_ccw_end(ccw
, NOP
, 0, NULL
);
346 rc
= tape_do_io(device
, request
);
347 if (rc
== 0 && request
->rescnt
> 0) {
348 DBF_LH(3, "BSR over tapemark\n");
351 tape_free_request(request
);
357 * MTWEOF: Write 'count' file marks at the current position.
360 tape_std_mtweof(struct tape_device
*device
, int mt_count
)
362 struct tape_request
*request
;
365 request
= tape_alloc_request(mt_count
+ 2, 0);
367 return PTR_ERR(request
);
368 request
->op
= TO_WTM
;
370 ccw
= tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1,
371 device
->modeset_byte
);
372 ccw
= tape_ccw_repeat(ccw
, WRITETAPEMARK
, mt_count
);
373 ccw
= tape_ccw_end(ccw
, NOP
, 0, NULL
);
376 return tape_do_io_free(device
, request
);
380 * MTBSFM: Backward space over 'count' file marks.
381 * The tape is positioned at the BOT (Begin Of Tape) side of the
382 * last skipped file mark.
385 tape_std_mtbsfm(struct tape_device
*device
, int mt_count
)
387 struct tape_request
*request
;
390 request
= tape_alloc_request(mt_count
+ 2, 0);
392 return PTR_ERR(request
);
393 request
->op
= TO_BSF
;
395 ccw
= tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1,
396 device
->modeset_byte
);
397 ccw
= tape_ccw_repeat(ccw
, BACKSPACEFILE
, mt_count
);
398 ccw
= tape_ccw_end(ccw
, NOP
, 0, NULL
);
401 return tape_do_io_free(device
, request
);
405 * MTBSF: Backward space over 'count' file marks. The tape is positioned at
406 * the EOT (End of Tape) side of the last skipped file mark.
409 tape_std_mtbsf(struct tape_device
*device
, int mt_count
)
411 struct tape_request
*request
;
415 request
= tape_alloc_request(mt_count
+ 2, 0);
417 return PTR_ERR(request
);
418 request
->op
= TO_BSF
;
420 ccw
= tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1,
421 device
->modeset_byte
);
422 ccw
= tape_ccw_repeat(ccw
, BACKSPACEFILE
, mt_count
);
423 ccw
= tape_ccw_end(ccw
, NOP
, 0, NULL
);
425 rc
= tape_do_io_free(device
, request
);
427 rc
= tape_mtop(device
, MTFSR
, 1);
435 * MTFSFM: Forward space over 'count' file marks.
436 * The tape is positioned at the BOT (Begin Of Tape) side
437 * of the last skipped file mark.
440 tape_std_mtfsfm(struct tape_device
*device
, int mt_count
)
442 struct tape_request
*request
;
446 request
= tape_alloc_request(mt_count
+ 2, 0);
448 return PTR_ERR(request
);
449 request
->op
= TO_FSF
;
451 ccw
= tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1,
452 device
->modeset_byte
);
453 ccw
= tape_ccw_repeat(ccw
, FORSPACEFILE
, mt_count
);
454 ccw
= tape_ccw_end(ccw
, NOP
, 0, NULL
);
456 rc
= tape_do_io_free(device
, request
);
458 rc
= tape_mtop(device
, MTBSR
, 1);
467 * MTREW: Rewind the tape.
470 tape_std_mtrew(struct tape_device
*device
, int mt_count
)
472 struct tape_request
*request
;
474 request
= tape_alloc_request(3, 0);
476 return PTR_ERR(request
);
477 request
->op
= TO_REW
;
479 tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1,
480 device
->modeset_byte
);
481 tape_ccw_cc(request
->cpaddr
+ 1, REWIND
, 0, NULL
);
482 tape_ccw_end(request
->cpaddr
+ 2, NOP
, 0, NULL
);
485 return tape_do_io_free(device
, request
);
489 * MTOFFL: Rewind the tape and put the drive off-line.
490 * Implement 'rewind unload'
493 tape_std_mtoffl(struct tape_device
*device
, int mt_count
)
495 struct tape_request
*request
;
497 request
= tape_alloc_request(3, 0);
499 return PTR_ERR(request
);
500 request
->op
= TO_RUN
;
502 tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1, device
->modeset_byte
);
503 tape_ccw_cc(request
->cpaddr
+ 1, REWIND_UNLOAD
, 0, NULL
);
504 tape_ccw_end(request
->cpaddr
+ 2, NOP
, 0, NULL
);
507 return tape_do_io_free(device
, request
);
511 * MTNOP: 'No operation'.
514 tape_std_mtnop(struct tape_device
*device
, int mt_count
)
516 struct tape_request
*request
;
518 request
= tape_alloc_request(2, 0);
520 return PTR_ERR(request
);
521 request
->op
= TO_NOP
;
523 tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1, device
->modeset_byte
);
524 tape_ccw_end(request
->cpaddr
+ 1, NOP
, 0, NULL
);
526 return tape_do_io_free(device
, request
);
530 * MTEOM: positions at the end of the portion of the tape already used
531 * for recordind data. MTEOM positions after the last file mark, ready for
532 * appending another file.
535 tape_std_mteom(struct tape_device
*device
, int mt_count
)
540 * Seek from the beginning of tape (rewind).
542 if ((rc
= tape_mtop(device
, MTREW
, 1)) < 0)
546 * The logical end of volume is given by two sewuential tapemarks.
547 * Look for this by skipping to the next file (over one tapemark)
548 * and then test for another one (fsr returns 1 if a tapemark was
552 if ((rc
= tape_mtop(device
, MTFSF
, 1)) < 0)
554 if ((rc
= tape_mtop(device
, MTFSR
, 1)) < 0)
558 return tape_mtop(device
, MTBSR
, 1);
562 * MTRETEN: Retension the tape, i.e. forward space to end of tape and rewind.
565 tape_std_mtreten(struct tape_device
*device
, int mt_count
)
567 struct tape_request
*request
;
569 request
= tape_alloc_request(4, 0);
571 return PTR_ERR(request
);
572 request
->op
= TO_FSF
;
574 tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1, device
->modeset_byte
);
575 tape_ccw_cc(request
->cpaddr
+ 1,FORSPACEFILE
, 0, NULL
);
576 tape_ccw_cc(request
->cpaddr
+ 2, NOP
, 0, NULL
);
577 tape_ccw_end(request
->cpaddr
+ 3, CCW_CMD_TIC
, 0, request
->cpaddr
);
578 /* execute it, MTRETEN rc gets ignored */
579 tape_do_io_interruptible(device
, request
);
580 tape_free_request(request
);
581 return tape_mtop(device
, MTREW
, 1);
585 * MTERASE: erases the tape.
588 tape_std_mterase(struct tape_device
*device
, int mt_count
)
590 struct tape_request
*request
;
592 request
= tape_alloc_request(6, 0);
594 return PTR_ERR(request
);
595 request
->op
= TO_DSE
;
597 tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1, device
->modeset_byte
);
598 tape_ccw_cc(request
->cpaddr
+ 1, REWIND
, 0, NULL
);
599 tape_ccw_cc(request
->cpaddr
+ 2, ERASE_GAP
, 0, NULL
);
600 tape_ccw_cc(request
->cpaddr
+ 3, DATA_SEC_ERASE
, 0, NULL
);
601 tape_ccw_cc(request
->cpaddr
+ 4, REWIND
, 0, NULL
);
602 tape_ccw_end(request
->cpaddr
+ 5, NOP
, 0, NULL
);
605 return tape_do_io_free(device
, request
);
609 * MTUNLOAD: Rewind the tape and unload it.
612 tape_std_mtunload(struct tape_device
*device
, int mt_count
)
614 return tape_mtop(device
, MTOFFL
, mt_count
);
618 * MTCOMPRESSION: used to enable compression.
619 * Sets the IDRC on/off.
622 tape_std_mtcompression(struct tape_device
*device
, int mt_count
)
624 struct tape_request
*request
;
626 if (mt_count
< 0 || mt_count
> 1) {
627 DBF_EXCEPTION(6, "xcom parm\n");
630 request
= tape_alloc_request(2, 0);
632 return PTR_ERR(request
);
633 request
->op
= TO_NOP
;
636 *device
->modeset_byte
&= ~0x08;
638 *device
->modeset_byte
|= 0x08;
639 tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1, device
->modeset_byte
);
640 tape_ccw_end(request
->cpaddr
+ 1, NOP
, 0, NULL
);
642 return tape_do_io_free(device
, request
);
648 struct tape_request
*
649 tape_std_read_block(struct tape_device
*device
, size_t count
)
651 struct tape_request
*request
;
654 * We have to alloc 4 ccws in order to be able to transform request
655 * into a read backward request in error case.
657 request
= tape_alloc_request(4, 0);
658 if (IS_ERR(request
)) {
659 DBF_EXCEPTION(6, "xrbl fail");
662 request
->op
= TO_RFO
;
663 tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1, device
->modeset_byte
);
664 tape_ccw_end_idal(request
->cpaddr
+ 1, READ_FORWARD
,
665 device
->char_data
.idal_buf
);
666 DBF_EVENT(6, "xrbl ccwg\n");
671 * Read Block backward transformation function.
674 tape_std_read_backward(struct tape_device
*device
, struct tape_request
*request
)
677 * We have allocated 4 ccws in tape_std_read, so we can now
678 * transform the request to a read backward, followed by a
679 * forward space block.
681 request
->op
= TO_RBA
;
682 tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1, device
->modeset_byte
);
683 tape_ccw_cc_idal(request
->cpaddr
+ 1, READ_BACKWARD
,
684 device
->char_data
.idal_buf
);
685 tape_ccw_cc(request
->cpaddr
+ 2, FORSPACEBLOCK
, 0, NULL
);
686 tape_ccw_end(request
->cpaddr
+ 3, NOP
, 0, NULL
);
687 DBF_EVENT(6, "xrop ccwg");}
692 struct tape_request
*
693 tape_std_write_block(struct tape_device
*device
, size_t count
)
695 struct tape_request
*request
;
697 request
= tape_alloc_request(2, 0);
698 if (IS_ERR(request
)) {
699 DBF_EXCEPTION(6, "xwbl fail\n");
702 request
->op
= TO_WRI
;
703 tape_ccw_cc(request
->cpaddr
, MODE_SET_DB
, 1, device
->modeset_byte
);
704 tape_ccw_end_idal(request
->cpaddr
+ 1, WRITE_CMD
,
705 device
->char_data
.idal_buf
);
706 DBF_EVENT(6, "xwbl ccwg\n");
711 * This routine is called by frontend after an ENOSP on write
714 tape_std_process_eov(struct tape_device
*device
)
717 * End of volume: We have to backspace the last written record, then
718 * we TRY to write a tapemark and then backspace over the written TM
720 if (tape_mtop(device
, MTBSR
, 1) == 0 &&
721 tape_mtop(device
, MTWEOF
, 1) == 0) {
722 tape_mtop(device
, MTBSR
, 1);
726 EXPORT_SYMBOL(tape_std_assign
);
727 EXPORT_SYMBOL(tape_std_unassign
);
728 EXPORT_SYMBOL(tape_std_display
);
729 EXPORT_SYMBOL(tape_std_read_block_id
);
730 EXPORT_SYMBOL(tape_std_mtload
);
731 EXPORT_SYMBOL(tape_std_mtsetblk
);
732 EXPORT_SYMBOL(tape_std_mtreset
);
733 EXPORT_SYMBOL(tape_std_mtfsf
);
734 EXPORT_SYMBOL(tape_std_mtfsr
);
735 EXPORT_SYMBOL(tape_std_mtbsr
);
736 EXPORT_SYMBOL(tape_std_mtweof
);
737 EXPORT_SYMBOL(tape_std_mtbsfm
);
738 EXPORT_SYMBOL(tape_std_mtbsf
);
739 EXPORT_SYMBOL(tape_std_mtfsfm
);
740 EXPORT_SYMBOL(tape_std_mtrew
);
741 EXPORT_SYMBOL(tape_std_mtoffl
);
742 EXPORT_SYMBOL(tape_std_mtnop
);
743 EXPORT_SYMBOL(tape_std_mteom
);
744 EXPORT_SYMBOL(tape_std_mtreten
);
745 EXPORT_SYMBOL(tape_std_mterase
);
746 EXPORT_SYMBOL(tape_std_mtunload
);
747 EXPORT_SYMBOL(tape_std_mtcompression
);
748 EXPORT_SYMBOL(tape_std_read_block
);
749 EXPORT_SYMBOL(tape_std_read_backward
);
750 EXPORT_SYMBOL(tape_std_write_block
);
751 EXPORT_SYMBOL(tape_std_process_eov
);