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);