[net-next-2.6.git] / drivers / s390 / char / tape_std.c

/*
 *  drivers/s390/char/tape_std.c
 *    standard tape device functions for ibm tapes.
 *
 *  S390 and zSeries version
 *    Copyright (C) 2001,2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
 *    Author(s): Carsten Otte <cotte@de.ibm.com>
 *		 Michael Holzheu <holzheu@de.ibm.com>
 *		 Tuan Ngo-Anh <ngoanh@de.ibm.com>
 *		 Martin Schwidefsky <schwidefsky@de.ibm.com>
 *		 Stefan Bader <shbader@de.ibm.com>
 */

#define KMSG_COMPONENT "tape"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/stddef.h>
#include <linux/kernel.h>
#include <linux/bio.h>
#include <linux/timer.h>

#include <asm/types.h>
#include <asm/idals.h>
#include <asm/ebcdic.h>
#include <asm/tape390.h>

#define TAPE_DBF_AREA	tape_core_dbf

#include "tape.h"
#include "tape_std.h"

/*
 * tape_std_assign
 */
static void
tape_std_assign_timeout(unsigned long data)
{
	struct tape_request *	request;
	struct tape_device *	device;
	int rc;

	request = (struct tape_request *) data;
	device = request->device;
	BUG_ON(!device);

	DBF_EVENT(3, "%08x: Assignment timeout. Device busy.\n",
			device->cdev_id);
	rc = tape_cancel_io(device, request);
	if(rc)
		DBF_EVENT(3, "(%08x): Assign timeout: Cancel failed with rc = "
			  "%i\n", device->cdev_id, rc);
}

int
tape_std_assign(struct tape_device *device)
{
	int                  rc;
	struct timer_list    timeout;
	struct tape_request *request;

	request = tape_alloc_request(2, 11);
	if (IS_ERR(request))
		return PTR_ERR(request);

	request->op = TO_ASSIGN;
	tape_ccw_cc(request->cpaddr, ASSIGN, 11, request->cpdata);
	tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);

	/*
	 * The assign command sometimes blocks if the device is assigned
	 * to another host (actually this shouldn't happen but it does).
	 * So we set up a timeout for this call.
	 */
	init_timer_on_stack(&timeout);
	timeout.function = tape_std_assign_timeout;
	timeout.data     = (unsigned long) request;
	timeout.expires  = jiffies + 2 * HZ;
	add_timer(&timeout);

	rc = tape_do_io_interruptible(device, request);

	del_timer(&timeout);

	if (rc != 0) {
		DBF_EVENT(3, "%08x: assign failed - device might be busy\n",
			device->cdev_id);
	} else {
		DBF_EVENT(3, "%08x: Tape assigned\n", device->cdev_id);
	}
	tape_free_request(request);
	return rc;
}

/*
 * tape_std_unassign
 */
int
tape_std_unassign (struct tape_device *device)
{
	int                  rc;
	struct tape_request *request;

	if (device->tape_state == TS_NOT_OPER) {
		DBF_EVENT(3, "(%08x): Can't unassign device\n",
			device->cdev_id);
		return -EIO;
	}

	request = tape_alloc_request(2, 11);
	if (IS_ERR(request))
		return PTR_ERR(request);

	request->op = TO_UNASSIGN;
	tape_ccw_cc(request->cpaddr, UNASSIGN, 11, request->cpdata);
	tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);

	if ((rc = tape_do_io(device, request)) != 0) {
		DBF_EVENT(3, "%08x: Unassign failed\n", device->cdev_id);
	} else {
		DBF_EVENT(3, "%08x: Tape unassigned\n", device->cdev_id);
	}
	tape_free_request(request);
	return rc;
}

/*
 * TAPE390_DISPLAY: Show a string on the tape display.
 */
int
tape_std_display(struct tape_device *device, struct display_struct *disp)
{
	struct tape_request *request;
	int rc;

	request = tape_alloc_request(2, 17);
	if (IS_ERR(request)) {
		DBF_EVENT(3, "TAPE: load display failed\n");
		return PTR_ERR(request);
	}
	request->op = TO_DIS;

	*(unsigned char *) request->cpdata = disp->cntrl;
	DBF_EVENT(5, "TAPE: display cntrl=%04x\n", disp->cntrl);
	memcpy(((unsigned char *) request->cpdata) + 1, disp->message1, 8);
	memcpy(((unsigned char *) request->cpdata) + 9, disp->message2, 8);
	ASCEBC(((unsigned char*) request->cpdata) + 1, 16);

	tape_ccw_cc(request->cpaddr, LOAD_DISPLAY, 17, request->cpdata);
	tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);

	rc = tape_do_io_interruptible(device, request);
	tape_free_request(request);
	return rc;
}

/*
 * Read block id.
 */
int
tape_std_read_block_id(struct tape_device *device, __u64 *id)
{
	struct tape_request *request;
	int rc;

	request = tape_alloc_request(3, 8);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_RBI;
	/* setup ccws */
	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
	tape_ccw_cc(request->cpaddr + 1, READ_BLOCK_ID, 8, request->cpdata);
	tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
	/* execute it */
	rc = tape_do_io(device, request);
	if (rc == 0)
		/* Get result from read buffer. */
		*id = *(__u64 *) request->cpdata;
	tape_free_request(request);
	return rc;
}

int
tape_std_terminate_write(struct tape_device *device)
{
	int rc;

	if(device->required_tapemarks == 0)
		return 0;

	DBF_LH(5, "tape%d: terminate write %dxEOF\n", device->first_minor,
		device->required_tapemarks);

	rc = tape_mtop(device, MTWEOF, device->required_tapemarks);
	if (rc)
		return rc;

	device->required_tapemarks = 0;
	return tape_mtop(device, MTBSR, 1);
}

/*
 * MTLOAD: Loads the tape.
 * The default implementation just wait until the tape medium state changes
 * to MS_LOADED.
 */
int
tape_std_mtload(struct tape_device *device, int count)
{
	return wait_event_interruptible(device->state_change_wq,
		(device->medium_state == MS_LOADED));
}

/*
 * MTSETBLK: Set block size.
 */
int
tape_std_mtsetblk(struct tape_device *device, int count)
{
	struct idal_buffer *new;

	DBF_LH(6, "tape_std_mtsetblk(%d)\n", count);
	if (count <= 0) {
		/*
		 * Just set block_size to 0. tapechar_read/tapechar_write
		 * will realloc the idal buffer if a bigger one than the
		 * current is needed.
		 */
		device->char_data.block_size = 0;
		return 0;
	}
	if (device->char_data.idal_buf != NULL &&
	    device->char_data.idal_buf->size == count)
		/* We already have a idal buffer of that size. */
		return 0;

	if (count > MAX_BLOCKSIZE) {
		DBF_EVENT(3, "Invalid block size (%d > %d) given.\n",
			count, MAX_BLOCKSIZE);
		return -EINVAL;
	}

	/* Allocate a new idal buffer. */
	new = idal_buffer_alloc(count, 0);
	if (IS_ERR(new))
		return -ENOMEM;
	if (device->char_data.idal_buf != NULL)
		idal_buffer_free(device->char_data.idal_buf);
	device->char_data.idal_buf = new;
	device->char_data.block_size = count;

	DBF_LH(6, "new blocksize is %d\n", device->char_data.block_size);

	return 0;
}

/*
 * MTRESET: Set block size to 0.
 */
int
tape_std_mtreset(struct tape_device *device, int count)
{
	DBF_EVENT(6, "TCHAR:devreset:\n");
	device->char_data.block_size = 0;
	return 0;
}

/*
 * MTFSF: Forward space over 'count' file marks. The tape is positioned
 * at the EOT (End of Tape) side of the file mark.
 */
int
tape_std_mtfsf(struct tape_device *device, int mt_count)
{
	struct tape_request *request;
	struct ccw1 *ccw;

	request = tape_alloc_request(mt_count + 2, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_FSF;
	/* setup ccws */
	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
			  device->modeset_byte);
	ccw = tape_ccw_repeat(ccw, FORSPACEFILE, mt_count);
	ccw = tape_ccw_end(ccw, NOP, 0, NULL);

	/* execute it */
	return tape_do_io_free(device, request);
}

/*
 * MTFSR: Forward space over 'count' tape blocks (blocksize is set
 * via MTSETBLK.
 */
int
tape_std_mtfsr(struct tape_device *device, int mt_count)
{
	struct tape_request *request;
	struct ccw1 *ccw;
	int rc;

	request = tape_alloc_request(mt_count + 2, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_FSB;
	/* setup ccws */
	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
			  device->modeset_byte);
	ccw = tape_ccw_repeat(ccw, FORSPACEBLOCK, mt_count);
	ccw = tape_ccw_end(ccw, NOP, 0, NULL);

	/* execute it */
	rc = tape_do_io(device, request);
	if (rc == 0 && request->rescnt > 0) {
		DBF_LH(3, "FSR over tapemark\n");
		rc = 1;
	}
	tape_free_request(request);

	return rc;
}

/*
 * MTBSR: Backward space over 'count' tape blocks.
 * (blocksize is set via MTSETBLK.
 */
int
tape_std_mtbsr(struct tape_device *device, int mt_count)
{
	struct tape_request *request;
	struct ccw1 *ccw;
	int rc;

	request = tape_alloc_request(mt_count + 2, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_BSB;
	/* setup ccws */
	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
			  device->modeset_byte);
	ccw = tape_ccw_repeat(ccw, BACKSPACEBLOCK, mt_count);
	ccw = tape_ccw_end(ccw, NOP, 0, NULL);

	/* execute it */
	rc = tape_do_io(device, request);
	if (rc == 0 && request->rescnt > 0) {
		DBF_LH(3, "BSR over tapemark\n");
		rc = 1;
	}
	tape_free_request(request);

	return rc;
}

/*
 * MTWEOF: Write 'count' file marks at the current position.
 */
int
tape_std_mtweof(struct tape_device *device, int mt_count)
{
	struct tape_request *request;
	struct ccw1 *ccw;

	request = tape_alloc_request(mt_count + 2, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_WTM;
	/* setup ccws */
	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
			  device->modeset_byte);
	ccw = tape_ccw_repeat(ccw, WRITETAPEMARK, mt_count);
	ccw = tape_ccw_end(ccw, NOP, 0, NULL);

	/* execute it */
	return tape_do_io_free(device, request);
}

/*
 * MTBSFM: Backward space over 'count' file marks.
 * The tape is positioned at the BOT (Begin Of Tape) side of the
 * last skipped file mark.
 */
int
tape_std_mtbsfm(struct tape_device *device, int mt_count)
{
	struct tape_request *request;
	struct ccw1 *ccw;

	request = tape_alloc_request(mt_count + 2, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_BSF;
	/* setup ccws */
	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
			  device->modeset_byte);
	ccw = tape_ccw_repeat(ccw, BACKSPACEFILE, mt_count);
	ccw = tape_ccw_end(ccw, NOP, 0, NULL);

	/* execute it */
	return tape_do_io_free(device, request);
}

/*
 * MTBSF: Backward space over 'count' file marks. The tape is positioned at
 * the EOT (End of Tape) side of the last skipped file mark.
 */
int
tape_std_mtbsf(struct tape_device *device, int mt_count)
{
	struct tape_request *request;
	struct ccw1 *ccw;
	int rc;

	request = tape_alloc_request(mt_count + 2, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_BSF;
	/* setup ccws */
	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
			  device->modeset_byte);
	ccw = tape_ccw_repeat(ccw, BACKSPACEFILE, mt_count);
	ccw = tape_ccw_end(ccw, NOP, 0, NULL);
	/* execute it */
	rc = tape_do_io_free(device, request);
	if (rc == 0) {
		rc = tape_mtop(device, MTFSR, 1);
		if (rc > 0)
			rc = 0;
	}
	return rc;
}

/*
 * MTFSFM: Forward space over 'count' file marks.
 * The tape is positioned at the BOT (Begin Of Tape) side
 * of the last skipped file mark.
 */
int
tape_std_mtfsfm(struct tape_device *device, int mt_count)
{
	struct tape_request *request;
	struct ccw1 *ccw;
	int rc;

	request = tape_alloc_request(mt_count + 2, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_FSF;
	/* setup ccws */
	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
			  device->modeset_byte);
	ccw = tape_ccw_repeat(ccw, FORSPACEFILE, mt_count);
	ccw = tape_ccw_end(ccw, NOP, 0, NULL);
	/* execute it */
	rc = tape_do_io_free(device, request);
	if (rc == 0) {
		rc = tape_mtop(device, MTBSR, 1);
		if (rc > 0)
			rc = 0;
	}

	return rc;
}

/*
 * MTREW: Rewind the tape.
 */
int
tape_std_mtrew(struct tape_device *device, int mt_count)
{
	struct tape_request *request;

	request = tape_alloc_request(3, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_REW;
	/* setup ccws */
	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
		    device->modeset_byte);
	tape_ccw_cc(request->cpaddr + 1, REWIND, 0, NULL);
	tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);

	/* execute it */
	return tape_do_io_free(device, request);
}

/*
 * MTOFFL: Rewind the tape and put the drive off-line.
 * Implement 'rewind unload'
 */
int
tape_std_mtoffl(struct tape_device *device, int mt_count)
{
	struct tape_request *request;

	request = tape_alloc_request(3, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_RUN;
	/* setup ccws */
	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
	tape_ccw_cc(request->cpaddr + 1, REWIND_UNLOAD, 0, NULL);
	tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);

	/* execute it */
	return tape_do_io_free(device, request);
}

/*
 * MTNOP: 'No operation'.
 */
int
tape_std_mtnop(struct tape_device *device, int mt_count)
{
	struct tape_request *request;

	request = tape_alloc_request(2, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_NOP;
	/* setup ccws */
	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
	tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);
	/* execute it */
	return tape_do_io_free(device, request);
}

/*
 * MTEOM: positions at the end of the portion of the tape already used
 * for recordind data. MTEOM positions after the last file mark, ready for
 * appending another file.
 */
int
tape_std_mteom(struct tape_device *device, int mt_count)
{
	int rc;

	/*
	 * Seek from the beginning of tape (rewind).
	 */
	if ((rc = tape_mtop(device, MTREW, 1)) < 0)
		return rc;

	/*
	 * The logical end of volume is given by two sewuential tapemarks.
	 * Look for this by skipping to the next file (over one tapemark)
	 * and then test for another one (fsr returns 1 if a tapemark was
	 * encountered).
	 */
	do {
		if ((rc = tape_mtop(device, MTFSF, 1)) < 0)
			return rc;
		if ((rc = tape_mtop(device, MTFSR, 1)) < 0)
			return rc;
	} while (rc == 0);

	return tape_mtop(device, MTBSR, 1);
}

/*
 * MTRETEN: Retension the tape, i.e. forward space to end of tape and rewind.
 */
int
tape_std_mtreten(struct tape_device *device, int mt_count)
{
	struct tape_request *request;
	int rc;

	request = tape_alloc_request(4, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_FSF;
	/* setup ccws */
	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
	tape_ccw_cc(request->cpaddr + 1,FORSPACEFILE, 0, NULL);
	tape_ccw_cc(request->cpaddr + 2, NOP, 0, NULL);
	tape_ccw_end(request->cpaddr + 3, CCW_CMD_TIC, 0, request->cpaddr);
	/* execute it, MTRETEN rc gets ignored */
	rc = tape_do_io_interruptible(device, request);
	tape_free_request(request);
	return tape_mtop(device, MTREW, 1);
}

/*
 * MTERASE: erases the tape.
 */
int
tape_std_mterase(struct tape_device *device, int mt_count)
{
	struct tape_request *request;

	request = tape_alloc_request(6, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_DSE;
	/* setup ccws */
	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
	tape_ccw_cc(request->cpaddr + 1, REWIND, 0, NULL);
	tape_ccw_cc(request->cpaddr + 2, ERASE_GAP, 0, NULL);
	tape_ccw_cc(request->cpaddr + 3, DATA_SEC_ERASE, 0, NULL);
	tape_ccw_cc(request->cpaddr + 4, REWIND, 0, NULL);
	tape_ccw_end(request->cpaddr + 5, NOP, 0, NULL);

	/* execute it */
	return tape_do_io_free(device, request);
}

/*
 * MTUNLOAD: Rewind the tape and unload it.
 */
int
tape_std_mtunload(struct tape_device *device, int mt_count)
{
	return tape_mtop(device, MTOFFL, mt_count);
}

/*
 * MTCOMPRESSION: used to enable compression.
 * Sets the IDRC on/off.
 */
int
tape_std_mtcompression(struct tape_device *device, int mt_count)
{
	struct tape_request *request;

	if (mt_count < 0 || mt_count > 1) {
		DBF_EXCEPTION(6, "xcom parm\n");
		return -EINVAL;
	}
	request = tape_alloc_request(2, 0);
	if (IS_ERR(request))
		return PTR_ERR(request);
	request->op = TO_NOP;
	/* setup ccws */
	if (mt_count == 0)
		*device->modeset_byte &= ~0x08;
	else
		*device->modeset_byte |= 0x08;
	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
	tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);
	/* execute it */
	return tape_do_io_free(device, request);
}

/*
 * Read Block
 */
struct tape_request *
tape_std_read_block(struct tape_device *device, size_t count)
{
	struct tape_request *request;

	/*
	 * We have to alloc 4 ccws in order to be able to transform request
	 * into a read backward request in error case.
	 */
	request = tape_alloc_request(4, 0);
	if (IS_ERR(request)) {
		DBF_EXCEPTION(6, "xrbl fail");
		return request;
	}
	request->op = TO_RFO;
	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
	tape_ccw_end_idal(request->cpaddr + 1, READ_FORWARD,
			  device->char_data.idal_buf);
	DBF_EVENT(6, "xrbl ccwg\n");
	return request;
}

/*
 * Read Block backward transformation function.
 */
void
tape_std_read_backward(struct tape_device *device, struct tape_request *request)
{
	/*
	 * We have allocated 4 ccws in tape_std_read, so we can now
	 * transform the request to a read backward, followed by a
	 * forward space block.
	 */
	request->op = TO_RBA;
	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
	tape_ccw_cc_idal(request->cpaddr + 1, READ_BACKWARD,
			 device->char_data.idal_buf);
	tape_ccw_cc(request->cpaddr + 2, FORSPACEBLOCK, 0, NULL);
	tape_ccw_end(request->cpaddr + 3, NOP, 0, NULL);
	DBF_EVENT(6, "xrop ccwg");}

/*
 * Write Block
 */
struct tape_request *
tape_std_write_block(struct tape_device *device, size_t count)
{
	struct tape_request *request;

	request = tape_alloc_request(2, 0);
	if (IS_ERR(request)) {
		DBF_EXCEPTION(6, "xwbl fail\n");
		return request;
	}
	request->op = TO_WRI;
	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
	tape_ccw_end_idal(request->cpaddr + 1, WRITE_CMD,
			  device->char_data.idal_buf);
	DBF_EVENT(6, "xwbl ccwg\n");
	return request;
}

/*
 * This routine is called by frontend after an ENOSP on write
 */
void
tape_std_process_eov(struct tape_device *device)
{
	/*
	 * End of volume: We have to backspace the last written record, then
	 * we TRY to write a tapemark and then backspace over the written TM
	 */
	if (tape_mtop(device, MTBSR, 1) == 0 &&
	    tape_mtop(device, MTWEOF, 1) == 0) {
		tape_mtop(device, MTBSR, 1);
	}
}

EXPORT_SYMBOL(tape_std_assign);
EXPORT_SYMBOL(tape_std_unassign);
EXPORT_SYMBOL(tape_std_display);
EXPORT_SYMBOL(tape_std_read_block_id);
EXPORT_SYMBOL(tape_std_mtload);
EXPORT_SYMBOL(tape_std_mtsetblk);
EXPORT_SYMBOL(tape_std_mtreset);
EXPORT_SYMBOL(tape_std_mtfsf);
EXPORT_SYMBOL(tape_std_mtfsr);
EXPORT_SYMBOL(tape_std_mtbsr);
EXPORT_SYMBOL(tape_std_mtweof);
EXPORT_SYMBOL(tape_std_mtbsfm);
EXPORT_SYMBOL(tape_std_mtbsf);
EXPORT_SYMBOL(tape_std_mtfsfm);
EXPORT_SYMBOL(tape_std_mtrew);
EXPORT_SYMBOL(tape_std_mtoffl);
EXPORT_SYMBOL(tape_std_mtnop);
EXPORT_SYMBOL(tape_std_mteom);
EXPORT_SYMBOL(tape_std_mtreten);
EXPORT_SYMBOL(tape_std_mterase);
EXPORT_SYMBOL(tape_std_mtunload);
EXPORT_SYMBOL(tape_std_mtcompression);
EXPORT_SYMBOL(tape_std_read_block);
EXPORT_SYMBOL(tape_std_read_backward);
EXPORT_SYMBOL(tape_std_write_block);
EXPORT_SYMBOL(tape_std_process_eov);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* drivers/s390/char/tape_std.c
	3	* standard tape device functions for ibm tapes.
	4	*
	5	* S390 and zSeries version
	6	* Copyright (C) 2001,2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
	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>
	12	*/
	13
bb509912 MH	14	#define KMSG_COMPONENT "tape"
	15	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	16
1da177e4 LT	17	#include <linux/stddef.h>
	18	#include <linux/kernel.h>
	19	#include <linux/bio.h>
	20	#include <linux/timer.h>
	21
	22	#include <asm/types.h>
	23	#include <asm/idals.h>
	24	#include <asm/ebcdic.h>
	25	#include <asm/tape390.h>
	26
	27	#define TAPE_DBF_AREA tape_core_dbf
	28
	29	#include "tape.h"
	30	#include "tape_std.h"
	31
1da177e4 LT	32	/*
	33	* tape_std_assign
	34	*/
	35	static void
	36	tape_std_assign_timeout(unsigned long data)
	37	{
	38	struct tape_request * request;
	39	struct tape_device * device;
5f384338	40	int rc;
1da177e4 LT	41
1da177e4 LT	42	request = (struct tape_request *) data;
6aa0d3a9 SG	43	device = request->device;
6aa0d3a9 SG	44	BUG_ON(!device);
1da177e4	45
5f384338	46	DBF_EVENT(3, "%08x: Assignment timeout. Device busy.\n",
1da177e4	47	device->cdev_id);
5f384338 MH	48	rc = tape_cancel_io(device, request);
5f384338 MH	49	if(rc)
f2166bb1 SO	50	DBF_EVENT(3, "(%08x): Assign timeout: Cancel failed with rc = "
f2166bb1 SO	51	"%i\n", device->cdev_id, rc);
1da177e4 LT	52	}
	53
	54	int
	55	tape_std_assign(struct tape_device *device)
	56	{
	57	int rc;
	58	struct timer_list timeout;
	59	struct tape_request *request;
	60
	61	request = tape_alloc_request(2, 11);
	62	if (IS_ERR(request))
	63	return PTR_ERR(request);
	64
	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);
	68
	69	/*
	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.
	73	*/
6292b9ef	74	init_timer_on_stack(&timeout);
1da177e4 LT	75	timeout.function = tape_std_assign_timeout;
	76	timeout.data = (unsigned long) request;
	77	timeout.expires = jiffies + 2 * HZ;
	78	add_timer(&timeout);
	79
	80	rc = tape_do_io_interruptible(device, request);
	81
	82	del_timer(&timeout);
	83
	84	if (rc != 0) {
1da177e4 LT	85	DBF_EVENT(3, "%08x: assign failed - device might be busy\n",
	86	device->cdev_id);
	87	} else {
	88	DBF_EVENT(3, "%08x: Tape assigned\n", device->cdev_id);
	89	}
	90	tape_free_request(request);
	91	return rc;
	92	}
	93
	94	/*
	95	* tape_std_unassign
	96	*/
	97	int
	98	tape_std_unassign (struct tape_device *device)
	99	{
	100	int rc;
	101	struct tape_request *request;
	102
	103	if (device->tape_state == TS_NOT_OPER) {
	104	DBF_EVENT(3, "(%08x): Can't unassign device\n",
	105	device->cdev_id);
1da177e4 LT	106	return -EIO;
	107	}
	108
	109	request = tape_alloc_request(2, 11);
	110	if (IS_ERR(request))
	111	return PTR_ERR(request);
	112
	113	request->op = TO_UNASSIGN;
	114	tape_ccw_cc(request->cpaddr, UNASSIGN, 11, request->cpdata);
	115	tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);
	116
	117	if ((rc = tape_do_io(device, request)) != 0) {
	118	DBF_EVENT(3, "%08x: Unassign failed\n", device->cdev_id);
1da177e4 LT	119	} else {
	120	DBF_EVENT(3, "%08x: Tape unassigned\n", device->cdev_id);
	121	}
	122	tape_free_request(request);
	123	return rc;
	124	}
	125
	126	/*
	127	* TAPE390_DISPLAY: Show a string on the tape display.
	128	*/
	129	int
	130	tape_std_display(struct tape_device device, struct display_struct disp)
	131	{
	132	struct tape_request *request;
	133	int rc;
	134
	135	request = tape_alloc_request(2, 17);
	136	if (IS_ERR(request)) {
	137	DBF_EVENT(3, "TAPE: load display failed\n");
	138	return PTR_ERR(request);
	139	}
	140	request->op = TO_DIS;
	141
	142	(unsigned char ) request->cpdata = disp->cntrl;
	143	DBF_EVENT(5, "TAPE: display cntrl=%04x\n", disp->cntrl);
	144	memcpy(((unsigned char *) request->cpdata) + 1, disp->message1, 8);
	145	memcpy(((unsigned char *) request->cpdata) + 9, disp->message2, 8);
	146	ASCEBC(((unsigned char*) request->cpdata) + 1, 16);
	147
	148	tape_ccw_cc(request->cpaddr, LOAD_DISPLAY, 17, request->cpdata);
	149	tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);
	150
	151	rc = tape_do_io_interruptible(device, request);
	152	tape_free_request(request);
	153	return rc;
	154	}
	155
	156	/*
	157	* Read block id.
	158	*/
	159	int
	160	tape_std_read_block_id(struct tape_device device, __u64 id)
	161	{
	162	struct tape_request *request;
	163	int rc;
	164
	165	request = tape_alloc_request(3, 8);
	166	if (IS_ERR(request))
	167	return PTR_ERR(request);
	168	request->op = TO_RBI;
	169	/* setup ccws */
	170	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
	171	tape_ccw_cc(request->cpaddr + 1, READ_BLOCK_ID, 8, request->cpdata);
	172	tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
	173	/* execute it */
	174	rc = tape_do_io(device, request);
	175	if (rc == 0)
	176	/* Get result from read buffer. */
	177	id = (__u64 *) request->cpdata;
	178	tape_free_request(request);
	179	return rc;
	180	}
	181
	182	int
183	tape_std_terminate_write(struct tape_device *device)
184	{
185	int rc;
186
187	if(device->required_tapemarks == 0)
188	return 0;
189
190	DBF_LH(5, "tape%d: terminate write %dxEOF\n", device->first_minor,
191	device->required_tapemarks);
192
193	rc = tape_mtop(device, MTWEOF, device->required_tapemarks);
194	if (rc)
195	return rc;
196
197	device->required_tapemarks = 0;
198	return tape_mtop(device, MTBSR, 1);
199	}
200
201	/*
202	* MTLOAD: Loads the tape.
203	* The default implementation just wait until the tape medium state changes
204	* to MS_LOADED.
205	*/
206	int
207	tape_std_mtload(struct tape_device *device, int count)
208	{
209	return wait_event_interruptible(device->state_change_wq,
210	(device->medium_state == MS_LOADED));
211	}
212
213	/*
214	* MTSETBLK: Set block size.
215	*/
216	int
217	tape_std_mtsetblk(struct tape_device *device, int count)
218	{
219	struct idal_buffer *new;
220
221	DBF_LH(6, "tape_std_mtsetblk(%d)\n", count);
222	if (count <= 0) {
223	/*
224	* Just set block_size to 0. tapechar_read/tapechar_write
225	* will realloc the idal buffer if a bigger one than the
226	* current is needed.
227	*/
228	device->char_data.block_size = 0;
229	return 0;
230	}
231	if (device->char_data.idal_buf != NULL &&
232	device->char_data.idal_buf->size == count)
233	/* We already have a idal buffer of that size. */
234	return 0;
235
236	if (count > MAX_BLOCKSIZE) {
237	DBF_EVENT(3, "Invalid block size (%d > %d) given.\n",
238	count, MAX_BLOCKSIZE);
1da177e4 LT	239	return -EINVAL;
	240	}
	241
	242	/* Allocate a new idal buffer. */
	243	new = idal_buffer_alloc(count, 0);
0983e568	244	if (IS_ERR(new))
1da177e4 LT	245	return -ENOMEM;
	246	if (device->char_data.idal_buf != NULL)
	247	idal_buffer_free(device->char_data.idal_buf);
	248	device->char_data.idal_buf = new;
	249	device->char_data.block_size = count;
	250
	251	DBF_LH(6, "new blocksize is %d\n", device->char_data.block_size);
	252
	253	return 0;
	254	}
	255
	256	/*
	257	* MTRESET: Set block size to 0.
	258	*/
	259	int
	260	tape_std_mtreset(struct tape_device *device, int count)
	261	{
	262	DBF_EVENT(6, "TCHAR:devreset:\n");
	263	device->char_data.block_size = 0;
	264	return 0;
	265	}
	266
	267	/*
	268	* MTFSF: Forward space over 'count' file marks. The tape is positioned
	269	* at the EOT (End of Tape) side of the file mark.
	270	*/
	271	int
	272	tape_std_mtfsf(struct tape_device *device, int mt_count)
	273	{
	274	struct tape_request *request;
	275	struct ccw1 *ccw;
	276
	277	request = tape_alloc_request(mt_count + 2, 0);
	278	if (IS_ERR(request))
	279	return PTR_ERR(request);
	280	request->op = TO_FSF;
	281	/* setup ccws */
	282	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
	283	device->modeset_byte);
	284	ccw = tape_ccw_repeat(ccw, FORSPACEFILE, mt_count);
	285	ccw = tape_ccw_end(ccw, NOP, 0, NULL);
	286
	287	/* execute it */
	288	return tape_do_io_free(device, request);
	289	}
	290
	291	/*
	292	* MTFSR: Forward space over 'count' tape blocks (blocksize is set
	293	* via MTSETBLK.
	294	*/
	295	int
	296	tape_std_mtfsr(struct tape_device *device, int mt_count)
	297	{
	298	struct tape_request *request;
	299	struct ccw1 *ccw;
	300	int rc;
	301
	302	request = tape_alloc_request(mt_count + 2, 0);
	303	if (IS_ERR(request))
	304	return PTR_ERR(request);
	305	request->op = TO_FSB;
	306	/* setup ccws */
	307	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
	308	device->modeset_byte);
309	ccw = tape_ccw_repeat(ccw, FORSPACEBLOCK, mt_count);
310	ccw = tape_ccw_end(ccw, NOP, 0, NULL);
311
312	/* execute it */
313	rc = tape_do_io(device, request);
314	if (rc == 0 && request->rescnt > 0) {
315	DBF_LH(3, "FSR over tapemark\n");
316	rc = 1;
317	}
318	tape_free_request(request);
319
320	return rc;
321	}
322
323	/*
324	* MTBSR: Backward space over 'count' tape blocks.
325	* (blocksize is set via MTSETBLK.
326	*/
327	int
328	tape_std_mtbsr(struct tape_device *device, int mt_count)
329	{
330	struct tape_request *request;
331	struct ccw1 *ccw;
332	int rc;
333
334	request = tape_alloc_request(mt_count + 2, 0);
335	if (IS_ERR(request))
336	return PTR_ERR(request);
337	request->op = TO_BSB;
338	/* setup ccws */
339	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
340	device->modeset_byte);
341	ccw = tape_ccw_repeat(ccw, BACKSPACEBLOCK, mt_count);
342	ccw = tape_ccw_end(ccw, NOP, 0, NULL);
343
344	/* execute it */
345	rc = tape_do_io(device, request);
346	if (rc == 0 && request->rescnt > 0) {
347	DBF_LH(3, "BSR over tapemark\n");
348	rc = 1;
349	}
350	tape_free_request(request);
351
352	return rc;
353	}
354
355	/*
356	* MTWEOF: Write 'count' file marks at the current position.
357	*/
358	int
359	tape_std_mtweof(struct tape_device *device, int mt_count)
360	{
361	struct tape_request *request;
362	struct ccw1 *ccw;
363
364	request = tape_alloc_request(mt_count + 2, 0);
365	if (IS_ERR(request))
366	return PTR_ERR(request);
367	request->op = TO_WTM;
368	/* setup ccws */
369	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
370	device->modeset_byte);
371	ccw = tape_ccw_repeat(ccw, WRITETAPEMARK, mt_count);
372	ccw = tape_ccw_end(ccw, NOP, 0, NULL);
373
374	/* execute it */
375	return tape_do_io_free(device, request);
376	}
377
378	/*
379	* MTBSFM: Backward space over 'count' file marks.
380	* The tape is positioned at the BOT (Begin Of Tape) side of the
381	* last skipped file mark.
382	*/
383	int
384	tape_std_mtbsfm(struct tape_device *device, int mt_count)
385	{
386	struct tape_request *request;
387	struct ccw1 *ccw;
388
389	request = tape_alloc_request(mt_count + 2, 0);
390	if (IS_ERR(request))
391	return PTR_ERR(request);
392	request->op = TO_BSF;
393	/* setup ccws */
394	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
395	device->modeset_byte);
396	ccw = tape_ccw_repeat(ccw, BACKSPACEFILE, mt_count);
397	ccw = tape_ccw_end(ccw, NOP, 0, NULL);
398
399	/* execute it */
400	return tape_do_io_free(device, request);
401	}
402
403	/*
404	* MTBSF: Backward space over 'count' file marks. The tape is positioned at
405	* the EOT (End of Tape) side of the last skipped file mark.
406	*/
407	int
408	tape_std_mtbsf(struct tape_device *device, int mt_count)
409	{
410	struct tape_request *request;
411	struct ccw1 *ccw;
412	int rc;
413
414	request = tape_alloc_request(mt_count + 2, 0);
415	if (IS_ERR(request))
416	return PTR_ERR(request);
417	request->op = TO_BSF;
418	/* setup ccws */
419	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
420	device->modeset_byte);
421	ccw = tape_ccw_repeat(ccw, BACKSPACEFILE, mt_count);
422	ccw = tape_ccw_end(ccw, NOP, 0, NULL);
423	/* execute it */
424	rc = tape_do_io_free(device, request);
425	if (rc == 0) {
426	rc = tape_mtop(device, MTFSR, 1);
427	if (rc > 0)
428	rc = 0;
429	}
430	return rc;
431	}
432
433	/*
434	* MTFSFM: Forward space over 'count' file marks.
435	* The tape is positioned at the BOT (Begin Of Tape) side
436	* of the last skipped file mark.
437	*/
438	int
439	tape_std_mtfsfm(struct tape_device *device, int mt_count)
440	{
441	struct tape_request *request;
442	struct ccw1 *ccw;
443	int rc;
444
445	request = tape_alloc_request(mt_count + 2, 0);
446	if (IS_ERR(request))
447	return PTR_ERR(request);
448	request->op = TO_FSF;
449	/* setup ccws */
450	ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
451	device->modeset_byte);
452	ccw = tape_ccw_repeat(ccw, FORSPACEFILE, mt_count);
453	ccw = tape_ccw_end(ccw, NOP, 0, NULL);
454	/* execute it */
455	rc = tape_do_io_free(device, request);
456	if (rc == 0) {
457	rc = tape_mtop(device, MTBSR, 1);
458	if (rc > 0)
459	rc = 0;
460	}
461
462	return rc;
463	}
464
465	/*
466	* MTREW: Rewind the tape.
467	*/
468	int
469	tape_std_mtrew(struct tape_device *device, int mt_count)
470	{
471	struct tape_request *request;
472
473	request = tape_alloc_request(3, 0);
474	if (IS_ERR(request))
475	return PTR_ERR(request);
476	request->op = TO_REW;
477	/* setup ccws */
478	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
479	device->modeset_byte);
480	tape_ccw_cc(request->cpaddr + 1, REWIND, 0, NULL);
481	tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
482
483	/* execute it */
484	return tape_do_io_free(device, request);
485	}
486
487	/*
488	* MTOFFL: Rewind the tape and put the drive off-line.
489	* Implement 'rewind unload'
490	*/
491	int
492	tape_std_mtoffl(struct tape_device *device, int mt_count)
493	{
494	struct tape_request *request;
495
496	request = tape_alloc_request(3, 0);
497	if (IS_ERR(request))
498	return PTR_ERR(request);
499	request->op = TO_RUN;
500	/* setup ccws */
501	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
502	tape_ccw_cc(request->cpaddr + 1, REWIND_UNLOAD, 0, NULL);
503	tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
504
505	/* execute it */
506	return tape_do_io_free(device, request);
507	}
508
509	/*
510	* MTNOP: 'No operation'.
511	*/
512	int
513	tape_std_mtnop(struct tape_device *device, int mt_count)
514	{
515	struct tape_request *request;
516
517	request = tape_alloc_request(2, 0);
518	if (IS_ERR(request))
519	return PTR_ERR(request);
520	request->op = TO_NOP;
521	/* setup ccws */
522	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
523	tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);
524	/* execute it */
525	return tape_do_io_free(device, request);
526	}
527
528	/*
529	* MTEOM: positions at the end of the portion of the tape already used
530	* for recordind data. MTEOM positions after the last file mark, ready for
531	* appending another file.
532	*/
533	int
534	tape_std_mteom(struct tape_device *device, int mt_count)
535	{
536	int rc;
537
538	/*
539	* Seek from the beginning of tape (rewind).
540	*/
541	if ((rc = tape_mtop(device, MTREW, 1)) < 0)
542	return rc;
543
544	/*
545	* The logical end of volume is given by two sewuential tapemarks.
546	* Look for this by skipping to the next file (over one tapemark)
547	* and then test for another one (fsr returns 1 if a tapemark was
548	* encountered).
549	*/
550	do {
551	if ((rc = tape_mtop(device, MTFSF, 1)) < 0)
552	return rc;
553	if ((rc = tape_mtop(device, MTFSR, 1)) < 0)
554	return rc;
555	} while (rc == 0);
556
557	return tape_mtop(device, MTBSR, 1);
558	}
559
560	/*
561	* MTRETEN: Retension the tape, i.e. forward space to end of tape and rewind.
562	*/
563	int
564	tape_std_mtreten(struct tape_device *device, int mt_count)
565	{
566	struct tape_request *request;
567	int rc;
568
569	request = tape_alloc_request(4, 0);
570	if (IS_ERR(request))
571	return PTR_ERR(request);
572	request->op = TO_FSF;
573	/* setup ccws */
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	rc = tape_do_io_interruptible(device, request);
580	tape_free_request(request);
581	return tape_mtop(device, MTREW, 1);
582	}
583
584	/*
585	* MTERASE: erases the tape.
586	*/
587	int
588	tape_std_mterase(struct tape_device *device, int mt_count)
589	{
590	struct tape_request *request;
591
592	request = tape_alloc_request(6, 0);
593	if (IS_ERR(request))
594	return PTR_ERR(request);
595	request->op = TO_DSE;
596	/* setup ccws */
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);
603
604	/* execute it */
605	return tape_do_io_free(device, request);
606	}
607
608	/*
609	* MTUNLOAD: Rewind the tape and unload it.
610	*/
611	int
612	tape_std_mtunload(struct tape_device *device, int mt_count)
613	{
614	return tape_mtop(device, MTOFFL, mt_count);
615	}
616
617	/*
618	* MTCOMPRESSION: used to enable compression.
619	* Sets the IDRC on/off.
620	*/
621	int
622	tape_std_mtcompression(struct tape_device *device, int mt_count)
623	{
624	struct tape_request *request;
625
626	if (mt_count < 0 \|\| mt_count > 1) {
627	DBF_EXCEPTION(6, "xcom parm\n");
1da177e4 LT	628	return -EINVAL;
	629	}
	630	request = tape_alloc_request(2, 0);
	631	if (IS_ERR(request))
	632	return PTR_ERR(request);
	633	request->op = TO_NOP;
	634	/* setup ccws */
4925c7e2 MH	635	if (mt_count == 0)
	636	*device->modeset_byte &= ~0x08;
	637	else
	638	*device->modeset_byte \|= 0x08;
1da177e4 LT	639	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
	640	tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);
	641	/* execute it */
	642	return tape_do_io_free(device, request);
	643	}
	644
	645	/*
	646	* Read Block
	647	*/
	648	struct tape_request *
	649	tape_std_read_block(struct tape_device *device, size_t count)
	650	{
	651	struct tape_request *request;
	652
	653	/*
	654	* We have to alloc 4 ccws in order to be able to transform request
	655	* into a read backward request in error case.
	656	*/
	657	request = tape_alloc_request(4, 0);
	658	if (IS_ERR(request)) {
	659	DBF_EXCEPTION(6, "xrbl fail");
	660	return request;
	661	}
	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");
	667	return request;
	668	}
	669
	670	/*
	671	* Read Block backward transformation function.
	672	*/
	673	void
	674	tape_std_read_backward(struct tape_device device, struct tape_request request)
	675	{
	676	/*
	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.
	680	*/
	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");}
	688
	689	/*
	690	* Write Block
	691	*/
	692	struct tape_request *
	693	tape_std_write_block(struct tape_device *device, size_t count)
	694	{
	695	struct tape_request *request;
	696
	697	request = tape_alloc_request(2, 0);
	698	if (IS_ERR(request)) {
	699	DBF_EXCEPTION(6, "xwbl fail\n");
	700	return request;
	701	}
	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");
707	return request;
708	}
709
710	/*
711	* This routine is called by frontend after an ENOSP on write
712	*/
713	void
714	tape_std_process_eov(struct tape_device *device)
715	{
716	/*
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
719	*/
720	if (tape_mtop(device, MTBSR, 1) == 0 &&
721	tape_mtop(device, MTWEOF, 1) == 0) {
722	tape_mtop(device, MTBSR, 1);
723	}
724	}
725
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);