Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit bb509912481214cf6ad1181c968295c62ff1ad9e

Authored by Michael Holzheu 2009-12-19 00:43:21 +0800

Committed by Martin Schwidefsky 2009-12-19 00:43:32 +0800

Exists in master and in 7 other branches

[S390] tape: Add pr_fmt() macro to all tape source files

Without defining the pr_fmt() macro, the "tape: " prefix will not be
printed when using the pr_xxx printk macros. This patch adds the
missing definitions.

Signed-off-by: Michael Holzheu <holzheu@linux.vnet.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

Showing 8 changed files with 18 additions and 0 deletions Inline Diff

drivers/s390/char/tape_34xx.c
drivers/s390/char/tape_3590.c
drivers/s390/char/tape_block.c
drivers/s390/char/tape_char.c
drivers/s390/char/tape_class.c
drivers/s390/char/tape_core.c
drivers/s390/char/tape_proc.c
drivers/s390/char/tape_std.c

drivers/s390/char/tape_34xx.c

Diff comments View file @ bb50991

 /*
  *  drivers/s390/char/tape_34xx.c
  *    tape device discipline for 3480/3490 tapes.
  *
  *    Copyright IBM Corp. 2001, 2009
  *    Author(s): Carsten Otte <cotte@de.ibm.com>
  *		 Tuan Ngo-Anh <ngoanh@de.ibm.com>
  *		 Martin Schwidefsky <schwidefsky@de.ibm.com>
  */
 #define KMSG_COMPONENT "tape_34xx"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/bio.h>
 #include <linux/workqueue.h>
 #define TAPE_DBF_AREA	tape_34xx_dbf
 #include "tape.h"
 #include "tape_std.h"
 /*
  * Pointer to debug area.
  */
 debug_info_t *TAPE_DBF_AREA = NULL;
 EXPORT_SYMBOL(TAPE_DBF_AREA);
 #define TAPE34XX_FMT_3480	0
 #define TAPE34XX_FMT_3480_2_XF	1
 #define TAPE34XX_FMT_3480_XF	2
 struct tape_34xx_block_id {
 	unsigned int	wrap		: 1;
 	unsigned int	segment		: 7;
 	unsigned int	format		: 2;
 	unsigned int	block		: 22;
 };
 /*
  * A list of block ID's is used to faster seek blocks.
  */
 struct tape_34xx_sbid {
 	struct list_head		list;
 	struct tape_34xx_block_id	bid;
 };
 static void tape_34xx_delete_sbid_from(struct tape_device *, int);
 /*
  * Medium sense for 34xx tapes. There is no 'real' medium sense call.
  * So we just do a normal sense.
  */
 static int
 tape_34xx_medium_sense(struct tape_device *device)
 {
 	struct tape_request *request;
 	unsigned char       *sense;
 	int                  rc;
 	request = tape_alloc_request(1, 32);
 	if (IS_ERR(request)) {
 		DBF_EXCEPTION(6, "MSEN fail\n");
 		return PTR_ERR(request);
 	}
 	request->op = TO_MSEN;
 	tape_ccw_end(request->cpaddr, SENSE, 32, request->cpdata);
 	rc = tape_do_io_interruptible(device, request);
 	if (request->rc == 0) {
 		sense = request->cpdata;
 		/*
 		 * This isn't quite correct. But since INTERVENTION_REQUIRED
 		 * means that the drive is 'neither ready nor on-line' it is
 		 * only slightly inaccurate to say there is no tape loaded if
 		 * the drive isn't online...
 		 */
 		if (sense[0] & SENSE_INTERVENTION_REQUIRED)
 			tape_med_state_set(device, MS_UNLOADED);
 		else
 			tape_med_state_set(device, MS_LOADED);
 		if (sense[1] & SENSE_WRITE_PROTECT)
 			device->tape_generic_status |= GMT_WR_PROT(~0);
 		else
 			device->tape_generic_status &= ~GMT_WR_PROT(~0);
 	} else {
 		DBF_EVENT(4, "tape_34xx: medium sense failed with rc=%d\n",
 			request->rc);
 	}
 	tape_free_request(request);
 	return rc;
 }
 struct tape_34xx_work {
 	struct tape_device	*device;
 	enum tape_op		 op;
 	struct work_struct	 work;
 };
 /*
  * These functions are currently used only to schedule a medium_sense for
  * later execution. This is because we get an interrupt whenever a medium
  * is inserted but cannot call tape_do_io* from an interrupt context.
  * Maybe that's useful for other actions we want to start from the
  * interrupt handler.
  */
 static void
 tape_34xx_work_handler(struct work_struct *work)
 {
 	struct tape_34xx_work *p =
 		container_of(work, struct tape_34xx_work, work);
 	struct tape_device *device = p->device;
 	switch(p->op) {
 		case TO_MSEN:
 			tape_34xx_medium_sense(device);
 			break;
 		default:
 			DBF_EVENT(3, "T34XX: internal error: unknown work\n");
 	}
 	tape_put_device(device);
 	kfree(p);
 }
 static int
 tape_34xx_schedule_work(struct tape_device *device, enum tape_op op)
 {
 	struct tape_34xx_work *p;
 	if ((p = kzalloc(sizeof(*p), GFP_ATOMIC)) == NULL)
 		return -ENOMEM;
 	INIT_WORK(&p->work, tape_34xx_work_handler);
 	p->device = tape_get_device(device);
 	p->op     = op;
 	schedule_work(&p->work);
 	return 0;
 }
 /*
  * Done Handler is called when dev stat = DEVICE-END (successful operation)
  */
 static inline int
 tape_34xx_done(struct tape_request *request)
 {
 	DBF_EVENT(6, "%s done\n", tape_op_verbose[request->op]);
 	switch (request->op) {
 		case TO_DSE:
 		case TO_RUN:
 		case TO_WRI:
 		case TO_WTM:
 		case TO_ASSIGN:
 		case TO_UNASSIGN:
 			tape_34xx_delete_sbid_from(request->device, 0);
 			break;
 		default:
 			;
 	}
 	return TAPE_IO_SUCCESS;
 }
 static inline int
 tape_34xx_erp_failed(struct tape_request *request, int rc)
 {
 	DBF_EVENT(3, "Error recovery failed for %s (RC=%d)\n",
 		  tape_op_verbose[request->op], rc);
 	return rc;
 }
 static inline int
 tape_34xx_erp_succeeded(struct tape_request *request)
 {
 	DBF_EVENT(3, "Error Recovery successful for %s\n",
 		  tape_op_verbose[request->op]);
 	return tape_34xx_done(request);
 }
 static inline int
 tape_34xx_erp_retry(struct tape_request *request)
 {
 	DBF_EVENT(3, "xerp retr %s\n", tape_op_verbose[request->op]);
 	return TAPE_IO_RETRY;
 }
 /*
  * This function is called, when no request is outstanding and we get an
  * interrupt
  */
 static int
 tape_34xx_unsolicited_irq(struct tape_device *device, struct irb *irb)
 {
 	if (irb->scsw.cmd.dstat == 0x85) { /* READY */
 		/* A medium was inserted in the drive. */
 		DBF_EVENT(6, "xuud med\n");
 		tape_34xx_delete_sbid_from(device, 0);
 		tape_34xx_schedule_work(device, TO_MSEN);
 	} else {
 		DBF_EVENT(3, "unsol.irq! dev end: %08x\n", device->cdev_id);
 		tape_dump_sense_dbf(device, NULL, irb);
 	}
 	return TAPE_IO_SUCCESS;
 }
 /*
  * Read Opposite Error Recovery Function:
  * Used, when Read Forward does not work
  */
 static int
 tape_34xx_erp_read_opposite(struct tape_device *device,
 			    struct tape_request *request)
 {
 	if (request->op == TO_RFO) {
 		/*
 		 * We did read forward, but the data could not be read
 		 * *correctly*. We transform the request to a read backward
 		 * and try again.
 		 */
 		tape_std_read_backward(device, request);
 		return tape_34xx_erp_retry(request);
 	}
 	/*
 	 * We tried to read forward and backward, but hat no
 	 * success -> failed.
 	 */
 	return tape_34xx_erp_failed(request, -EIO);
 }
 static int
 tape_34xx_erp_bug(struct tape_device *device, struct tape_request *request,
 		  struct irb *irb, int no)
 {
 	if (request->op != TO_ASSIGN) {
 		dev_err(&device->cdev->dev, "An unexpected condition %d "
 			"occurred in tape error recovery\n", no);
 		tape_dump_sense_dbf(device, request, irb);
 	}
 	return tape_34xx_erp_failed(request, -EIO);
 }
 /*
  * Handle data overrun between cu and drive. The channel speed might
  * be too slow.
  */
 static int
 tape_34xx_erp_overrun(struct tape_device *device, struct tape_request *request,
 		      struct irb *irb)
 {
 	if (irb->ecw[3] == 0x40) {
 		dev_warn (&device->cdev->dev, "A data overrun occurred between"
 			" the control unit and tape unit\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	}
 	return tape_34xx_erp_bug(device, request, irb, -1);
 }
 /*
  * Handle record sequence error.
  */
 static int
 tape_34xx_erp_sequence(struct tape_device *device,
 		       struct tape_request *request, struct irb *irb)
 {
 	if (irb->ecw[3] == 0x41) {
 		/*
 		 * cu detected incorrect block-id sequence on tape.
 		 */
 		dev_warn (&device->cdev->dev, "The block ID sequence on the "
 			"tape is incorrect\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	}
 	/*
 	 * Record sequence error bit is set, but erpa does not
 	 * show record sequence error.
 	 */
 	return tape_34xx_erp_bug(device, request, irb, -2);
 }
 /*
  * This function analyses the tape's sense-data in case of a unit-check.
  * If possible, it tries to recover from the error. Else the user is
  * informed about the problem.
  */
 static int
 tape_34xx_unit_check(struct tape_device *device, struct tape_request *request,
 		     struct irb *irb)
 {
 	int inhibit_cu_recovery;
 	__u8* sense;
 	inhibit_cu_recovery = (*device->modeset_byte & 0x80) ? 1 : 0;
 	sense = irb->ecw;
 #ifdef CONFIG_S390_TAPE_BLOCK
 	if (request->op == TO_BLOCK) {
 		/*
 		 * Recovery for block device requests. Set the block_position
 		 * to something invalid and retry.
 		 */
 		device->blk_data.block_position = -1;
 		if (request->retries-- <= 0)
 			return tape_34xx_erp_failed(request, -EIO);
 		else
 			return tape_34xx_erp_retry(request);
 	}
 #endif
 	if (
 		sense[0] & SENSE_COMMAND_REJECT &&
 		sense[1] & SENSE_WRITE_PROTECT
 	) {
 		if (
 			request->op == TO_DSE ||
 			request->op == TO_WRI ||
 			request->op == TO_WTM
 		) {
 			/* medium is write protected */
 			return tape_34xx_erp_failed(request, -EACCES);
 		} else {
 			return tape_34xx_erp_bug(device, request, irb, -3);
 		}
 	}
 	/*
 	 * Special cases for various tape-states when reaching
 	 * end of recorded area
 	 *
 	 * FIXME: Maybe a special case of the special case:
 	 *        sense[0] == SENSE_EQUIPMENT_CHECK &&
 	 *        sense[1] == SENSE_DRIVE_ONLINE    &&
 	 *        sense[3] == 0x47 (Volume Fenced)
 	 *
 	 *        This was caused by continued FSF or FSR after an
 	 *        'End Of Data'.
 	 */
 	if ((
 		sense[0] == SENSE_DATA_CHECK      ||
 		sense[0] == SENSE_EQUIPMENT_CHECK ||
 		sense[0] == SENSE_EQUIPMENT_CHECK + SENSE_DEFERRED_UNIT_CHECK
 	) && (
 		sense[1] == SENSE_DRIVE_ONLINE ||
 		sense[1] == SENSE_BEGINNING_OF_TAPE + SENSE_WRITE_MODE
 	)) {
 		switch (request->op) {
 		/*
 		 * sense[0] == SENSE_DATA_CHECK   &&
 		 * sense[1] == SENSE_DRIVE_ONLINE
 		 * sense[3] == 0x36 (End Of Data)
 		 *
 		 * Further seeks might return a 'Volume Fenced'.
 		 */
 		case TO_FSF:
 		case TO_FSB:
 			/* Trying to seek beyond end of recorded area */
 			return tape_34xx_erp_failed(request, -ENOSPC);
 		case TO_BSB:
 			return tape_34xx_erp_retry(request);
 		/*
 		 * sense[0] == SENSE_DATA_CHECK   &&
 		 * sense[1] == SENSE_DRIVE_ONLINE &&
 		 * sense[3] == 0x36 (End Of Data)
 		 */
 		case TO_LBL:
 			/* Block could not be located. */
 			tape_34xx_delete_sbid_from(device, 0);
 			return tape_34xx_erp_failed(request, -EIO);
 		case TO_RFO:
 			/* Read beyond end of recorded area -> 0 bytes read */
 			return tape_34xx_erp_failed(request, 0);
 		/*
 		 * sense[0] == SENSE_EQUIPMENT_CHECK &&
 		 * sense[1] == SENSE_DRIVE_ONLINE    &&
 		 * sense[3] == 0x38 (Physical End Of Volume)
 		 */
 		case TO_WRI:
 			/* Writing at physical end of volume */
 			return tape_34xx_erp_failed(request, -ENOSPC);
 		default:
 			return tape_34xx_erp_failed(request, 0);
 		}
 	}
 	/* Sensing special bits */
 	if (sense[0] & SENSE_BUS_OUT_CHECK)
 		return tape_34xx_erp_retry(request);
 	if (sense[0] & SENSE_DATA_CHECK) {
 		/*
 		 * hardware failure, damaged tape or improper
 		 * operating conditions
 		 */
 		switch (sense[3]) {
 		case 0x23:
 			/* a read data check occurred */
 			if ((sense[2] & SENSE_TAPE_SYNC_MODE) ||
 			    inhibit_cu_recovery)
 				// data check is not permanent, may be
 				// recovered. We always use async-mode with
 				// cu-recovery, so this should *never* happen.
 				return tape_34xx_erp_bug(device, request,
 							 irb, -4);
 			/* data check is permanent, CU recovery has failed */
 			dev_warn (&device->cdev->dev, "A read error occurred "
 				"that cannot be recovered\n");
 			return tape_34xx_erp_failed(request, -EIO);
 		case 0x25:
 			// a write data check occurred
 			if ((sense[2] & SENSE_TAPE_SYNC_MODE) ||
 			    inhibit_cu_recovery)
 				// data check is not permanent, may be
 				// recovered. We always use async-mode with
 				// cu-recovery, so this should *never* happen.
 				return tape_34xx_erp_bug(device, request,
 							 irb, -5);
 			// data check is permanent, cu-recovery has failed
 			dev_warn (&device->cdev->dev, "A write error on the "
 				"tape cannot be recovered\n");
 			return tape_34xx_erp_failed(request, -EIO);
 		case 0x26:
 			/* Data Check (read opposite) occurred. */
 			return tape_34xx_erp_read_opposite(device, request);
 		case 0x28:
 			/* ID-Mark at tape start couldn't be written */
 			dev_warn (&device->cdev->dev, "Writing the ID-mark "
 				"failed\n");
 			return tape_34xx_erp_failed(request, -EIO);
 		case 0x31:
 			/* Tape void. Tried to read beyond end of device. */
 			dev_warn (&device->cdev->dev, "Reading the tape beyond"
 				" the end of the recorded area failed\n");
 			return tape_34xx_erp_failed(request, -ENOSPC);
 		case 0x41:
 			/* Record sequence error. */
 			dev_warn (&device->cdev->dev, "The tape contains an "
 				"incorrect block ID sequence\n");
 			return tape_34xx_erp_failed(request, -EIO);
 		default:
 			/* all data checks for 3480 should result in one of
 			 * the above erpa-codes. For 3490, other data-check
 			 * conditions do exist. */
 			if (device->cdev->id.driver_info == tape_3480)
 				return tape_34xx_erp_bug(device, request,
 							 irb, -6);
 		}
 	}
 	if (sense[0] & SENSE_OVERRUN)
 		return tape_34xx_erp_overrun(device, request, irb);
 	if (sense[1] & SENSE_RECORD_SEQUENCE_ERR)
 		return tape_34xx_erp_sequence(device, request, irb);
 	/* Sensing erpa codes */
 	switch (sense[3]) {
 	case 0x00:
 		/* Unit check with erpa code 0. Report and ignore. */
 		return TAPE_IO_SUCCESS;
 	case 0x21:
 		/*
 		 * Data streaming not operational. CU will switch to
 		 * interlock mode. Reissue the command.
 		 */
 		return tape_34xx_erp_retry(request);
 	case 0x22:
 		/*
 		 * Path equipment check. Might be drive adapter error, buffer
 		 * error on the lower interface, internal path not usable,
 		 * or error during cartridge load.
 		 */
 		dev_warn (&device->cdev->dev, "A path equipment check occurred"
 			" for the tape device\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x24:
 		/*
 		 * Load display check. Load display was command was issued,
 		 * but the drive is displaying a drive check message. Can
 		 * be threated as "device end".
 		 */
 		return tape_34xx_erp_succeeded(request);
 	case 0x27:
 		/*
 		 * Command reject. May indicate illegal channel program or
 		 * buffer over/underrun. Since all channel programs are
 		 * issued by this driver and ought be correct, we assume a
 		 * over/underrun situation and retry the channel program.
 		 */
 		return tape_34xx_erp_retry(request);
 	case 0x29:
 		/*
 		 * Function incompatible. Either the tape is idrc compressed
 		 * but the hardware isn't capable to do idrc, or a perform
 		 * subsystem func is issued and the CU is not on-line.
 		 */
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x2a:
 		/*
 		 * Unsolicited environmental data. An internal counter
 		 * overflows, we can ignore this and reissue the cmd.
 		 */
 		return tape_34xx_erp_retry(request);
 	case 0x2b:
 		/*
 		 * Environmental data present. Indicates either unload
 		 * completed ok or read buffered log command completed ok.
 		 */
 		if (request->op == TO_RUN) {
 			/* Rewind unload completed ok. */
 			tape_med_state_set(device, MS_UNLOADED);
 			return tape_34xx_erp_succeeded(request);
 		}
 		/* tape_34xx doesn't use read buffered log commands. */
 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
 	case 0x2c:
 		/*
 		 * Permanent equipment check. CU has tried recovery, but
 		 * did not succeed.
 		 */
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x2d:
 		/* Data security erase failure. */
 		if (request->op == TO_DSE)
 			return tape_34xx_erp_failed(request, -EIO);
 		/* Data security erase failure, but no such command issued. */
 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
 	case 0x2e:
 		/*
 		 * Not capable. This indicates either that the drive fails
 		 * reading the format id mark or that that format specified
 		 * is not supported by the drive.
 		 */
 		dev_warn (&device->cdev->dev, "The tape unit cannot process "
 			"the tape format\n");
 		return tape_34xx_erp_failed(request, -EMEDIUMTYPE);
 	case 0x30:
 		/* The medium is write protected. */
 		dev_warn (&device->cdev->dev, "The tape medium is write-"
 			"protected\n");
 		return tape_34xx_erp_failed(request, -EACCES);
 	case 0x32:
 		// Tension loss. We cannot recover this, it's an I/O error.
 		dev_warn (&device->cdev->dev, "The tape does not have the "
 			"required tape tension\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x33:
 		/*
 		 * Load Failure. The cartridge was not inserted correctly or
 		 * the tape is not threaded correctly.
 		 */
 		dev_warn (&device->cdev->dev, "The tape unit failed to load"
 			" the cartridge\n");
 		tape_34xx_delete_sbid_from(device, 0);
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x34:
 		/*
 		 * Unload failure. The drive cannot maintain tape tension
 		 * and control tape movement during an unload operation.
 		 */
 		dev_warn (&device->cdev->dev, "Automatic unloading of the tape"
 			" cartridge failed\n");
 		if (request->op == TO_RUN)
 			return tape_34xx_erp_failed(request, -EIO);
 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
 	case 0x35:
 		/*
 		 * Drive equipment check. One of the following:
 		 * - cu cannot recover from a drive detected error
 		 * - a check code message is shown on drive display
 		 * - the cartridge loader does not respond correctly
 		 * - a failure occurs during an index, load, or unload cycle
 		 */
 		dev_warn (&device->cdev->dev, "An equipment check has occurred"
 			" on the tape unit\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x36:
 		if (device->cdev->id.driver_info == tape_3490)
 			/* End of data. */
 			return tape_34xx_erp_failed(request, -EIO);
 		/* This erpa is reserved for 3480 */
 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
 	case 0x37:
 		/*
 		 * Tape length error. The tape is shorter than reported in
 		 * the beginning-of-tape data.
 		 */
 		dev_warn (&device->cdev->dev, "The tape information states an"
 			" incorrect length\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x38:
 		/*
 		 * Physical end of tape. A read/write operation reached
 		 * the physical end of tape.
 		 */
 		if (request->op==TO_WRI ||
 		    request->op==TO_DSE ||
 		    request->op==TO_WTM)
 			return tape_34xx_erp_failed(request, -ENOSPC);
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x39:
 		/* Backward at Beginning of tape. */
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x3a:
 		/* Drive switched to not ready. */
 		dev_warn (&device->cdev->dev, "The tape unit is not ready\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x3b:
 		/* Manual rewind or unload. This causes an I/O error. */
 		dev_warn (&device->cdev->dev, "The tape medium has been "
 			"rewound or unloaded manually\n");
 		tape_34xx_delete_sbid_from(device, 0);
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x42:
 		/*
 		 * Degraded mode. A condition that can cause degraded
 		 * performance is detected.
 		 */
 		dev_warn (&device->cdev->dev, "The tape subsystem is running "
 			"in degraded mode\n");
 		return tape_34xx_erp_retry(request);
 	case 0x43:
 		/* Drive not ready. */
 		tape_34xx_delete_sbid_from(device, 0);
 		tape_med_state_set(device, MS_UNLOADED);
 		/* Some commands commands are successful even in this case */
 		if (sense[1] & SENSE_DRIVE_ONLINE) {
 			switch(request->op) {
 				case TO_ASSIGN:
 				case TO_UNASSIGN:
 				case TO_DIS:
 				case TO_NOP:
 					return tape_34xx_done(request);
 					break;
 				default:
 					break;
 			}
 		}
 		return tape_34xx_erp_failed(request, -ENOMEDIUM);
 	case 0x44:
 		/* Locate Block unsuccessful. */
 		if (request->op != TO_BLOCK && request->op != TO_LBL)
 			/* No locate block was issued. */
 			return tape_34xx_erp_bug(device, request,
 						 irb, sense[3]);
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x45:
 		/* The drive is assigned to a different channel path. */
 		dev_warn (&device->cdev->dev, "The tape unit is already "
 			"assigned\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x46:
 		/*
 		 * Drive not on-line. Drive may be switched offline,
 		 * the power supply may be switched off or
 		 * the drive address may not be set correctly.
 		 */
 		dev_warn (&device->cdev->dev, "The tape unit is not online\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x47:
 		/* Volume fenced. CU reports volume integrity is lost. */
 		dev_warn (&device->cdev->dev, "The control unit has fenced "
 			"access to the tape volume\n");
 		tape_34xx_delete_sbid_from(device, 0);
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x48:
 		/* Log sense data and retry request. */
 		return tape_34xx_erp_retry(request);
 	case 0x49:
 		/* Bus out check. A parity check error on the bus was found. */
 		dev_warn (&device->cdev->dev, "A parity error occurred on the "
 			"tape bus\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x4a:
 		/* Control unit erp failed. */
 		dev_warn (&device->cdev->dev, "I/O error recovery failed on "
 			"the tape control unit\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x4b:
 		/*
 		 * CU and drive incompatible. The drive requests micro-program
 		 * patches, which are not available on the CU.
 		 */
 		dev_warn (&device->cdev->dev, "The tape unit requires a "
 			"firmware update\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x4c:
 		/*
 		 * Recovered Check-One failure. Cu develops a hardware error,
 		 * but is able to recover.
 		 */
 		return tape_34xx_erp_retry(request);
 	case 0x4d:
 		if (device->cdev->id.driver_info == tape_3490)
 			/*
 			 * Resetting event received. Since the driver does
 			 * not support resetting event recovery (which has to
 			 * be handled by the I/O Layer), retry our command.
 			 */
 			return tape_34xx_erp_retry(request);
 		/* This erpa is reserved for 3480. */
 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
 	case 0x4e:
 		if (device->cdev->id.driver_info == tape_3490) {
 			/*
 			 * Maximum block size exceeded. This indicates, that
 			 * the block to be written is larger than allowed for
 			 * buffered mode.
 			 */
 			dev_warn (&device->cdev->dev, "The maximum block size"
 				" for buffered mode is exceeded\n");
 			return tape_34xx_erp_failed(request, -ENOBUFS);
 		}
 		/* This erpa is reserved for 3480. */
 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
 	case 0x50:
 		/*
 		 * Read buffered log (Overflow). CU is running in extended
 		 * buffered log mode, and a counter overflows. This should
 		 * never happen, since we're never running in extended
 		 * buffered log mode.
 		 */
 		return tape_34xx_erp_retry(request);
 	case 0x51:
 		/*
 		 * Read buffered log (EOV). EOF processing occurs while the
 		 * CU is in extended buffered log mode. This should never
 		 * happen, since we're never running in extended buffered
 		 * log mode.
 		 */
 		return tape_34xx_erp_retry(request);
 	case 0x52:
 		/* End of Volume complete. Rewind unload completed ok. */
 		if (request->op == TO_RUN) {
 			tape_med_state_set(device, MS_UNLOADED);
 			tape_34xx_delete_sbid_from(device, 0);
 			return tape_34xx_erp_succeeded(request);
 		}
 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
 	case 0x53:
 		/* Global command intercept. */
 		return tape_34xx_erp_retry(request);
 	case 0x54:
 		/* Channel interface recovery (temporary). */
 		return tape_34xx_erp_retry(request);
 	case 0x55:
 		/* Channel interface recovery (permanent). */
 		dev_warn (&device->cdev->dev, "A channel interface error cannot be"
 			" recovered\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x56:
 		/* Channel protocol error. */
 		dev_warn (&device->cdev->dev, "A channel protocol error "
 			"occurred\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x57:
 		if (device->cdev->id.driver_info == tape_3480) {
 			/* Attention intercept. */
 			return tape_34xx_erp_retry(request);
 		} else {
 			/* Global status intercept. */
 			return tape_34xx_erp_retry(request);
 		}
 	case 0x5a:
 		/*
 		 * Tape length incompatible. The tape inserted is too long,
 		 * which could cause damage to the tape or the drive.
 		 */
 		dev_warn (&device->cdev->dev, "The tape unit does not support "
 			"the tape length\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x5b:
 		/* Format 3480 XF incompatible */
 		if (sense[1] & SENSE_BEGINNING_OF_TAPE)
 			/* The tape will get overwritten. */
 			return tape_34xx_erp_retry(request);
 		dev_warn (&device->cdev->dev, "The tape unit does not support"
 			" format 3480 XF\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x5c:
 		/* Format 3480-2 XF incompatible */
 		dev_warn (&device->cdev->dev, "The tape unit does not support tape "
 			"format 3480-2 XF\n");
 		return tape_34xx_erp_failed(request, -EIO);
 	case 0x5d:
 		/* Tape length violation. */
 		dev_warn (&device->cdev->dev, "The tape unit does not support"
 			" the current tape length\n");
 		return tape_34xx_erp_failed(request, -EMEDIUMTYPE);
 	case 0x5e:
 		/* Compaction algorithm incompatible. */
 		dev_warn (&device->cdev->dev, "The tape unit does not support"
 			" the compaction algorithm\n");
 		return tape_34xx_erp_failed(request, -EMEDIUMTYPE);
 		/* The following erpas should have been covered earlier. */
 	case 0x23: /* Read data check. */
 	case 0x25: /* Write data check. */
 	case 0x26: /* Data check (read opposite). */
 	case 0x28: /* Write id mark check. */
 	case 0x31: /* Tape void. */
 	case 0x40: /* Overrun error. */
 	case 0x41: /* Record sequence error. */
 		/* All other erpas are reserved for future use. */
 	default:
 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
 	}
 }
 /*
  * 3480/3490 interrupt handler
  */
 static int
 tape_34xx_irq(struct tape_device *device, struct tape_request *request,
 	      struct irb *irb)
 {
 	if (request == NULL)
 		return tape_34xx_unsolicited_irq(device, irb);
 	if ((irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) &&
 	    (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) &&
 	    (request->op == TO_WRI)) {
 		/* Write at end of volume */
 		return tape_34xx_erp_failed(request, -ENOSPC);
 	}
 	if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)
 		return tape_34xx_unit_check(device, request, irb);
 	if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) {
 		/*
 		 * A unit exception occurs on skipping over a tapemark block.
 		 */
 		if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) {
 			if (request->op == TO_BSB || request->op == TO_FSB)
 				request->rescnt++;
 			else
 				DBF_EVENT(5, "Unit Exception!\n");
 		}
 		return tape_34xx_done(request);
 	}
 	DBF_EVENT(6, "xunknownirq\n");
 	tape_dump_sense_dbf(device, request, irb);
 	return TAPE_IO_STOP;
 }
 /*
  * ioctl_overload
  */
 static int
 tape_34xx_ioctl(struct tape_device *device, unsigned int cmd, unsigned long arg)
 {
 	if (cmd == TAPE390_DISPLAY) {
 		struct display_struct disp;
 		if (copy_from_user(&disp, (char __user *) arg, sizeof(disp)) != 0)
 			return -EFAULT;
 		return tape_std_display(device, &disp);
 	} else
 		return -EINVAL;
 }
 static inline void
 tape_34xx_append_new_sbid(struct tape_34xx_block_id bid, struct list_head *l)
 {
 	struct tape_34xx_sbid *	new_sbid;
 	new_sbid = kmalloc(sizeof(*new_sbid), GFP_ATOMIC);
 	if (!new_sbid)
 		return;
 	new_sbid->bid = bid;
 	list_add(&new_sbid->list, l);
 }
 /*
  * Build up the search block ID list. The block ID consists of a logical
  * block number and a hardware specific part. The hardware specific part
  * helps the tape drive to speed up searching for a specific block.
  */
 static void
 tape_34xx_add_sbid(struct tape_device *device, struct tape_34xx_block_id bid)
 {
 	struct list_head *	sbid_list;
 	struct tape_34xx_sbid *	sbid;
 	struct list_head *	l;
 	/*
 	 * immediately return if there is no list at all or the block to add
 	 * is located in segment 1 of wrap 0 because this position is used
 	 * if no hardware position data is supplied.
 	 */
 	sbid_list = (struct list_head *) device->discdata;
 	if (!sbid_list || (bid.segment < 2 && bid.wrap == 0))
 		return;
 	/*
 	 * Search the position where to insert the new entry. Hardware
 	 * acceleration uses only the segment and wrap number. So we
 	 * need only one entry for a specific wrap/segment combination.
 	 * If there is a block with a lower number but the same hard-
 	 * ware position data we just update the block number in the
 	 * existing entry.
 	 */
 	list_for_each(l, sbid_list) {
 		sbid = list_entry(l, struct tape_34xx_sbid, list);
 		if (
 			(sbid->bid.segment == bid.segment) &&
 			(sbid->bid.wrap    == bid.wrap)
 		) {
 			if (bid.block < sbid->bid.block)
 				sbid->bid = bid;
 			else return;
 			break;
 		}
 		/* Sort in according to logical block number. */
 		if (bid.block < sbid->bid.block) {
 			tape_34xx_append_new_sbid(bid, l->prev);
 			break;
 		}
 	}
 	/* List empty or new block bigger than last entry. */
 	if (l == sbid_list)
 		tape_34xx_append_new_sbid(bid, l->prev);
 	DBF_LH(4, "Current list is:\n");
 	list_for_each(l, sbid_list) {
 		sbid = list_entry(l, struct tape_34xx_sbid, list);
 		DBF_LH(4, "%d:%03d@%05d\n",
 			sbid->bid.wrap,
 			sbid->bid.segment,
 			sbid->bid.block
 		);
 	}
 }
 /*
  * Delete all entries from the search block ID list that belong to tape blocks
  * equal or higher than the given number.
  */
 static void
 tape_34xx_delete_sbid_from(struct tape_device *device, int from)
 {
 	struct list_head *	sbid_list;
 	struct tape_34xx_sbid *	sbid;
 	struct list_head *	l;
 	struct list_head *	n;
 	sbid_list = (struct list_head *) device->discdata;
 	if (!sbid_list)
 		return;
 	list_for_each_safe(l, n, sbid_list) {
 		sbid = list_entry(l, struct tape_34xx_sbid, list);
 		if (sbid->bid.block >= from) {
 			DBF_LH(4, "Delete sbid %d:%03d@%05d\n",
 				sbid->bid.wrap,
 				sbid->bid.segment,
 				sbid->bid.block
 			);
 			list_del(l);
 			kfree(sbid);
 		}
 	}
 }
 /*
  * Merge hardware position data into a block id.
  */
 static void
 tape_34xx_merge_sbid(
 	struct tape_device *		device,
 	struct tape_34xx_block_id *	bid
 ) {
 	struct tape_34xx_sbid *	sbid;
 	struct tape_34xx_sbid *	sbid_to_use;
 	struct list_head *	sbid_list;
 	struct list_head *	l;
 	sbid_list = (struct list_head *) device->discdata;
 	bid->wrap    = 0;
 	bid->segment = 1;
 	if (!sbid_list || list_empty(sbid_list))
 		return;
 	sbid_to_use = NULL;
 	list_for_each(l, sbid_list) {
 		sbid = list_entry(l, struct tape_34xx_sbid, list);
 		if (sbid->bid.block >= bid->block)
 			break;
 		sbid_to_use = sbid;
 	}
 	if (sbid_to_use) {
 		bid->wrap    = sbid_to_use->bid.wrap;
 		bid->segment = sbid_to_use->bid.segment;
 		DBF_LH(4, "Use %d:%03d@%05d for %05d\n",
 			sbid_to_use->bid.wrap,
 			sbid_to_use->bid.segment,
 			sbid_to_use->bid.block,
 			bid->block
 		);
 	}
 }
 static int
 tape_34xx_setup_device(struct tape_device * device)
 {
 	int			rc;
 	struct list_head *	discdata;
 	DBF_EVENT(6, "34xx device setup\n");
 	if ((rc = tape_std_assign(device)) == 0) {
 		if ((rc = tape_34xx_medium_sense(device)) != 0) {
 			DBF_LH(3, "34xx medium sense returned %d\n", rc);
 		}
 	}
 	discdata = kmalloc(sizeof(struct list_head), GFP_KERNEL);
 	if (discdata) {
 			INIT_LIST_HEAD(discdata);
 			device->discdata = discdata;
 	}
 	return rc;
 }
 static void
 tape_34xx_cleanup_device(struct tape_device *device)
 {
 	tape_std_unassign(device);
 	if (device->discdata) {
 		tape_34xx_delete_sbid_from(device, 0);
 		kfree(device->discdata);
 		device->discdata = NULL;
 	}
 }
 /*
  * MTTELL: Tell block. Return the number of block relative to current file.
  */
 static int
 tape_34xx_mttell(struct tape_device *device, int mt_count)
 {
 	struct {
 		struct tape_34xx_block_id	cbid;
 		struct tape_34xx_block_id	dbid;
 	} __attribute__ ((packed)) block_id;
 	int rc;
 	rc = tape_std_read_block_id(device, (__u64 *) &block_id);
 	if (rc)
 		return rc;
 	tape_34xx_add_sbid(device, block_id.cbid);
 	return block_id.cbid.block;
 }
 /*
  * MTSEEK: seek to the specified block.
  */
 static int
 tape_34xx_mtseek(struct tape_device *device, int mt_count)
 {
 	struct tape_request *request;
 	struct tape_34xx_block_id *	bid;
 	if (mt_count > 0x3fffff) {
 		DBF_EXCEPTION(6, "xsee parm\n");
 		return -EINVAL;
 	}
 	request = tape_alloc_request(3, 4);
 	if (IS_ERR(request))
 		return PTR_ERR(request);
 	/* setup ccws */
 	request->op = TO_LBL;
 	bid         = (struct tape_34xx_block_id *) request->cpdata;
 	bid->format = (*device->modeset_byte & 0x08) ?
 			TAPE34XX_FMT_3480_XF : TAPE34XX_FMT_3480;
 	bid->block  = mt_count;
 	tape_34xx_merge_sbid(device, bid);
 	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
 	tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
 	tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
 	/* execute it */
 	return tape_do_io_free(device, request);
 }
 #ifdef CONFIG_S390_TAPE_BLOCK
 /*
  * Tape block read for 34xx.
  */
 static struct tape_request *
 tape_34xx_bread(struct tape_device *device, struct request *req)
 {
 	struct tape_request *request;
 	struct ccw1 *ccw;
 	int count = 0;
 	unsigned off;
 	char *dst;
 	struct bio_vec *bv;
 	struct req_iterator iter;
 	struct tape_34xx_block_id *	start_block;
 	DBF_EVENT(6, "xBREDid:");
 	/* Count the number of blocks for the request. */
 	rq_for_each_segment(bv, req, iter)
 		count += bv->bv_len >> (TAPEBLOCK_HSEC_S2B + 9);
 	/* Allocate the ccw request. */
 	request = tape_alloc_request(3+count+1, 8);
 	if (IS_ERR(request))
 		return request;
 	/* Setup ccws. */
 	request->op = TO_BLOCK;
 	start_block = (struct tape_34xx_block_id *) request->cpdata;
 	start_block->block = blk_rq_pos(req) >> TAPEBLOCK_HSEC_S2B;
 	DBF_EVENT(6, "start_block = %i\n", start_block->block);
 	ccw = request->cpaddr;
 	ccw = tape_ccw_cc(ccw, MODE_SET_DB, 1, device->modeset_byte);
 	/*
 	 * We always setup a nop after the mode set ccw. This slot is
 	 * used in tape_std_check_locate to insert a locate ccw if the
 	 * current tape position doesn't match the start block to be read.
 	 * The second nop will be filled with a read block id which is in
 	 * turn used by tape_34xx_free_bread to populate the segment bid
 	 * table.
 	 */
 	ccw = tape_ccw_cc(ccw, NOP, 0, NULL);
 	ccw = tape_ccw_cc(ccw, NOP, 0, NULL);
 	rq_for_each_segment(bv, req, iter) {
 		dst = kmap(bv->bv_page) + bv->bv_offset;
 		for (off = 0; off < bv->bv_len; off += TAPEBLOCK_HSEC_SIZE) {
 			ccw->flags = CCW_FLAG_CC;
 			ccw->cmd_code = READ_FORWARD;
 			ccw->count = TAPEBLOCK_HSEC_SIZE;
 			set_normalized_cda(ccw, (void*) __pa(dst));
 			ccw++;
 			dst += TAPEBLOCK_HSEC_SIZE;
 		}
 	}
 	ccw = tape_ccw_end(ccw, NOP, 0, NULL);
 	DBF_EVENT(6, "xBREDccwg\n");
 	return request;
 }
 static void
 tape_34xx_free_bread (struct tape_request *request)
 {
 	struct ccw1* ccw;
 	ccw = request->cpaddr;
 	if ((ccw + 2)->cmd_code == READ_BLOCK_ID) {
 		struct {
 			struct tape_34xx_block_id	cbid;
 			struct tape_34xx_block_id	dbid;
 		} __attribute__ ((packed)) *rbi_data;
 		rbi_data = request->cpdata;
 		if (request->device)
 			tape_34xx_add_sbid(request->device, rbi_data->cbid);
 	}
 	/* Last ccw is a nop and doesn't need clear_normalized_cda */
 	for (; ccw->flags & CCW_FLAG_CC; ccw++)
 		if (ccw->cmd_code == READ_FORWARD)
 			clear_normalized_cda(ccw);
 	tape_free_request(request);
 }
 /*
  * check_locate is called just before the tape request is passed to
  * the common io layer for execution. It has to check the current
  * tape position and insert a locate ccw if it doesn't match the
  * start block for the request.
  */
 static void
 tape_34xx_check_locate(struct tape_device *device, struct tape_request *request)
 {
 	struct tape_34xx_block_id *	start_block;
 	start_block = (struct tape_34xx_block_id *) request->cpdata;
 	if (start_block->block == device->blk_data.block_position)
 		return;
 	DBF_LH(4, "Block seek(%06d+%06d)\n", start_block->block, device->bof);
 	start_block->wrap    = 0;
 	start_block->segment = 1;
 	start_block->format  = (*device->modeset_byte & 0x08) ?
 				TAPE34XX_FMT_3480_XF :
 				TAPE34XX_FMT_3480;
 	start_block->block   = start_block->block + device->bof;
 	tape_34xx_merge_sbid(device, start_block);
 	tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
 	tape_ccw_cc(request->cpaddr + 2, READ_BLOCK_ID, 8, request->cpdata);
 }
 #endif
 /*
  * List of 3480/3490 magnetic tape commands.
  */
 static tape_mtop_fn tape_34xx_mtop[TAPE_NR_MTOPS] = {
 	[MTRESET]	 = tape_std_mtreset,
 	[MTFSF]		 = tape_std_mtfsf,
 	[MTBSF]		 = tape_std_mtbsf,
 	[MTFSR]		 = tape_std_mtfsr,
 	[MTBSR]		 = tape_std_mtbsr,
 	[MTWEOF]	 = tape_std_mtweof,
 	[MTREW]		 = tape_std_mtrew,
 	[MTOFFL]	 = tape_std_mtoffl,
 	[MTNOP]		 = tape_std_mtnop,
 	[MTRETEN]	 = tape_std_mtreten,
 	[MTBSFM]	 = tape_std_mtbsfm,
 	[MTFSFM]	 = tape_std_mtfsfm,
 	[MTEOM]		 = tape_std_mteom,
 	[MTERASE]	 = tape_std_mterase,
 	[MTRAS1]	 = NULL,
 	[MTRAS2]	 = NULL,
 	[MTRAS3]	 = NULL,
 	[MTSETBLK]	 = tape_std_mtsetblk,
 	[MTSETDENSITY]	 = NULL,
 	[MTSEEK]	 = tape_34xx_mtseek,
 	[MTTELL]	 = tape_34xx_mttell,
 	[MTSETDRVBUFFER] = NULL,
 	[MTFSS]		 = NULL,
 	[MTBSS]		 = NULL,
 	[MTWSM]		 = NULL,
 	[MTLOCK]	 = NULL,
 	[MTUNLOCK]	 = NULL,
 	[MTLOAD]	 = tape_std_mtload,
 	[MTUNLOAD]	 = tape_std_mtunload,
 	[MTCOMPRESSION]	 = tape_std_mtcompression,
 	[MTSETPART]	 = NULL,
 	[MTMKPART]	 = NULL
 };
 /*
  * Tape discipline structure for 3480 and 3490.
  */
 static struct tape_discipline tape_discipline_34xx = {
 	.owner = THIS_MODULE,
 	.setup_device = tape_34xx_setup_device,
 	.cleanup_device = tape_34xx_cleanup_device,
 	.process_eov = tape_std_process_eov,
 	.irq = tape_34xx_irq,
 	.read_block = tape_std_read_block,
 	.write_block = tape_std_write_block,
 #ifdef CONFIG_S390_TAPE_BLOCK
 	.bread = tape_34xx_bread,
 	.free_bread = tape_34xx_free_bread,
 	.check_locate = tape_34xx_check_locate,
 #endif
 	.ioctl_fn = tape_34xx_ioctl,
 	.mtop_array = tape_34xx_mtop
 };
 static struct ccw_device_id tape_34xx_ids[] = {
 	{ CCW_DEVICE_DEVTYPE(0x3480, 0, 0x3480, 0), .driver_info = tape_3480},
 	{ CCW_DEVICE_DEVTYPE(0x3490, 0, 0x3490, 0), .driver_info = tape_3490},
 	{ /* end of list */ },
 };
 static int
 tape_34xx_online(struct ccw_device *cdev)
 {
 	return tape_generic_online(
 		dev_get_drvdata(&cdev->dev),
 		&tape_discipline_34xx
 	);
 }
 static struct ccw_driver tape_34xx_driver = {
 	.name = "tape_34xx",
 	.owner = THIS_MODULE,
 	.ids = tape_34xx_ids,
 	.probe = tape_generic_probe,
 	.remove = tape_generic_remove,
 	.set_online = tape_34xx_online,
 	.set_offline = tape_generic_offline,
 	.freeze = tape_generic_pm_suspend,
 };
 static int
 tape_34xx_init (void)
 {
 	int rc;
 	TAPE_DBF_AREA = debug_register ( "tape_34xx", 2, 2, 4*sizeof(long));
 	debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
 #ifdef DBF_LIKE_HELL
 	debug_set_level(TAPE_DBF_AREA, 6);
 #endif
 	DBF_EVENT(3, "34xx init\n");
 	/* Register driver for 3480/3490 tapes. */
 	rc = ccw_driver_register(&tape_34xx_driver);
 	if (rc)
 		DBF_EVENT(3, "34xx init failed\n");
 	else
 		DBF_EVENT(3, "34xx registered\n");
 	return rc;
 }
 static void
 tape_34xx_exit(void)
 {
 	ccw_driver_unregister(&tape_34xx_driver);
 	debug_unregister(TAPE_DBF_AREA);
 }
 MODULE_DEVICE_TABLE(ccw, tape_34xx_ids);
 MODULE_AUTHOR("(C) 2001-2002 IBM Deutschland Entwicklung GmbH");
 MODULE_DESCRIPTION("Linux on zSeries channel attached 3480 tape device driver");
 MODULE_LICENSE("GPL");
 module_init(tape_34xx_init);
 module_exit(tape_34xx_exit);

drivers/s390/char/tape_3590.c

Diff comments View file @ bb50991

 /*
  *  drivers/s390/char/tape_3590.c
  *    tape device discipline for 3590 tapes.
  *
  *    Copyright IBM Corp. 2001, 2009
  *    Author(s): Stefan Bader <shbader@de.ibm.com>
  *		 Michael Holzheu <holzheu@de.ibm.com>
  *		 Martin Schwidefsky <schwidefsky@de.ibm.com>
  */
 #define KMSG_COMPONENT "tape_3590"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/bio.h>
 #include <asm/ebcdic.h>
 #define TAPE_DBF_AREA	tape_3590_dbf
 #define BUFSIZE 512	/* size of buffers for dynamic generated messages */
 #include "tape.h"
 #include "tape_std.h"
 #include "tape_3590.h"
 /*
  * Pointer to debug area.
  */
 debug_info_t *TAPE_DBF_AREA = NULL;
 EXPORT_SYMBOL(TAPE_DBF_AREA);
 /*******************************************************************
  * Error Recovery fuctions:
  * - Read Opposite:		 implemented
  * - Read Device (buffered) log: BRA
  * - Read Library log:		 BRA
  * - Swap Devices:		 BRA
  * - Long Busy:			 implemented
  * - Special Intercept:		 BRA
  * - Read Alternate:		 implemented
  *******************************************************************/
 static const char *tape_3590_msg[TAPE_3590_MAX_MSG] = {
 	[0x00] = "",
 	[0x10] = "Lost Sense",
 	[0x11] = "Assigned Elsewhere",
 	[0x12] = "Allegiance Reset",
 	[0x13] = "Shared Access Violation",
 	[0x20] = "Command Reject",
 	[0x21] = "Configuration Error",
 	[0x22] = "Protection Exception",
 	[0x23] = "Write Protect",
 	[0x24] = "Write Length",
 	[0x25] = "Read-Only Format",
 	[0x31] = "Beginning of Partition",
 	[0x33] = "End of Partition",
 	[0x34] = "End of Data",
 	[0x35] = "Block not found",
 	[0x40] = "Device Intervention",
 	[0x41] = "Loader Intervention",
 	[0x42] = "Library Intervention",
 	[0x50] = "Write Error",
 	[0x51] = "Erase Error",
 	[0x52] = "Formatting Error",
 	[0x53] = "Read Error",
 	[0x54] = "Unsupported Format",
 	[0x55] = "No Formatting",
 	[0x56] = "Positioning lost",
 	[0x57] = "Read Length",
 	[0x60] = "Unsupported Medium",
 	[0x61] = "Medium Length Error",
 	[0x62] = "Medium removed",
 	[0x64] = "Load Check",
 	[0x65] = "Unload Check",
 	[0x70] = "Equipment Check",
 	[0x71] = "Bus out Check",
 	[0x72] = "Protocol Error",
 	[0x73] = "Interface Error",
 	[0x74] = "Overrun",
 	[0x75] = "Halt Signal",
 	[0x90] = "Device fenced",
 	[0x91] = "Device Path fenced",
 	[0xa0] = "Volume misplaced",
 	[0xa1] = "Volume inaccessible",
 	[0xa2] = "Volume in input",
 	[0xa3] = "Volume ejected",
 	[0xa4] = "All categories reserved",
 	[0xa5] = "Duplicate Volume",
 	[0xa6] = "Library Manager Offline",
 	[0xa7] = "Library Output Station full",
 	[0xa8] = "Vision System non-operational",
 	[0xa9] = "Library Manager Equipment Check",
 	[0xaa] = "Library Equipment Check",
 	[0xab] = "All Library Cells full",
 	[0xac] = "No Cleaner Volumes in Library",
 	[0xad] = "I/O Station door open",
 	[0xae] = "Subsystem environmental alert",
 };
 static int crypt_supported(struct tape_device *device)
 {
 	return TAPE390_CRYPT_SUPPORTED(TAPE_3590_CRYPT_INFO(device));
 }
 static int crypt_enabled(struct tape_device *device)
 {
 	return TAPE390_CRYPT_ON(TAPE_3590_CRYPT_INFO(device));
 }
 static void ext_to_int_kekl(struct tape390_kekl *in,
 			    struct tape3592_kekl *out)
 {
 	int i;
 	memset(out, 0, sizeof(*out));
 	if (in->type == TAPE390_KEKL_TYPE_HASH)
 		out->flags |= 0x40;
 	if (in->type_on_tape == TAPE390_KEKL_TYPE_HASH)
 		out->flags |= 0x80;
 	strncpy(out->label, in->label, 64);
 	for (i = strlen(in->label); i < sizeof(out->label); i++)
 		out->label[i] = ' ';
 	ASCEBC(out->label, sizeof(out->label));
 }
 static void int_to_ext_kekl(struct tape3592_kekl *in,
 			    struct tape390_kekl *out)
 {
 	memset(out, 0, sizeof(*out));
 	if(in->flags & 0x40)
 		out->type = TAPE390_KEKL_TYPE_HASH;
 	else
 		out->type = TAPE390_KEKL_TYPE_LABEL;
 	if(in->flags & 0x80)
 		out->type_on_tape = TAPE390_KEKL_TYPE_HASH;
 	else
 		out->type_on_tape = TAPE390_KEKL_TYPE_LABEL;
 	memcpy(out->label, in->label, sizeof(in->label));
 	EBCASC(out->label, sizeof(in->label));
 	strstrip(out->label);
 }
 static void int_to_ext_kekl_pair(struct tape3592_kekl_pair *in,
 				 struct tape390_kekl_pair *out)
 {
 	if (in->count == 0) {
 		out->kekl[0].type = TAPE390_KEKL_TYPE_NONE;
 		out->kekl[0].type_on_tape = TAPE390_KEKL_TYPE_NONE;
 		out->kekl[1].type = TAPE390_KEKL_TYPE_NONE;
 		out->kekl[1].type_on_tape = TAPE390_KEKL_TYPE_NONE;
 	} else if (in->count == 1) {
 		int_to_ext_kekl(&in->kekl[0], &out->kekl[0]);
 		out->kekl[1].type = TAPE390_KEKL_TYPE_NONE;
 		out->kekl[1].type_on_tape = TAPE390_KEKL_TYPE_NONE;
 	} else if (in->count == 2) {
 		int_to_ext_kekl(&in->kekl[0], &out->kekl[0]);
 		int_to_ext_kekl(&in->kekl[1], &out->kekl[1]);
 	} else {
 		printk("Invalid KEKL number: %d\n", in->count);
 		BUG();
 	}
 }
 static int check_ext_kekl(struct tape390_kekl *kekl)
 {
 	if (kekl->type == TAPE390_KEKL_TYPE_NONE)
 		goto invalid;
 	if (kekl->type > TAPE390_KEKL_TYPE_HASH)
 		goto invalid;
 	if (kekl->type_on_tape == TAPE390_KEKL_TYPE_NONE)
 		goto invalid;
 	if (kekl->type_on_tape > TAPE390_KEKL_TYPE_HASH)
 		goto invalid;
 	if ((kekl->type == TAPE390_KEKL_TYPE_HASH) &&
 	    (kekl->type_on_tape == TAPE390_KEKL_TYPE_LABEL))
 		goto invalid;
 	return 0;
 invalid:
 	return -EINVAL;
 }
 static int check_ext_kekl_pair(struct tape390_kekl_pair *kekls)
 {
 	if (check_ext_kekl(&kekls->kekl[0]))
 		goto invalid;
 	if (check_ext_kekl(&kekls->kekl[1]))
 		goto invalid;
 	return 0;
 invalid:
 	return -EINVAL;
 }
 /*
  * Query KEKLs
  */
 static int tape_3592_kekl_query(struct tape_device *device,
 				struct tape390_kekl_pair *ext_kekls)
 {
 	struct tape_request *request;
 	struct tape3592_kekl_query_order *order;
 	struct tape3592_kekl_query_data *int_kekls;
 	int rc;
 	DBF_EVENT(6, "tape3592_kekl_query\n");
 	int_kekls = kmalloc(sizeof(*int_kekls), GFP_KERNEL|GFP_DMA);
 	if (!int_kekls)
 		return -ENOMEM;
 	request = tape_alloc_request(2, sizeof(*order));
 	if (IS_ERR(request)) {
 		rc = PTR_ERR(request);
 		goto fail_malloc;
 	}
 	order = request->cpdata;
 	memset(order,0,sizeof(*order));
 	order->code = 0xe2;
 	order->max_count = 2;
 	request->op = TO_KEKL_QUERY;
 	tape_ccw_cc(request->cpaddr, PERF_SUBSYS_FUNC, sizeof(*order), order);
 	tape_ccw_end(request->cpaddr + 1, READ_SS_DATA, sizeof(*int_kekls),
 		     int_kekls);
 	rc = tape_do_io(device, request);
 	if (rc)
 		goto fail_request;
 	int_to_ext_kekl_pair(&int_kekls->kekls, ext_kekls);
 	rc = 0;
 fail_request:
 	tape_free_request(request);
 fail_malloc:
 	kfree(int_kekls);
 	return rc;
 }
 /*
  * IOCTL: Query KEKLs
  */
 static int tape_3592_ioctl_kekl_query(struct tape_device *device,
 				      unsigned long arg)
 {
 	int rc;
 	struct tape390_kekl_pair *ext_kekls;
 	DBF_EVENT(6, "tape_3592_ioctl_kekl_query\n");
 	if (!crypt_supported(device))
 		return -ENOSYS;
 	if (!crypt_enabled(device))
 		return -EUNATCH;
 	ext_kekls = kmalloc(sizeof(*ext_kekls), GFP_KERNEL);
 	if (!ext_kekls)
 		return -ENOMEM;
 	rc = tape_3592_kekl_query(device, ext_kekls);
 	if (rc != 0)
 		goto fail;
 	if (copy_to_user((char __user *) arg, ext_kekls, sizeof(*ext_kekls))) {
 		rc = -EFAULT;
 		goto fail;
 	}
 	rc = 0;
 fail:
 	kfree(ext_kekls);
 	return rc;
 }
 static int tape_3590_mttell(struct tape_device *device, int mt_count);
 /*
  * Set KEKLs
  */
 static int tape_3592_kekl_set(struct tape_device *device,
 			      struct tape390_kekl_pair *ext_kekls)
 {
 	struct tape_request *request;
 	struct tape3592_kekl_set_order *order;
 	DBF_EVENT(6, "tape3592_kekl_set\n");
 	if (check_ext_kekl_pair(ext_kekls)) {
 		DBF_EVENT(6, "invalid kekls\n");
 		return -EINVAL;
 	}
 	if (tape_3590_mttell(device, 0) != 0)
 		return -EBADSLT;
 	request = tape_alloc_request(1, sizeof(*order));
 	if (IS_ERR(request))
 		return PTR_ERR(request);
 	order = request->cpdata;
 	memset(order, 0, sizeof(*order));
 	order->code = 0xe3;
 	order->kekls.count = 2;
 	ext_to_int_kekl(&ext_kekls->kekl[0], &order->kekls.kekl[0]);
 	ext_to_int_kekl(&ext_kekls->kekl[1], &order->kekls.kekl[1]);
 	request->op = TO_KEKL_SET;
 	tape_ccw_end(request->cpaddr, PERF_SUBSYS_FUNC, sizeof(*order), order);
 	return tape_do_io_free(device, request);
 }
 /*
  * IOCTL: Set KEKLs
  */
 static int tape_3592_ioctl_kekl_set(struct tape_device *device,
 				    unsigned long arg)
 {
 	int rc;
 	struct tape390_kekl_pair *ext_kekls;
 	DBF_EVENT(6, "tape_3592_ioctl_kekl_set\n");
 	if (!crypt_supported(device))
 		return -ENOSYS;
 	if (!crypt_enabled(device))
 		return -EUNATCH;
 	ext_kekls = kmalloc(sizeof(*ext_kekls), GFP_KERNEL);
 	if (!ext_kekls)
 		return -ENOMEM;
 	if (copy_from_user(ext_kekls, (char __user *)arg, sizeof(*ext_kekls))) {
 		rc = -EFAULT;
 		goto out;
 	}
 	rc = tape_3592_kekl_set(device, ext_kekls);
 out:
 	kfree(ext_kekls);
 	return rc;
 }
 /*
  * Enable encryption
  */
 static int tape_3592_enable_crypt(struct tape_device *device)
 {
 	struct tape_request *request;
 	char *data;
 	DBF_EVENT(6, "tape_3592_enable_crypt\n");
 	if (!crypt_supported(device))
 		return -ENOSYS;
 	request = tape_alloc_request(2, 72);
 	if (IS_ERR(request))
 		return PTR_ERR(request);
 	data = request->cpdata;
 	memset(data,0,72);
 	data[0]       = 0x05;
 	data[36 + 0]  = 0x03;
 	data[36 + 1]  = 0x03;
 	data[36 + 4]  = 0x40;
 	data[36 + 6]  = 0x01;
 	data[36 + 14] = 0x2f;
 	data[36 + 18] = 0xc3;
 	data[36 + 35] = 0x72;
 	request->op = TO_CRYPT_ON;
 	tape_ccw_cc(request->cpaddr, MODE_SET_CB, 36, data);
 	tape_ccw_end(request->cpaddr + 1, MODE_SET_CB, 36, data + 36);
 	return tape_do_io_free(device, request);
 }
 /*
  * Disable encryption
  */
 static int tape_3592_disable_crypt(struct tape_device *device)
 {
 	struct tape_request *request;
 	char *data;
 	DBF_EVENT(6, "tape_3592_disable_crypt\n");
 	if (!crypt_supported(device))
 		return -ENOSYS;
 	request = tape_alloc_request(2, 72);
 	if (IS_ERR(request))
 		return PTR_ERR(request);
 	data = request->cpdata;
 	memset(data,0,72);
 	data[0]       = 0x05;
 	data[36 + 0]  = 0x03;
 	data[36 + 1]  = 0x03;
 	data[36 + 35] = 0x32;
 	request->op = TO_CRYPT_OFF;
 	tape_ccw_cc(request->cpaddr, MODE_SET_CB, 36, data);
 	tape_ccw_end(request->cpaddr + 1, MODE_SET_CB, 36, data + 36);
 	return tape_do_io_free(device, request);
 }
 /*
  * IOCTL: Set encryption status
  */
 static int tape_3592_ioctl_crypt_set(struct tape_device *device,
 				     unsigned long arg)
 {
 	struct tape390_crypt_info info;
 	DBF_EVENT(6, "tape_3592_ioctl_crypt_set\n");
 	if (!crypt_supported(device))
 		return -ENOSYS;
 	if (copy_from_user(&info, (char __user *)arg, sizeof(info)))
 		return -EFAULT;
 	if (info.status & ~TAPE390_CRYPT_ON_MASK)
 		return -EINVAL;
 	if (info.status & TAPE390_CRYPT_ON_MASK)
 		return tape_3592_enable_crypt(device);
 	else
 		return tape_3592_disable_crypt(device);
 }
 static int tape_3590_sense_medium(struct tape_device *device);
 /*
  * IOCTL: Query enryption status
  */
 static int tape_3592_ioctl_crypt_query(struct tape_device *device,
 				       unsigned long arg)
 {
 	DBF_EVENT(6, "tape_3592_ioctl_crypt_query\n");
 	if (!crypt_supported(device))
 		return -ENOSYS;
 	tape_3590_sense_medium(device);
 	if (copy_to_user((char __user *) arg, &TAPE_3590_CRYPT_INFO(device),
 		sizeof(TAPE_3590_CRYPT_INFO(device))))
 		return -EFAULT;
 	else
 		return 0;
 }
 /*
  * 3590 IOCTL Overload
  */
 static int
 tape_3590_ioctl(struct tape_device *device, unsigned int cmd, unsigned long arg)
 {
 	switch (cmd) {
 	case TAPE390_DISPLAY: {
 		struct display_struct disp;
 		if (copy_from_user(&disp, (char __user *) arg, sizeof(disp)))
 			return -EFAULT;
 		return tape_std_display(device, &disp);
 	}
 	case TAPE390_KEKL_SET:
 		return tape_3592_ioctl_kekl_set(device, arg);
 	case TAPE390_KEKL_QUERY:
 		return tape_3592_ioctl_kekl_query(device, arg);
 	case TAPE390_CRYPT_SET:
 		return tape_3592_ioctl_crypt_set(device, arg);
 	case TAPE390_CRYPT_QUERY:
 		return tape_3592_ioctl_crypt_query(device, arg);
 	default:
 		return -EINVAL;	/* no additional ioctls */
 	}
 }
 /*
  * SENSE Medium: Get Sense data about medium state
  */
 static int
 tape_3590_sense_medium(struct tape_device *device)
 {
 	struct tape_request *request;
 	request = tape_alloc_request(1, 128);
 	if (IS_ERR(request))
 		return PTR_ERR(request);
 	request->op = TO_MSEN;
 	tape_ccw_end(request->cpaddr, MEDIUM_SENSE, 128, request->cpdata);
 	return tape_do_io_free(device, request);
 }
 /*
  * MTTELL: Tell block. Return the number of block relative to current file.
  */
 static int
 tape_3590_mttell(struct tape_device *device, int mt_count)
 {
 	__u64 block_id;
 	int rc;
 	rc = tape_std_read_block_id(device, &block_id);
 	if (rc)
 		return rc;
 	return block_id >> 32;
 }
 /*
  * MTSEEK: seek to the specified block.
  */
 static int
 tape_3590_mtseek(struct tape_device *device, int count)
 {
 	struct tape_request *request;
 	DBF_EVENT(6, "xsee id: %x\n", count);
 	request = tape_alloc_request(3, 4);
 	if (IS_ERR(request))
 		return PTR_ERR(request);
 	request->op = TO_LBL;
 	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
 	*(__u32 *) request->cpdata = count;
 	tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
 	tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
 	return tape_do_io_free(device, request);
 }
 /*
  * Read Opposite Error Recovery Function:
  * Used, when Read Forward does not work
  */
 static void
 tape_3590_read_opposite(struct tape_device *device,
 			struct tape_request *request)
 {
 	struct tape_3590_disc_data *data;
 	/*
 	 * 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);
 	data = device->discdata;
 	tape_ccw_cc_idal(request->cpaddr + 1, data->read_back_op,
 			 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\n");
 }
 /*
  * Read Attention Msg
  * This should be done after an interrupt with attention bit (0x80)
  * in device state.
  *
  * After a "read attention message" request there are two possible
  * results:
  *
  * 1. A unit check is presented, when attention sense is present (e.g. when
  * a medium has been unloaded). The attention sense comes then
  * together with the unit check. The recovery action is either "retry"
  * (in case there is an attention message pending) or "permanent error".
  *
  * 2. The attention msg is written to the "read subsystem data" buffer.
  * In this case we probably should print it to the console.
  */
 static int
 tape_3590_read_attmsg(struct tape_device *device)
 {
 	struct tape_request *request;
 	char *buf;
 	request = tape_alloc_request(3, 4096);
 	if (IS_ERR(request))
 		return PTR_ERR(request);
 	request->op = TO_READ_ATTMSG;
 	buf = request->cpdata;
 	buf[0] = PREP_RD_SS_DATA;
 	buf[6] = RD_ATTMSG;	/* read att msg */
 	tape_ccw_cc(request->cpaddr, PERFORM_SS_FUNC, 12, buf);
 	tape_ccw_cc(request->cpaddr + 1, READ_SS_DATA, 4096 - 12, buf + 12);
 	tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
 	return tape_do_io_free(device, request);
 }
 /*
  * These functions are used to schedule follow-up actions from within an
  * interrupt context (like unsolicited interrupts).
  */
 struct work_handler_data {
 	struct tape_device *device;
 	enum tape_op        op;
 	struct work_struct  work;
 };
 static void
 tape_3590_work_handler(struct work_struct *work)
 {
 	struct work_handler_data *p =
 		container_of(work, struct work_handler_data, work);
 	switch (p->op) {
 	case TO_MSEN:
 		tape_3590_sense_medium(p->device);
 		break;
 	case TO_READ_ATTMSG:
 		tape_3590_read_attmsg(p->device);
 		break;
 	case TO_CRYPT_ON:
 		tape_3592_enable_crypt(p->device);
 		break;
 	case TO_CRYPT_OFF:
 		tape_3592_disable_crypt(p->device);
 		break;
 	default:
 		DBF_EVENT(3, "T3590: work handler undefined for "
 			  "operation 0x%02x\n", p->op);
 	}
 	tape_put_device(p->device);
 	kfree(p);
 }
 static int
 tape_3590_schedule_work(struct tape_device *device, enum tape_op op)
 {
 	struct work_handler_data *p;
 	if ((p = kzalloc(sizeof(*p), GFP_ATOMIC)) == NULL)
 		return -ENOMEM;
 	INIT_WORK(&p->work, tape_3590_work_handler);
 	p->device = tape_get_device(device);
 	p->op = op;
 	schedule_work(&p->work);
 	return 0;
 }
 #ifdef CONFIG_S390_TAPE_BLOCK
 /*
  * Tape Block READ
  */
 static struct tape_request *
 tape_3590_bread(struct tape_device *device, struct request *req)
 {
 	struct tape_request *request;
 	struct ccw1 *ccw;
 	int count = 0, start_block;
 	unsigned off;
 	char *dst;
 	struct bio_vec *bv;
 	struct req_iterator iter;
 	DBF_EVENT(6, "xBREDid:");
 	start_block = blk_rq_pos(req) >> TAPEBLOCK_HSEC_S2B;
 	DBF_EVENT(6, "start_block = %i\n", start_block);
 	rq_for_each_segment(bv, req, iter)
 		count += bv->bv_len >> (TAPEBLOCK_HSEC_S2B + 9);
 	request = tape_alloc_request(2 + count + 1, 4);
 	if (IS_ERR(request))
 		return request;
 	request->op = TO_BLOCK;
 	*(__u32 *) request->cpdata = start_block;
 	ccw = request->cpaddr;
 	ccw = tape_ccw_cc(ccw, MODE_SET_DB, 1, device->modeset_byte);
 	/*
 	 * We always setup a nop after the mode set ccw. This slot is
 	 * used in tape_std_check_locate to insert a locate ccw if the
 	 * current tape position doesn't match the start block to be read.
 	 */
 	ccw = tape_ccw_cc(ccw, NOP, 0, NULL);
 	rq_for_each_segment(bv, req, iter) {
 		dst = page_address(bv->bv_page) + bv->bv_offset;
 		for (off = 0; off < bv->bv_len; off += TAPEBLOCK_HSEC_SIZE) {
 			ccw->flags = CCW_FLAG_CC;
 			ccw->cmd_code = READ_FORWARD;
 			ccw->count = TAPEBLOCK_HSEC_SIZE;
 			set_normalized_cda(ccw, (void *) __pa(dst));
 			ccw++;
 			dst += TAPEBLOCK_HSEC_SIZE;
 		}
 		BUG_ON(off > bv->bv_len);
 	}
 	ccw = tape_ccw_end(ccw, NOP, 0, NULL);
 	DBF_EVENT(6, "xBREDccwg\n");
 	return request;
 }
 static void
 tape_3590_free_bread(struct tape_request *request)
 {
 	struct ccw1 *ccw;
 	/* Last ccw is a nop and doesn't need clear_normalized_cda */
 	for (ccw = request->cpaddr; ccw->flags & CCW_FLAG_CC; ccw++)
 		if (ccw->cmd_code == READ_FORWARD)
 			clear_normalized_cda(ccw);
 	tape_free_request(request);
 }
 /*
  * check_locate is called just before the tape request is passed to
  * the common io layer for execution. It has to check the current
  * tape position and insert a locate ccw if it doesn't match the
  * start block for the request.
  */
 static void
 tape_3590_check_locate(struct tape_device *device, struct tape_request *request)
 {
 	__u32 *start_block;
 	start_block = (__u32 *) request->cpdata;
 	if (*start_block != device->blk_data.block_position) {
 		/* Add the start offset of the file to get the real block. */
 		*start_block += device->bof;
 		tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
 	}
 }
 #endif
 static void tape_3590_med_state_set(struct tape_device *device,
 				    struct tape_3590_med_sense *sense)
 {
 	struct tape390_crypt_info *c_info;
 	c_info = &TAPE_3590_CRYPT_INFO(device);
 	DBF_EVENT(6, "medium state: %x:%x\n", sense->macst, sense->masst);
 	switch (sense->macst) {
 	case 0x04:
 	case 0x05:
 	case 0x06:
 		tape_med_state_set(device, MS_UNLOADED);
 		TAPE_3590_CRYPT_INFO(device).medium_status = 0;
 		return;
 	case 0x08:
 	case 0x09:
 		tape_med_state_set(device, MS_LOADED);
 		break;
 	default:
 		tape_med_state_set(device, MS_UNKNOWN);
 		return;
 	}
 	c_info->medium_status |= TAPE390_MEDIUM_LOADED_MASK;
 	if (sense->flags & MSENSE_CRYPT_MASK) {
 		DBF_EVENT(6, "Medium is encrypted (%04x)\n", sense->flags);
 		c_info->medium_status |= TAPE390_MEDIUM_ENCRYPTED_MASK;
 	} else	{
 		DBF_EVENT(6, "Medium is not encrypted %04x\n", sense->flags);
 		c_info->medium_status &= ~TAPE390_MEDIUM_ENCRYPTED_MASK;
 	}
 }
 /*
  * The done handler is called at device/channel end and wakes up the sleeping
  * process
  */
 static int
 tape_3590_done(struct tape_device *device, struct tape_request *request)
 {
 	struct tape_3590_disc_data *disc_data;
 	DBF_EVENT(6, "%s done\n", tape_op_verbose[request->op]);
 	disc_data = device->discdata;
 	switch (request->op) {
 	case TO_BSB:
 	case TO_BSF:
 	case TO_DSE:
 	case TO_FSB:
 	case TO_FSF:
 	case TO_LBL:
 	case TO_RFO:
 	case TO_RBA:
 	case TO_REW:
 	case TO_WRI:
 	case TO_WTM:
 	case TO_BLOCK:
 	case TO_LOAD:
 		tape_med_state_set(device, MS_LOADED);
 		break;
 	case TO_RUN:
 		tape_med_state_set(device, MS_UNLOADED);
 		tape_3590_schedule_work(device, TO_CRYPT_OFF);
 		break;
 	case TO_MSEN:
 		tape_3590_med_state_set(device, request->cpdata);
 		break;
 	case TO_CRYPT_ON:
 		TAPE_3590_CRYPT_INFO(device).status
 			|= TAPE390_CRYPT_ON_MASK;
 		*(device->modeset_byte) |= 0x03;
 		break;
 	case TO_CRYPT_OFF:
 		TAPE_3590_CRYPT_INFO(device).status
 			&= ~TAPE390_CRYPT_ON_MASK;
 		*(device->modeset_byte) &= ~0x03;
 		break;
 	case TO_RBI:	/* RBI seems to succeed even without medium loaded. */
 	case TO_NOP:	/* Same to NOP. */
 	case TO_READ_CONFIG:
 	case TO_READ_ATTMSG:
 	case TO_DIS:
 	case TO_ASSIGN:
 	case TO_UNASSIGN:
 	case TO_SIZE:
 	case TO_KEKL_SET:
 	case TO_KEKL_QUERY:
 	case TO_RDC:
 		break;
 	}
 	return TAPE_IO_SUCCESS;
 }
 /*
  * This fuction is called, when error recovery was successfull
  */
 static inline int
 tape_3590_erp_succeded(struct tape_device *device, struct tape_request *request)
 {
 	DBF_EVENT(3, "Error Recovery successful for %s\n",
 		  tape_op_verbose[request->op]);
 	return tape_3590_done(device, request);
 }
 /*
  * This fuction is called, when error recovery was not successfull
  */
 static inline int
 tape_3590_erp_failed(struct tape_device *device, struct tape_request *request,
 		     struct irb *irb, int rc)
 {
 	DBF_EVENT(3, "Error Recovery failed for %s\n",
 		  tape_op_verbose[request->op]);
 	tape_dump_sense_dbf(device, request, irb);
 	return rc;
 }
 /*
  * Error Recovery do retry
  */
 static inline int
 tape_3590_erp_retry(struct tape_device *device, struct tape_request *request,
 		    struct irb *irb)
 {
 	DBF_EVENT(2, "Retry: %s\n", tape_op_verbose[request->op]);
 	tape_dump_sense_dbf(device, request, irb);
 	return TAPE_IO_RETRY;
 }
 /*
  * Handle unsolicited interrupts
  */
 static int
 tape_3590_unsolicited_irq(struct tape_device *device, struct irb *irb)
 {
 	if (irb->scsw.cmd.dstat == DEV_STAT_CHN_END)
 		/* Probably result of halt ssch */
 		return TAPE_IO_PENDING;
 	else if (irb->scsw.cmd.dstat == 0x85)
 		/* Device Ready */
 		DBF_EVENT(3, "unsol.irq! tape ready: %08x\n", device->cdev_id);
 	else if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
 		tape_3590_schedule_work(device, TO_READ_ATTMSG);
 	} else {
 		DBF_EVENT(3, "unsol.irq! dev end: %08x\n", device->cdev_id);
 		tape_dump_sense_dbf(device, NULL, irb);
 	}
 	/* check medium state */
 	tape_3590_schedule_work(device, TO_MSEN);
 	return TAPE_IO_SUCCESS;
 }
 /*
  * Basic Recovery routine
  */
 static int
 tape_3590_erp_basic(struct tape_device *device, struct tape_request *request,
 		    struct irb *irb, int rc)
 {
 	struct tape_3590_sense *sense;
 	sense = (struct tape_3590_sense *) irb->ecw;
 	switch (sense->bra) {
 	case SENSE_BRA_PER:
 		return tape_3590_erp_failed(device, request, irb, rc);
 	case SENSE_BRA_CONT:
 		return tape_3590_erp_succeded(device, request);
 	case SENSE_BRA_RE:
 		return tape_3590_erp_retry(device, request, irb);
 	case SENSE_BRA_DRE:
 		return tape_3590_erp_failed(device, request, irb, rc);
 	default:
 		BUG();
 		return TAPE_IO_STOP;
 	}
 }
 /*
  *  RDL: Read Device (buffered) log
  */
 static int
 tape_3590_erp_read_buf_log(struct tape_device *device,
 			   struct tape_request *request, struct irb *irb)
 {
 	/*
 	 * We just do the basic error recovery at the moment (retry).
 	 * Perhaps in the future, we read the log and dump it somewhere...
 	 */
 	return tape_3590_erp_basic(device, request, irb, -EIO);
 }
 /*
  *  SWAP: Swap Devices
  */
 static int
 tape_3590_erp_swap(struct tape_device *device, struct tape_request *request,
 		   struct irb *irb)
 {
 	/*
 	 * This error recovery should swap the tapes
 	 * if the original has a problem. The operation
 	 * should proceed with the new tape... this
 	 * should probably be done in user space!
 	 */
 	dev_warn (&device->cdev->dev, "The tape medium must be loaded into a "
 		"different tape unit\n");
 	return tape_3590_erp_basic(device, request, irb, -EIO);
 }
 /*
  *  LBY: Long Busy
  */
 static int
 tape_3590_erp_long_busy(struct tape_device *device,
 			struct tape_request *request, struct irb *irb)
 {
 	DBF_EVENT(6, "Device is busy\n");
 	return TAPE_IO_LONG_BUSY;
 }
 /*
  *  SPI: Special Intercept
  */
 static int
 tape_3590_erp_special_interrupt(struct tape_device *device,
 				struct tape_request *request, struct irb *irb)
 {
 	return tape_3590_erp_basic(device, request, irb, -EIO);
 }
 /*
  *  RDA: Read Alternate
  */
 static int
 tape_3590_erp_read_alternate(struct tape_device *device,
 			     struct tape_request *request, struct irb *irb)
 {
 	struct tape_3590_disc_data *data;
 	/*
 	 * The issued Read Backward or Read Previous command is not
 	 * supported by the device
 	 * The recovery action should be to issue another command:
 	 * Read Revious: if Read Backward is not supported
 	 * Read Backward: if Read Previous is not supported
 	 */
 	data = device->discdata;
 	if (data->read_back_op == READ_PREVIOUS) {
 		DBF_EVENT(2, "(%08x): No support for READ_PREVIOUS command\n",
 			  device->cdev_id);
 		data->read_back_op = READ_BACKWARD;
 	} else {
 		DBF_EVENT(2, "(%08x): No support for READ_BACKWARD command\n",
 			  device->cdev_id);
 		data->read_back_op = READ_PREVIOUS;
 	}
 	tape_3590_read_opposite(device, request);
 	return tape_3590_erp_retry(device, request, irb);
 }
 /*
  * Error Recovery read opposite
  */
 static int
 tape_3590_erp_read_opposite(struct tape_device *device,
 			    struct tape_request *request, struct irb *irb)
 {
 	switch (request->op) {
 	case TO_RFO:
 		/*
 		 * We did read forward, but the data could not be read.
 		 * We will read backward and then skip forward again.
 		 */
 		tape_3590_read_opposite(device, request);
 		return tape_3590_erp_retry(device, request, irb);
 	case TO_RBA:
 		/* We tried to read forward and backward, but hat no success */
 		return tape_3590_erp_failed(device, request, irb, -EIO);
 		break;
 	default:
 		return tape_3590_erp_failed(device, request, irb, -EIO);
 	}
 }
 /*
  * Print an MIM (Media Information  Message) (message code f0)
  */
 static void
 tape_3590_print_mim_msg_f0(struct tape_device *device, struct irb *irb)
 {
 	struct tape_3590_sense *sense;
 	char *exception, *service;
 	exception = kmalloc(BUFSIZE, GFP_ATOMIC);
 	service = kmalloc(BUFSIZE, GFP_ATOMIC);
 	if (!exception || !service)
 		goto out_nomem;
 	sense = (struct tape_3590_sense *) irb->ecw;
 	/* Exception Message */
 	switch (sense->fmt.f70.emc) {
 	case 0x02:
 		snprintf(exception, BUFSIZE, "Data degraded");
 		break;
 	case 0x03:
 		snprintf(exception, BUFSIZE, "Data degraded in partion %i",
 			sense->fmt.f70.mp);
 		break;
 	case 0x04:
 		snprintf(exception, BUFSIZE, "Medium degraded");
 		break;
 	case 0x05:
 		snprintf(exception, BUFSIZE, "Medium degraded in partition %i",
 			sense->fmt.f70.mp);
 		break;
 	case 0x06:
 		snprintf(exception, BUFSIZE, "Block 0 Error");
 		break;
 	case 0x07:
 		snprintf(exception, BUFSIZE, "Medium Exception 0x%02x",
 			sense->fmt.f70.md);
 		break;
 	default:
 		snprintf(exception, BUFSIZE, "0x%02x",
 			sense->fmt.f70.emc);
 		break;
 	}
 	/* Service Message */
 	switch (sense->fmt.f70.smc) {
 	case 0x02:
 		snprintf(service, BUFSIZE, "Reference Media maintenance "
 			"procedure %i", sense->fmt.f70.md);
 		break;
 	default:
 		snprintf(service, BUFSIZE, "0x%02x",
 			sense->fmt.f70.smc);
 		break;
 	}
 	dev_warn (&device->cdev->dev, "Tape media information: exception %s, "
 		"service %s\n", exception, service);
 out_nomem:
 	kfree(exception);
 	kfree(service);
 }
 /*
  * Print an I/O Subsystem Service Information Message (message code f1)
  */
 static void
 tape_3590_print_io_sim_msg_f1(struct tape_device *device, struct irb *irb)
 {
 	struct tape_3590_sense *sense;
 	char *exception, *service;
 	exception = kmalloc(BUFSIZE, GFP_ATOMIC);
 	service = kmalloc(BUFSIZE, GFP_ATOMIC);
 	if (!exception || !service)
 		goto out_nomem;
 	sense = (struct tape_3590_sense *) irb->ecw;
 	/* Exception Message */
 	switch (sense->fmt.f71.emc) {
 	case 0x01:
 		snprintf(exception, BUFSIZE, "Effect of failure is unknown");
 		break;
 	case 0x02:
 		snprintf(exception, BUFSIZE, "CU Exception - no performance "
 			"impact");
 		break;
 	case 0x03:
 		snprintf(exception, BUFSIZE, "CU Exception on channel "
 			"interface 0x%02x", sense->fmt.f71.md[0]);
 		break;
 	case 0x04:
 		snprintf(exception, BUFSIZE, "CU Exception on device path "
 			"0x%02x", sense->fmt.f71.md[0]);
 		break;
 	case 0x05:
 		snprintf(exception, BUFSIZE, "CU Exception on library path "
 			"0x%02x", sense->fmt.f71.md[0]);
 		break;
 	case 0x06:
 		snprintf(exception, BUFSIZE, "CU Exception on node 0x%02x",
 			sense->fmt.f71.md[0]);
 		break;
 	case 0x07:
 		snprintf(exception, BUFSIZE, "CU Exception on partition "
 			"0x%02x", sense->fmt.f71.md[0]);
 		break;
 	default:
 		snprintf(exception, BUFSIZE, "0x%02x",
 			sense->fmt.f71.emc);
 	}
 	/* Service Message */
 	switch (sense->fmt.f71.smc) {
 	case 0x01:
 		snprintf(service, BUFSIZE, "Repair impact is unknown");
 		break;
 	case 0x02:
 		snprintf(service, BUFSIZE, "Repair will not impact cu "
 			"performance");
 		break;
 	case 0x03:
 		if (sense->fmt.f71.mdf == 0)
 			snprintf(service, BUFSIZE, "Repair will disable node "
 				"0x%x on CU", sense->fmt.f71.md[1]);
 		else
 			snprintf(service, BUFSIZE, "Repair will disable "
 				"nodes (0x%x-0x%x) on CU", sense->fmt.f71.md[1],
 				sense->fmt.f71.md[2]);
 		break;
 	case 0x04:
 		if (sense->fmt.f71.mdf == 0)
 			snprintf(service, BUFSIZE, "Repair will disable "
 				"channel path 0x%x on CU",
 				sense->fmt.f71.md[1]);
 		else
 			snprintf(service, BUFSIZE, "Repair will disable cannel"
 				" paths (0x%x-0x%x) on CU",
 				sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
 		break;
 	case 0x05:
 		if (sense->fmt.f71.mdf == 0)
 			snprintf(service, BUFSIZE, "Repair will disable device"
 				" path 0x%x on CU", sense->fmt.f71.md[1]);
 		else
 			snprintf(service, BUFSIZE, "Repair will disable device"
 				" paths (0x%x-0x%x) on CU",
 				sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
 		break;
 	case 0x06:
 		if (sense->fmt.f71.mdf == 0)
 			snprintf(service, BUFSIZE, "Repair will disable "
 				"library path 0x%x on CU",
 				sense->fmt.f71.md[1]);
 		else
 			snprintf(service, BUFSIZE, "Repair will disable "
 				"library paths (0x%x-0x%x) on CU",
 				sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
 		break;
 	case 0x07:
 		snprintf(service, BUFSIZE, "Repair will disable access to CU");
 		break;
 	default:
 		snprintf(service, BUFSIZE, "0x%02x",
 			sense->fmt.f71.smc);
 	}
 	dev_warn (&device->cdev->dev, "I/O subsystem information: exception"
 		" %s, service %s\n", exception, service);
 out_nomem:
 	kfree(exception);
 	kfree(service);
 }
 /*
  * Print an Device Subsystem Service Information Message (message code f2)
  */
 static void
 tape_3590_print_dev_sim_msg_f2(struct tape_device *device, struct irb *irb)
 {
 	struct tape_3590_sense *sense;
 	char *exception, *service;
 	exception = kmalloc(BUFSIZE, GFP_ATOMIC);
 	service = kmalloc(BUFSIZE, GFP_ATOMIC);
 	if (!exception || !service)
 		goto out_nomem;
 	sense = (struct tape_3590_sense *) irb->ecw;
 	/* Exception Message */
 	switch (sense->fmt.f71.emc) {
 	case 0x01:
 		snprintf(exception, BUFSIZE, "Effect of failure is unknown");
 		break;
 	case 0x02:
 		snprintf(exception, BUFSIZE, "DV Exception - no performance"
 			" impact");
 		break;
 	case 0x03:
 		snprintf(exception, BUFSIZE, "DV Exception on channel "
 			"interface 0x%02x", sense->fmt.f71.md[0]);
 		break;
 	case 0x04:
 		snprintf(exception, BUFSIZE, "DV Exception on loader 0x%02x",
 			sense->fmt.f71.md[0]);
 		break;
 	case 0x05:
 		snprintf(exception, BUFSIZE, "DV Exception on message display"
 			" 0x%02x", sense->fmt.f71.md[0]);
 		break;
 	case 0x06:
 		snprintf(exception, BUFSIZE, "DV Exception in tape path");
 		break;
 	case 0x07:
 		snprintf(exception, BUFSIZE, "DV Exception in drive");
 		break;
 	default:
 		snprintf(exception, BUFSIZE, "0x%02x",
 			sense->fmt.f71.emc);
 	}
 	/* Service Message */
 	switch (sense->fmt.f71.smc) {
 	case 0x01:
 		snprintf(service, BUFSIZE, "Repair impact is unknown");
 		break;
 	case 0x02:
 		snprintf(service, BUFSIZE, "Repair will not impact device "
 			"performance");
 		break;
 	case 0x03:
 		if (sense->fmt.f71.mdf == 0)
 			snprintf(service, BUFSIZE, "Repair will disable "
 				"channel path 0x%x on DV",
 				sense->fmt.f71.md[1]);
 		else
 			snprintf(service, BUFSIZE, "Repair will disable "
 				"channel path (0x%x-0x%x) on DV",
 				sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
 		break;
 	case 0x04:
 		if (sense->fmt.f71.mdf == 0)
 			snprintf(service, BUFSIZE, "Repair will disable "
 				"interface 0x%x on DV", sense->fmt.f71.md[1]);
 		else
 			snprintf(service, BUFSIZE, "Repair will disable "
 				"interfaces (0x%x-0x%x) on DV",
 				sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
 		break;
 	case 0x05:
 		if (sense->fmt.f71.mdf == 0)
 			snprintf(service, BUFSIZE, "Repair will disable loader"
 				" 0x%x on DV", sense->fmt.f71.md[1]);
 		else
 			snprintf(service, BUFSIZE, "Repair will disable loader"
 				" (0x%x-0x%x) on DV",
 				sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
 		break;
 	case 0x07:
 		snprintf(service, BUFSIZE, "Repair will disable access to DV");
 		break;
 	case 0x08:
 		if (sense->fmt.f71.mdf == 0)
 			snprintf(service, BUFSIZE, "Repair will disable "
 				"message display 0x%x on DV",
 				sense->fmt.f71.md[1]);
 		else
 			snprintf(service, BUFSIZE, "Repair will disable "
 				"message displays (0x%x-0x%x) on DV",
 				 sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
 		break;
 	case 0x09:
 		snprintf(service, BUFSIZE, "Clean DV");
 		break;
 	default:
 		snprintf(service, BUFSIZE, "0x%02x",
 			sense->fmt.f71.smc);
 	}
 	dev_warn (&device->cdev->dev, "Device subsystem information: exception"
 		" %s, service %s\n", exception, service);
 out_nomem:
 	kfree(exception);
 	kfree(service);
 }
 /*
  * Print standard ERA Message
  */
 static void
 tape_3590_print_era_msg(struct tape_device *device, struct irb *irb)
 {
 	struct tape_3590_sense *sense;
 	sense = (struct tape_3590_sense *) irb->ecw;
 	if (sense->mc == 0)
 		return;
 	if ((sense->mc > 0) && (sense->mc < TAPE_3590_MAX_MSG)) {
 		if (tape_3590_msg[sense->mc] != NULL)
 			dev_warn (&device->cdev->dev, "The tape unit has "
 				"issued sense message %s\n",
 				tape_3590_msg[sense->mc]);
 		else
 			dev_warn (&device->cdev->dev, "The tape unit has "
 				"issued an unknown sense message code 0x%x\n",
 				sense->mc);
 		return;
 	}
 	if (sense->mc == 0xf0) {
 		/* Standard Media Information Message */
 		dev_warn (&device->cdev->dev, "MIM SEV=%i, MC=%02x, ES=%x/%x, "
 			"RC=%02x-%04x-%02x\n", sense->fmt.f70.sev, sense->mc,
 			sense->fmt.f70.emc, sense->fmt.f70.smc,
 			sense->fmt.f70.refcode, sense->fmt.f70.mid,
 			sense->fmt.f70.fid);
 		tape_3590_print_mim_msg_f0(device, irb);
 		return;
 	}
 	if (sense->mc == 0xf1) {
 		/* Standard I/O Subsystem Service Information Message */
 		dev_warn (&device->cdev->dev, "IOSIM SEV=%i, DEVTYPE=3590/%02x,"
 			" MC=%02x, ES=%x/%x, REF=0x%04x-0x%04x-0x%04x\n",
 			sense->fmt.f71.sev, device->cdev->id.dev_model,
 			sense->mc, sense->fmt.f71.emc, sense->fmt.f71.smc,
 			sense->fmt.f71.refcode1, sense->fmt.f71.refcode2,
 			sense->fmt.f71.refcode3);
 		tape_3590_print_io_sim_msg_f1(device, irb);
 		return;
 	}
 	if (sense->mc == 0xf2) {
 		/* Standard Device Service Information Message */
 		dev_warn (&device->cdev->dev, "DEVSIM SEV=%i, DEVTYPE=3590/%02x"
 			", MC=%02x, ES=%x/%x, REF=0x%04x-0x%04x-0x%04x\n",
 			sense->fmt.f71.sev, device->cdev->id.dev_model,
 			sense->mc, sense->fmt.f71.emc, sense->fmt.f71.smc,
 			sense->fmt.f71.refcode1, sense->fmt.f71.refcode2,
 			sense->fmt.f71.refcode3);
 		tape_3590_print_dev_sim_msg_f2(device, irb);
 		return;
 	}
 	if (sense->mc == 0xf3) {
 		/* Standard Library Service Information Message */
 		return;
 	}
 	dev_warn (&device->cdev->dev, "The tape unit has issued an unknown "
 		"sense message code %x\n", sense->mc);
 }
 static int tape_3590_crypt_error(struct tape_device *device,
 				 struct tape_request *request, struct irb *irb)
 {
 	u8 cu_rc, ekm_rc1;
 	u16 ekm_rc2;
 	u32 drv_rc;
 	const char *bus_id;
 	char *sense;
 	sense = ((struct tape_3590_sense *) irb->ecw)->fmt.data;
 	bus_id = dev_name(&device->cdev->dev);
 	cu_rc = sense[0];
 	drv_rc = *((u32*) &sense[5]) & 0xffffff;
 	ekm_rc1 = sense[9];
 	ekm_rc2 = *((u16*) &sense[10]);
 	if ((cu_rc == 0) && (ekm_rc2 == 0xee31))
 		/* key not defined on EKM */
 		return tape_3590_erp_basic(device, request, irb, -EKEYREJECTED);
 	if ((cu_rc == 1) || (cu_rc == 2))
 		/* No connection to EKM */
 		return tape_3590_erp_basic(device, request, irb, -ENOTCONN);
 	dev_err (&device->cdev->dev, "The tape unit failed to obtain the "
 		"encryption key from EKM\n");
 	return tape_3590_erp_basic(device, request, irb, -ENOKEY);
 }
 /*
  *  3590 error Recovery routine:
  *  If possible, it tries to recover from the error. If this is not possible,
  *  inform the user about the problem.
  */
 static int
 tape_3590_unit_check(struct tape_device *device, struct tape_request *request,
 		     struct irb *irb)
 {
 	struct tape_3590_sense *sense;
 	int rc;
 #ifdef CONFIG_S390_TAPE_BLOCK
 	if (request->op == TO_BLOCK) {
 		/*
 		 * Recovery for block device requests. Set the block_position
 		 * to something invalid and retry.
 		 */
 		device->blk_data.block_position = -1;
 		if (request->retries-- <= 0)
 			return tape_3590_erp_failed(device, request, irb, -EIO);
 		else
 			return tape_3590_erp_retry(device, request, irb);
 	}
 #endif
 	sense = (struct tape_3590_sense *) irb->ecw;
 	DBF_EVENT(6, "Unit Check: RQC = %x\n", sense->rc_rqc);
 	/*
 	 * First check all RC-QRCs where we want to do something special
 	 *   - "break":     basic error recovery is done
 	 *   - "goto out:": just print error message if available
 	 */
 	rc = -EIO;
 	switch (sense->rc_rqc) {
 	case 0x1110:
 		tape_3590_print_era_msg(device, irb);
 		return tape_3590_erp_read_buf_log(device, request, irb);
 	case 0x2011:
 		tape_3590_print_era_msg(device, irb);
 		return tape_3590_erp_read_alternate(device, request, irb);
 	case 0x2230:
 	case 0x2231:
 		tape_3590_print_era_msg(device, irb);
 		return tape_3590_erp_special_interrupt(device, request, irb);
 	case 0x2240:
 		return tape_3590_crypt_error(device, request, irb);
 	case 0x3010:
 		DBF_EVENT(2, "(%08x): Backward at Beginning of Partition\n",
 			  device->cdev_id);
 		return tape_3590_erp_basic(device, request, irb, -ENOSPC);
 	case 0x3012:
 		DBF_EVENT(2, "(%08x): Forward at End of Partition\n",
 			  device->cdev_id);
 		return tape_3590_erp_basic(device, request, irb, -ENOSPC);
 	case 0x3020:
 		DBF_EVENT(2, "(%08x): End of Data Mark\n", device->cdev_id);
 		return tape_3590_erp_basic(device, request, irb, -ENOSPC);
 	case 0x3122:
 		DBF_EVENT(2, "(%08x): Rewind Unload initiated\n",
 			  device->cdev_id);
 		return tape_3590_erp_basic(device, request, irb, -EIO);
 	case 0x3123:
 		DBF_EVENT(2, "(%08x): Rewind Unload complete\n",
 			  device->cdev_id);
 		tape_med_state_set(device, MS_UNLOADED);
 		tape_3590_schedule_work(device, TO_CRYPT_OFF);
 		return tape_3590_erp_basic(device, request, irb, 0);
 	case 0x4010:
 		/*
 		 * print additional msg since default msg
 		 * "device intervention" is not very meaningfull
 		 */
 		tape_med_state_set(device, MS_UNLOADED);
 		tape_3590_schedule_work(device, TO_CRYPT_OFF);
 		return tape_3590_erp_basic(device, request, irb, -ENOMEDIUM);
 	case 0x4012:		/* Device Long Busy */
 		/* XXX: Also use long busy handling here? */
 		DBF_EVENT(6, "(%08x): LONG BUSY\n", device->cdev_id);
 		tape_3590_print_era_msg(device, irb);
 		return tape_3590_erp_basic(device, request, irb, -EBUSY);
 	case 0x4014:
 		DBF_EVENT(6, "(%08x): Crypto LONG BUSY\n", device->cdev_id);
 		return tape_3590_erp_long_busy(device, request, irb);
 	case 0x5010:
 		if (sense->rac == 0xd0) {
 			/* Swap */
 			tape_3590_print_era_msg(device, irb);
 			return tape_3590_erp_swap(device, request, irb);
 		}
 		if (sense->rac == 0x26) {
 			/* Read Opposite */
 			tape_3590_print_era_msg(device, irb);
 			return tape_3590_erp_read_opposite(device, request,
 							   irb);
 		}
 		return tape_3590_erp_basic(device, request, irb, -EIO);
 	case 0x5020:
 	case 0x5021:
 	case 0x5022:
 	case 0x5040:
 	case 0x5041:
 	case 0x5042:
 		tape_3590_print_era_msg(device, irb);
 		return tape_3590_erp_swap(device, request, irb);
 	case 0x5110:
 	case 0x5111:
 		return tape_3590_erp_basic(device, request, irb, -EMEDIUMTYPE);
 	case 0x5120:
 	case 0x1120:
 		tape_med_state_set(device, MS_UNLOADED);
 		tape_3590_schedule_work(device, TO_CRYPT_OFF);
 		return tape_3590_erp_basic(device, request, irb, -ENOMEDIUM);
 	case 0x6020:
 		return tape_3590_erp_basic(device, request, irb, -EMEDIUMTYPE);
 	case 0x8011:
 		return tape_3590_erp_basic(device, request, irb, -EPERM);
 	case 0x8013:
 		dev_warn (&device->cdev->dev, "A different host has privileged"
 			" access to the tape unit\n");
 		return tape_3590_erp_basic(device, request, irb, -EPERM);
 	default:
 		return tape_3590_erp_basic(device, request, irb, -EIO);
 	}
 }
 /*
  * 3590 interrupt handler:
  */
 static int
 tape_3590_irq(struct tape_device *device, struct tape_request *request,
 	      struct irb *irb)
 {
 	if (request == NULL)
 		return tape_3590_unsolicited_irq(device, irb);
 	if ((irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) &&
 	    (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) &&
 	    (request->op == TO_WRI)) {
 		/* Write at end of volume */
 		DBF_EVENT(2, "End of volume\n");
 		return tape_3590_erp_failed(device, request, irb, -ENOSPC);
 	}
 	if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)
 		return tape_3590_unit_check(device, request, irb);
 	if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) {
 		if (irb->scsw.cmd.dstat == DEV_STAT_UNIT_EXCEP) {
 			if (request->op == TO_FSB || request->op == TO_BSB)
 				request->rescnt++;
 			else
 				DBF_EVENT(5, "Unit Exception!\n");
 		}
 		return tape_3590_done(device, request);
 	}
 	if (irb->scsw.cmd.dstat & DEV_STAT_CHN_END) {
 		DBF_EVENT(2, "cannel end\n");
 		return TAPE_IO_PENDING;
 	}
 	if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
 		DBF_EVENT(2, "Unit Attention when busy..\n");
 		return TAPE_IO_PENDING;
 	}
 	DBF_EVENT(6, "xunknownirq\n");
 	tape_dump_sense_dbf(device, request, irb);
 	return TAPE_IO_STOP;
 }
 static int tape_3590_read_dev_chars(struct tape_device *device,
 				    struct tape_3590_rdc_data *rdc_data)
 {
 	int rc;
 	struct tape_request *request;
 	request = tape_alloc_request(1, sizeof(*rdc_data));
 	if (IS_ERR(request))
 		return PTR_ERR(request);
 	request->op = TO_RDC;
 	tape_ccw_end(request->cpaddr, CCW_CMD_RDC, sizeof(*rdc_data),
 		     request->cpdata);
 	rc = tape_do_io(device, request);
 	if (rc == 0)
 		memcpy(rdc_data, request->cpdata, sizeof(*rdc_data));
 	tape_free_request(request);
 	return rc;
 }
 /*
  * Setup device function
  */
 static int
 tape_3590_setup_device(struct tape_device *device)
 {
 	int rc;
 	struct tape_3590_disc_data *data;
 	struct tape_3590_rdc_data *rdc_data;
 	DBF_EVENT(6, "3590 device setup\n");
 	data = kzalloc(sizeof(struct tape_3590_disc_data), GFP_KERNEL | GFP_DMA);
 	if (data == NULL)
 		return -ENOMEM;
 	data->read_back_op = READ_PREVIOUS;
 	device->discdata = data;
 	rdc_data = kmalloc(sizeof(*rdc_data), GFP_KERNEL | GFP_DMA);
 	if (!rdc_data) {
 		rc = -ENOMEM;
 		goto fail_kmalloc;
 	}
 	rc = tape_3590_read_dev_chars(device, rdc_data);
 	if (rc) {
 		DBF_LH(3, "Read device characteristics failed!\n");
 		goto fail_rdc_data;
 	}
 	rc = tape_std_assign(device);
 	if (rc)
 		goto fail_rdc_data;
 	if (rdc_data->data[31] == 0x13) {
 		data->crypt_info.capability |= TAPE390_CRYPT_SUPPORTED_MASK;
 		tape_3592_disable_crypt(device);
 	} else {
 		DBF_EVENT(6, "Device has NO crypto support\n");
 	}
 	/* Try to find out if medium is loaded */
 	rc = tape_3590_sense_medium(device);
 	if (rc) {
 		DBF_LH(3, "3590 medium sense returned %d\n", rc);
 		goto fail_rdc_data;
 	}
 	return 0;
 fail_rdc_data:
 	kfree(rdc_data);
 fail_kmalloc:
 	kfree(data);
 	return rc;
 }
 /*
  * Cleanup device function
  */
 static void
 tape_3590_cleanup_device(struct tape_device *device)
 {
 	flush_scheduled_work();
 	tape_std_unassign(device);
 	kfree(device->discdata);
 	device->discdata = NULL;
 }
 /*
  * List of 3590 magnetic tape commands.
  */
 static tape_mtop_fn tape_3590_mtop[TAPE_NR_MTOPS] = {
 	[MTRESET]	 = tape_std_mtreset,
 	[MTFSF]		 = tape_std_mtfsf,
 	[MTBSF]		 = tape_std_mtbsf,
 	[MTFSR]		 = tape_std_mtfsr,
 	[MTBSR]		 = tape_std_mtbsr,
 	[MTWEOF]	 = tape_std_mtweof,
 	[MTREW]		 = tape_std_mtrew,
 	[MTOFFL]	 = tape_std_mtoffl,
 	[MTNOP]		 = tape_std_mtnop,
 	[MTRETEN]	 = tape_std_mtreten,
 	[MTBSFM]	 = tape_std_mtbsfm,
 	[MTFSFM]	 = tape_std_mtfsfm,
 	[MTEOM]		 = tape_std_mteom,
 	[MTERASE]	 = tape_std_mterase,
 	[MTRAS1]	 = NULL,
 	[MTRAS2]	 = NULL,
 	[MTRAS3]	 = NULL,
 	[MTSETBLK]	 = tape_std_mtsetblk,
 	[MTSETDENSITY]	 = NULL,
 	[MTSEEK]	 = tape_3590_mtseek,
 	[MTTELL]	 = tape_3590_mttell,
 	[MTSETDRVBUFFER] = NULL,
 	[MTFSS]		 = NULL,
 	[MTBSS]		 = NULL,
 	[MTWSM]		 = NULL,
 	[MTLOCK]	 = NULL,
 	[MTUNLOCK]	 = NULL,
 	[MTLOAD]	 = tape_std_mtload,
 	[MTUNLOAD]	 = tape_std_mtunload,
 	[MTCOMPRESSION]	 = tape_std_mtcompression,
 	[MTSETPART]	 = NULL,
 	[MTMKPART]	 = NULL
 };
 /*
  * Tape discipline structure for 3590.
  */
 static struct tape_discipline tape_discipline_3590 = {
 	.owner = THIS_MODULE,
 	.setup_device = tape_3590_setup_device,
 	.cleanup_device = tape_3590_cleanup_device,
 	.process_eov = tape_std_process_eov,
 	.irq = tape_3590_irq,
 	.read_block = tape_std_read_block,
 	.write_block = tape_std_write_block,
 #ifdef CONFIG_S390_TAPE_BLOCK
 	.bread = tape_3590_bread,
 	.free_bread = tape_3590_free_bread,
 	.check_locate = tape_3590_check_locate,
 #endif
 	.ioctl_fn = tape_3590_ioctl,
 	.mtop_array = tape_3590_mtop
 };
 static struct ccw_device_id tape_3590_ids[] = {
 	{CCW_DEVICE_DEVTYPE(0x3590, 0, 0x3590, 0), .driver_info = tape_3590},
 	{CCW_DEVICE_DEVTYPE(0x3592, 0, 0x3592, 0), .driver_info = tape_3592},
 	{ /* end of list */ }
 };
 static int
 tape_3590_online(struct ccw_device *cdev)
 {
 	return tape_generic_online(dev_get_drvdata(&cdev->dev),
 				   &tape_discipline_3590);
 }
 static struct ccw_driver tape_3590_driver = {
 	.name = "tape_3590",
 	.owner = THIS_MODULE,
 	.ids = tape_3590_ids,
 	.probe = tape_generic_probe,
 	.remove = tape_generic_remove,
 	.set_offline = tape_generic_offline,
 	.set_online = tape_3590_online,
 	.freeze = tape_generic_pm_suspend,
 };
 /*
  * Setup discipline structure.
  */
 static int
 tape_3590_init(void)
 {
 	int rc;
 	TAPE_DBF_AREA = debug_register("tape_3590", 2, 2, 4 * sizeof(long));
 	debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
 #ifdef DBF_LIKE_HELL
 	debug_set_level(TAPE_DBF_AREA, 6);
 #endif
 	DBF_EVENT(3, "3590 init\n");
 	/* Register driver for 3590 tapes. */
 	rc = ccw_driver_register(&tape_3590_driver);
 	if (rc)
 		DBF_EVENT(3, "3590 init failed\n");
 	else
 		DBF_EVENT(3, "3590 registered\n");
 	return rc;
 }
 static void
 tape_3590_exit(void)
 {
 	ccw_driver_unregister(&tape_3590_driver);
 	debug_unregister(TAPE_DBF_AREA);
 }
 MODULE_DEVICE_TABLE(ccw, tape_3590_ids);
 MODULE_AUTHOR("(C) 2001,2006 IBM Corporation");
 MODULE_DESCRIPTION("Linux on zSeries channel attached 3590 tape device driver");
 MODULE_LICENSE("GPL");
 module_init(tape_3590_init);
 module_exit(tape_3590_exit);

drivers/s390/char/tape_block.c

Diff comments View file @ bb50991

 /*
  *  drivers/s390/char/tape_block.c
  *    block device frontend for tape device driver
  *
  *  S390 and zSeries version
  *    Copyright (C) 2001,2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
  *    Author(s): Carsten Otte <cotte@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/fs.h>
 #include <linux/module.h>
 #include <linux/blkdev.h>
 #include <linux/interrupt.h>
 #include <linux/buffer_head.h>
 #include <linux/kernel.h>
 #include <asm/debug.h>
 #define TAPE_DBF_AREA	tape_core_dbf
 #include "tape.h"
 #define TAPEBLOCK_MAX_SEC	100
 #define TAPEBLOCK_MIN_REQUEUE	3
 /*
  * 2003/11/25  Stefan Bader <shbader@de.ibm.com>
  *
  * In 2.5/2.6 the block device request function is very likely to be called
  * with disabled interrupts (e.g. generic_unplug_device). So the driver can't
  * just call any function that tries to allocate CCW requests from that con-
  * text since it might sleep. There are two choices to work around this:
  *	a) do not allocate with kmalloc but use its own memory pool
  *      b) take requests from the queue outside that context, knowing that
  *         allocation might sleep
  */
 /*
  * file operation structure for tape block frontend
  */
 static int tapeblock_open(struct block_device *, fmode_t);
 static int tapeblock_release(struct gendisk *, fmode_t);
 static int tapeblock_ioctl(struct block_device *, fmode_t, unsigned int,
 				unsigned long);
 static int tapeblock_medium_changed(struct gendisk *);
 static int tapeblock_revalidate_disk(struct gendisk *);
 static const struct block_device_operations tapeblock_fops = {
 	.owner		 = THIS_MODULE,
 	.open		 = tapeblock_open,
 	.release	 = tapeblock_release,
 	.ioctl		 = tapeblock_ioctl,
 	.media_changed   = tapeblock_medium_changed,
 	.revalidate_disk = tapeblock_revalidate_disk,
 };
 static int tapeblock_major = 0;
 static void
 tapeblock_trigger_requeue(struct tape_device *device)
 {
 	/* Protect against rescheduling. */
 	if (atomic_cmpxchg(&device->blk_data.requeue_scheduled, 0, 1) != 0)
 		return;
 	schedule_work(&device->blk_data.requeue_task);
 }
 /*
  * Post finished request.
  */
 static void
 __tapeblock_end_request(struct tape_request *ccw_req, void *data)
 {
 	struct tape_device *device;
 	struct request *req;
 	DBF_LH(6, "__tapeblock_end_request()\n");
 	device = ccw_req->device;
 	req = (struct request *) data;
 	blk_end_request_all(req, (ccw_req->rc == 0) ? 0 : -EIO);
 	if (ccw_req->rc == 0)
 		/* Update position. */
 		device->blk_data.block_position =
 		  (blk_rq_pos(req) + blk_rq_sectors(req)) >> TAPEBLOCK_HSEC_S2B;
 	else
 		/* We lost the position information due to an error. */
 		device->blk_data.block_position = -1;
 	device->discipline->free_bread(ccw_req);
 	if (!list_empty(&device->req_queue) ||
 	    blk_peek_request(device->blk_data.request_queue))
 		tapeblock_trigger_requeue(device);
 }
 /*
  * Feed the tape device CCW queue with requests supplied in a list.
  */
 static int
 tapeblock_start_request(struct tape_device *device, struct request *req)
 {
 	struct tape_request *	ccw_req;
 	int			rc;
 	DBF_LH(6, "tapeblock_start_request(%p, %p)\n", device, req);
 	ccw_req = device->discipline->bread(device, req);
 	if (IS_ERR(ccw_req)) {
 		DBF_EVENT(1, "TBLOCK: bread failed\n");
 		blk_end_request_all(req, -EIO);
 		return PTR_ERR(ccw_req);
 	}
 	ccw_req->callback = __tapeblock_end_request;
 	ccw_req->callback_data = (void *) req;
 	ccw_req->retries = TAPEBLOCK_RETRIES;
 	rc = tape_do_io_async(device, ccw_req);
 	if (rc) {
 		/*
 		 * Start/enqueueing failed. No retries in
 		 * this case.
 		 */
 		blk_end_request_all(req, -EIO);
 		device->discipline->free_bread(ccw_req);
 	}
 	return rc;
 }
 /*
  * Move requests from the block device request queue to the tape device ccw
  * queue.
  */
 static void
 tapeblock_requeue(struct work_struct *work) {
 	struct tape_blk_data *	blkdat;
 	struct tape_device *	device;
 	struct request_queue *	queue;
 	int			nr_queued;
 	struct request *	req;
 	struct list_head *	l;
 	int			rc;
 	blkdat = container_of(work, struct tape_blk_data, requeue_task);
 	device = blkdat->device;
 	if (!device)
 		return;
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	queue  = device->blk_data.request_queue;
 	/* Count number of requests on ccw queue. */
 	nr_queued = 0;
 	list_for_each(l, &device->req_queue)
 		nr_queued++;
 	spin_unlock(get_ccwdev_lock(device->cdev));
 	spin_lock_irq(&device->blk_data.request_queue_lock);
 	while (
 		!blk_queue_plugged(queue) &&
 		blk_peek_request(queue) &&
 		nr_queued < TAPEBLOCK_MIN_REQUEUE
 	) {
 		req = blk_fetch_request(queue);
 		if (rq_data_dir(req) == WRITE) {
 			DBF_EVENT(1, "TBLOCK: Rejecting write request\n");
 			spin_unlock_irq(&device->blk_data.request_queue_lock);
 			blk_end_request_all(req, -EIO);
 			spin_lock_irq(&device->blk_data.request_queue_lock);
 			continue;
 		}
 		nr_queued++;
 		spin_unlock_irq(&device->blk_data.request_queue_lock);
 		rc = tapeblock_start_request(device, req);
 		spin_lock_irq(&device->blk_data.request_queue_lock);
 	}
 	spin_unlock_irq(&device->blk_data.request_queue_lock);
 	atomic_set(&device->blk_data.requeue_scheduled, 0);
 }
 /*
  * Tape request queue function. Called from ll_rw_blk.c
  */
 static void
 tapeblock_request_fn(struct request_queue *queue)
 {
 	struct tape_device *device;
 	device = (struct tape_device *) queue->queuedata;
 	DBF_LH(6, "tapeblock_request_fn(device=%p)\n", device);
 	BUG_ON(device == NULL);
 	tapeblock_trigger_requeue(device);
 }
 /*
  * This function is called for every new tapedevice
  */
 int
 tapeblock_setup_device(struct tape_device * device)
 {
 	struct tape_blk_data *	blkdat;
 	struct gendisk *	disk;
 	int			rc;
 	blkdat = &device->blk_data;
 	blkdat->device = device;
 	spin_lock_init(&blkdat->request_queue_lock);
 	atomic_set(&blkdat->requeue_scheduled, 0);
 	blkdat->request_queue = blk_init_queue(
 		tapeblock_request_fn,
 		&blkdat->request_queue_lock
 	);
 	if (!blkdat->request_queue)
 		return -ENOMEM;
 	elevator_exit(blkdat->request_queue->elevator);
 	rc = elevator_init(blkdat->request_queue, "noop");
 	if (rc)
 		goto cleanup_queue;
 	blk_queue_logical_block_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
 	blk_queue_max_sectors(blkdat->request_queue, TAPEBLOCK_MAX_SEC);
 	blk_queue_max_phys_segments(blkdat->request_queue, -1L);
 	blk_queue_max_hw_segments(blkdat->request_queue, -1L);
 	blk_queue_max_segment_size(blkdat->request_queue, -1L);
 	blk_queue_segment_boundary(blkdat->request_queue, -1L);
 	disk = alloc_disk(1);
 	if (!disk) {
 		rc = -ENOMEM;
 		goto cleanup_queue;
 	}
 	disk->major = tapeblock_major;
 	disk->first_minor = device->first_minor;
 	disk->fops = &tapeblock_fops;
 	disk->private_data = tape_get_device(device);
 	disk->queue = blkdat->request_queue;
 	set_capacity(disk, 0);
 	sprintf(disk->disk_name, "btibm%d",
 		device->first_minor / TAPE_MINORS_PER_DEV);
 	blkdat->disk = disk;
 	blkdat->medium_changed = 1;
 	blkdat->request_queue->queuedata = tape_get_device(device);
 	add_disk(disk);
 	tape_get_device(device);
 	INIT_WORK(&blkdat->requeue_task, tapeblock_requeue);
 	return 0;
 cleanup_queue:
 	blk_cleanup_queue(blkdat->request_queue);
 	blkdat->request_queue = NULL;
 	return rc;
 }
 void
 tapeblock_cleanup_device(struct tape_device *device)
 {
 	flush_scheduled_work();
 	tape_put_device(device);
 	if (!device->blk_data.disk) {
 		goto cleanup_queue;
 	}
 	del_gendisk(device->blk_data.disk);
 	device->blk_data.disk->private_data = NULL;
 	tape_put_device(device);
 	put_disk(device->blk_data.disk);
 	device->blk_data.disk = NULL;
 cleanup_queue:
 	device->blk_data.request_queue->queuedata = NULL;
 	tape_put_device(device);
 	blk_cleanup_queue(device->blk_data.request_queue);
 	device->blk_data.request_queue = NULL;
 }
 /*
  * Detect number of blocks of the tape.
  * FIXME: can we extent this to detect the blocks size as well ?
  */
 static int
 tapeblock_revalidate_disk(struct gendisk *disk)
 {
 	struct tape_device *	device;
 	unsigned int		nr_of_blks;
 	int			rc;
 	device = (struct tape_device *) disk->private_data;
 	BUG_ON(!device);
 	if (!device->blk_data.medium_changed)
 		return 0;
 	rc = tape_mtop(device, MTFSFM, 1);
 	if (rc)
 		return rc;
 	rc = tape_mtop(device, MTTELL, 1);
 	if (rc < 0)
 		return rc;
 	pr_info("%s: Determining the size of the recorded area...\n",
 		dev_name(&device->cdev->dev));
 	DBF_LH(3, "Image file ends at %d\n", rc);
 	nr_of_blks = rc;
 	/* This will fail for the first file. Catch the error by checking the
 	 * position. */
 	tape_mtop(device, MTBSF, 1);
 	rc = tape_mtop(device, MTTELL, 1);
 	if (rc < 0)
 		return rc;
 	if (rc > nr_of_blks)
 		return -EINVAL;
 	DBF_LH(3, "Image file starts at %d\n", rc);
 	device->bof = rc;
 	nr_of_blks -= rc;
 	pr_info("%s: The size of the recorded area is %i blocks\n",
 		dev_name(&device->cdev->dev), nr_of_blks);
 	set_capacity(device->blk_data.disk,
 		nr_of_blks*(TAPEBLOCK_HSEC_SIZE/512));
 	device->blk_data.block_position = 0;
 	device->blk_data.medium_changed = 0;
 	return 0;
 }
 static int
 tapeblock_medium_changed(struct gendisk *disk)
 {
 	struct tape_device *device;
 	device = (struct tape_device *) disk->private_data;
 	DBF_LH(6, "tapeblock_medium_changed(%p) = %d\n",
 		device, device->blk_data.medium_changed);
 	return device->blk_data.medium_changed;
 }
 /*
  * Block frontend tape device open function.
  */
 static int
 tapeblock_open(struct block_device *bdev, fmode_t mode)
 {
 	struct gendisk *	disk = bdev->bd_disk;
 	struct tape_device *	device;
 	int			rc;
 	device = tape_get_device(disk->private_data);
 	if (device->required_tapemarks) {
 		DBF_EVENT(2, "TBLOCK: missing tapemarks\n");
 		pr_warning("%s: Opening the tape failed because of missing "
 			   "end-of-file marks\n", dev_name(&device->cdev->dev));
 		rc = -EPERM;
 		goto put_device;
 	}
 	rc = tape_open(device);
 	if (rc)
 		goto put_device;
 	rc = tapeblock_revalidate_disk(disk);
 	if (rc)
 		goto release;
 	/*
 	 * Note: The reference to <device> is hold until the release function
 	 *       is called.
 	 */
 	tape_state_set(device, TS_BLKUSE);
 	return 0;
 release:
 	tape_release(device);
  put_device:
 	tape_put_device(device);
 	return rc;
 }
 /*
  * Block frontend tape device release function.
  *
  * Note: One reference to the tape device was made by the open function. So
  *       we just get the pointer here and release the reference.
  */
 static int
 tapeblock_release(struct gendisk *disk, fmode_t mode)
 {
 	struct tape_device *device = disk->private_data;
 	tape_state_set(device, TS_IN_USE);
 	tape_release(device);
 	tape_put_device(device);
 	return 0;
 }
 /*
  * Support of some generic block device IOCTLs.
  */
 static int
 tapeblock_ioctl(
 	struct block_device *	bdev,
 	fmode_t			mode,
 	unsigned int		command,
 	unsigned long		arg
 ) {
 	int rc;
 	int minor;
 	struct gendisk *disk = bdev->bd_disk;
 	struct tape_device *device;
 	rc     = 0;
 	BUG_ON(!disk);
 	device = disk->private_data;
 	BUG_ON(!device);
 	minor  = MINOR(bdev->bd_dev);
 	DBF_LH(6, "tapeblock_ioctl(0x%0x)\n", command);
 	DBF_LH(6, "device = %d:%d\n", tapeblock_major, minor);
 	switch (command) {
 		/* Refuse some IOCTL calls without complaining (mount). */
 		case 0x5310:		/* CDROMMULTISESSION */
 			rc = -EINVAL;
 			break;
 		default:
 			rc = -EINVAL;
 	}
 	return rc;
 }
 /*
  * Initialize block device frontend.
  */
 int
 tapeblock_init(void)
 {
 	int rc;
 	/* Register the tape major number to the kernel */
 	rc = register_blkdev(tapeblock_major, "tBLK");
 	if (rc < 0)
 		return rc;
 	if (tapeblock_major == 0)
 		tapeblock_major = rc;
 	return 0;
 }
 /*
  * Deregister major for block device frontend
  */
 void
 tapeblock_exit(void)
 {
 	unregister_blkdev(tapeblock_major, "tBLK");
 }

drivers/s390/char/tape_char.c

Diff comments View file @ bb50991

 /*
  *  drivers/s390/char/tape_char.c
  *    character device frontend for tape device driver
  *
  *  S390 and zSeries version
  *    Copyright IBM Corp. 2001,2006
  *    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>
  */
+#define KMSG_COMPONENT "tape"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/proc_fs.h>
 #include <linux/mtio.h>
 #include <linux/smp_lock.h>
 #include <asm/uaccess.h>
 #define TAPE_DBF_AREA	tape_core_dbf
 #include "tape.h"
 #include "tape_std.h"
 #include "tape_class.h"
 #define TAPECHAR_MAJOR		0	/* get dynamic major */
 /*
  * file operation structure for tape character frontend
  */
 static ssize_t tapechar_read(struct file *, char __user *, size_t, loff_t *);
 static ssize_t tapechar_write(struct file *, const char __user *, size_t, loff_t *);
 static int tapechar_open(struct inode *,struct file *);
 static int tapechar_release(struct inode *,struct file *);
 static long tapechar_ioctl(struct file *, unsigned int, unsigned long);
 static long tapechar_compat_ioctl(struct file *, unsigned int,
 			  unsigned long);
 static const struct file_operations tape_fops =
 {
 	.owner = THIS_MODULE,
 	.read = tapechar_read,
 	.write = tapechar_write,
 	.unlocked_ioctl = tapechar_ioctl,
 	.compat_ioctl = tapechar_compat_ioctl,
 	.open = tapechar_open,
 	.release = tapechar_release,
 };
 static int tapechar_major = TAPECHAR_MAJOR;
 /*
  * This function is called for every new tapedevice
  */
 int
 tapechar_setup_device(struct tape_device * device)
 {
 	char	device_name[20];
 	sprintf(device_name, "ntibm%i", device->first_minor / 2);
 	device->nt = register_tape_dev(
 		&device->cdev->dev,
 		MKDEV(tapechar_major, device->first_minor),
 		&tape_fops,
 		device_name,
 		"non-rewinding"
 	);
 	device_name[0] = 'r';
 	device->rt = register_tape_dev(
 		&device->cdev->dev,
 		MKDEV(tapechar_major, device->first_minor + 1),
 		&tape_fops,
 		device_name,
 		"rewinding"
 	);
 	return 0;
 }
 void
 tapechar_cleanup_device(struct tape_device *device)
 {
 	unregister_tape_dev(&device->cdev->dev, device->rt);
 	device->rt = NULL;
 	unregister_tape_dev(&device->cdev->dev, device->nt);
 	device->nt = NULL;
 }
 static int
 tapechar_check_idalbuffer(struct tape_device *device, size_t block_size)
 {
 	struct idal_buffer *new;
 	if (device->char_data.idal_buf != NULL &&
 	    device->char_data.idal_buf->size == block_size)
 		return 0;
 	if (block_size > MAX_BLOCKSIZE) {
 		DBF_EVENT(3, "Invalid blocksize (%zd > %d)\n",
 			block_size, MAX_BLOCKSIZE);
 		return -EINVAL;
 	}
 	/* The current idal buffer is not correct. Allocate a new one. */
 	new = idal_buffer_alloc(block_size, 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;
 	return 0;
 }
 /*
  * Tape device read function
  */
 static ssize_t
 tapechar_read(struct file *filp, char __user *data, size_t count, loff_t *ppos)
 {
 	struct tape_device *device;
 	struct tape_request *request;
 	size_t block_size;
 	int rc;
 	DBF_EVENT(6, "TCHAR:read\n");
 	device = (struct tape_device *) filp->private_data;
 	/*
 	 * If the tape isn't terminated yet, do it now. And since we then
 	 * are at the end of the tape there wouldn't be anything to read
 	 * anyways. So we return immediatly.
 	 */
 	if(device->required_tapemarks) {
 		return tape_std_terminate_write(device);
 	}
 	/* Find out block size to use */
 	if (device->char_data.block_size != 0) {
 		if (count < device->char_data.block_size) {
 			DBF_EVENT(3, "TCHAR:read smaller than block "
 				  "size was requested\n");
 			return -EINVAL;
 		}
 		block_size = device->char_data.block_size;
 	} else {
 		block_size = count;
 	}
 	rc = tapechar_check_idalbuffer(device, block_size);
 	if (rc)
 		return rc;
 #ifdef CONFIG_S390_TAPE_BLOCK
 	/* Changes position. */
 	device->blk_data.medium_changed = 1;
 #endif
 	DBF_EVENT(6, "TCHAR:nbytes: %lx\n", block_size);
 	/* Let the discipline build the ccw chain. */
 	request = device->discipline->read_block(device, block_size);
 	if (IS_ERR(request))
 		return PTR_ERR(request);
 	/* Execute it. */
 	rc = tape_do_io(device, request);
 	if (rc == 0) {
 		rc = block_size - request->rescnt;
 		DBF_EVENT(6, "TCHAR:rbytes:  %x\n", rc);
 		/* Copy data from idal buffer to user space. */
 		if (idal_buffer_to_user(device->char_data.idal_buf,
 					data, rc) != 0)
 			rc = -EFAULT;
 	}
 	tape_free_request(request);
 	return rc;
 }
 /*
  * Tape device write function
  */
 static ssize_t
 tapechar_write(struct file *filp, const char __user *data, size_t count, loff_t *ppos)
 {
 	struct tape_device *device;
 	struct tape_request *request;
 	size_t block_size;
 	size_t written;
 	int nblocks;
 	int i, rc;
 	DBF_EVENT(6, "TCHAR:write\n");
 	device = (struct tape_device *) filp->private_data;
 	/* Find out block size and number of blocks */
 	if (device->char_data.block_size != 0) {
 		if (count < device->char_data.block_size) {
 			DBF_EVENT(3, "TCHAR:write smaller than block "
 				  "size was requested\n");
 			return -EINVAL;
 		}
 		block_size = device->char_data.block_size;
 		nblocks = count / block_size;
 	} else {
 		block_size = count;
 		nblocks = 1;
 	}
 	rc = tapechar_check_idalbuffer(device, block_size);
 	if (rc)
 		return rc;
 #ifdef CONFIG_S390_TAPE_BLOCK
 	/* Changes position. */
 	device->blk_data.medium_changed = 1;
 #endif
 	DBF_EVENT(6,"TCHAR:nbytes: %lx\n", block_size);
 	DBF_EVENT(6, "TCHAR:nblocks: %x\n", nblocks);
 	/* Let the discipline build the ccw chain. */
 	request = device->discipline->write_block(device, block_size);
 	if (IS_ERR(request))
 		return PTR_ERR(request);
 	rc = 0;
 	written = 0;
 	for (i = 0; i < nblocks; i++) {
 		/* Copy data from user space to idal buffer. */
 		if (idal_buffer_from_user(device->char_data.idal_buf,
 					  data, block_size)) {
 			rc = -EFAULT;
 			break;
 		}
 		rc = tape_do_io(device, request);
 		if (rc)
 			break;
 		DBF_EVENT(6, "TCHAR:wbytes: %lx\n",
 			  block_size - request->rescnt);
 		written += block_size - request->rescnt;
 		if (request->rescnt != 0)
 			break;
 		data += block_size;
 	}
 	tape_free_request(request);
 	if (rc == -ENOSPC) {
 		/*
 		 * Ok, the device has no more space. It has NOT written
 		 * the block.
 		 */
 		if (device->discipline->process_eov)
 			device->discipline->process_eov(device);
 		if (written > 0)
 			rc = 0;
 	}
 	/*
 	 * After doing a write we always need two tapemarks to correctly
 	 * terminate the tape (one to terminate the file, the second to
 	 * flag the end of recorded data.
 	 * Since process_eov positions the tape in front of the written
 	 * tapemark it doesn't hurt to write two marks again.
 	 */
 	if (!rc)
 		device->required_tapemarks = 2;
 	return rc ? rc : written;
 }
 /*
  * Character frontend tape device open function.
  */
 static int
 tapechar_open (struct inode *inode, struct file *filp)
 {
 	struct tape_device *device;
 	int minor, rc;
 	DBF_EVENT(6, "TCHAR:open: %i:%i\n",
 		imajor(filp->f_path.dentry->d_inode),
 		iminor(filp->f_path.dentry->d_inode));
 	if (imajor(filp->f_path.dentry->d_inode) != tapechar_major)
 		return -ENODEV;
 	minor = iminor(filp->f_path.dentry->d_inode);
 	device = tape_find_device(minor / TAPE_MINORS_PER_DEV);
 	if (IS_ERR(device)) {
 		DBF_EVENT(3, "TCHAR:open: tape_find_device() failed\n");
 		return PTR_ERR(device);
 	}
 	rc = tape_open(device);
 	if (rc == 0) {
 		filp->private_data = device;
 		nonseekable_open(inode, filp);
 	} else
 		tape_put_device(device);
 	return rc;
 }
 /*
  * Character frontend tape device release function.
  */
 static int
 tapechar_release(struct inode *inode, struct file *filp)
 {
 	struct tape_device *device;
 	DBF_EVENT(6, "TCHAR:release: %x\n", iminor(inode));
 	device = (struct tape_device *) filp->private_data;
 	/*
 	 * If this is the rewinding tape minor then rewind. In that case we
 	 * write all required tapemarks. Otherwise only one to terminate the
 	 * file.
 	 */
 	if ((iminor(inode) & 1) != 0) {
 		if (device->required_tapemarks)
 			tape_std_terminate_write(device);
 		tape_mtop(device, MTREW, 1);
 	} else {
 		if (device->required_tapemarks > 1) {
 			if (tape_mtop(device, MTWEOF, 1) == 0)
 				device->required_tapemarks--;
 		}
 	}
 	if (device->char_data.idal_buf != NULL) {
 		idal_buffer_free(device->char_data.idal_buf);
 		device->char_data.idal_buf = NULL;
 	}
 	tape_release(device);
 	filp->private_data = NULL;
 	tape_put_device(device);
 	return 0;
 }
 /*
  * Tape device io controls.
  */
 static int
 __tapechar_ioctl(struct tape_device *device,
 		 unsigned int no, unsigned long data)
 {
 	int rc;
 	if (no == MTIOCTOP) {
 		struct mtop op;
 		if (copy_from_user(&op, (char __user *) data, sizeof(op)) != 0)
 			return -EFAULT;
 		if (op.mt_count < 0)
 			return -EINVAL;
 		/*
 		 * Operations that change tape position should write final
 		 * tapemarks.
 		 */
 		switch (op.mt_op) {
 			case MTFSF:
 			case MTBSF:
 			case MTFSR:
 			case MTBSR:
 			case MTREW:
 			case MTOFFL:
 			case MTEOM:
 			case MTRETEN:
 			case MTBSFM:
 			case MTFSFM:
 			case MTSEEK:
 #ifdef CONFIG_S390_TAPE_BLOCK
 				device->blk_data.medium_changed = 1;
 #endif
 				if (device->required_tapemarks)
 					tape_std_terminate_write(device);
 			default:
 				;
 		}
 		rc = tape_mtop(device, op.mt_op, op.mt_count);
 		if (op.mt_op == MTWEOF && rc == 0) {
 			if (op.mt_count > device->required_tapemarks)
 				device->required_tapemarks = 0;
 			else
 				device->required_tapemarks -= op.mt_count;
 		}
 		return rc;
 	}
 	if (no == MTIOCPOS) {
 		/* MTIOCPOS: query the tape position. */
 		struct mtpos pos;
 		rc = tape_mtop(device, MTTELL, 1);
 		if (rc < 0)
 			return rc;
 		pos.mt_blkno = rc;
 		if (copy_to_user((char __user *) data, &pos, sizeof(pos)) != 0)
 			return -EFAULT;
 		return 0;
 	}
 	if (no == MTIOCGET) {
 		/* MTIOCGET: query the tape drive status. */
 		struct mtget get;
 		memset(&get, 0, sizeof(get));
 		get.mt_type = MT_ISUNKNOWN;
 		get.mt_resid = 0 /* device->devstat.rescnt */;
 		get.mt_dsreg = device->tape_state;
 		/* FIXME: mt_gstat, mt_erreg, mt_fileno */
 		get.mt_gstat = 0;
 		get.mt_erreg = 0;
 		get.mt_fileno = 0;
 		get.mt_gstat  = device->tape_generic_status;
 		if (device->medium_state == MS_LOADED) {
 			rc = tape_mtop(device, MTTELL, 1);
 			if (rc < 0)
 				return rc;
 			if (rc == 0)
 				get.mt_gstat |= GMT_BOT(~0);
 			get.mt_blkno = rc;
 		}
 		if (copy_to_user((char __user *) data, &get, sizeof(get)) != 0)
 			return -EFAULT;
 		return 0;
 	}
 	/* Try the discipline ioctl function. */
 	if (device->discipline->ioctl_fn == NULL)
 		return -EINVAL;
 	return device->discipline->ioctl_fn(device, no, data);
 }
 static long
 tapechar_ioctl(struct file *filp, unsigned int no, unsigned long data)
 {
 	struct tape_device *device;
 	long rc;
 	DBF_EVENT(6, "TCHAR:ioct\n");
 	device = (struct tape_device *) filp->private_data;
 	mutex_lock(&device->mutex);
 	rc = __tapechar_ioctl(device, no, data);
 	mutex_unlock(&device->mutex);
 	return rc;
 }
 static long
 tapechar_compat_ioctl(struct file *filp, unsigned int no, unsigned long data)
 {
 	struct tape_device *device = filp->private_data;
 	int rval = -ENOIOCTLCMD;
 	if (device->discipline->ioctl_fn) {
 		mutex_lock(&device->mutex);
 		rval = device->discipline->ioctl_fn(device, no, data);
 		mutex_unlock(&device->mutex);
 		if (rval == -EINVAL)
 			rval = -ENOIOCTLCMD;
 	}
 	return rval;
 }
 /*
  * Initialize character device frontend.
  */
 int
 tapechar_init (void)
 {
 	dev_t	dev;
 	if (alloc_chrdev_region(&dev, 0, 256, "tape") != 0)
 		return -1;
 	tapechar_major = MAJOR(dev);
 	return 0;
 }
 /*
  * cleanup
  */
 void
 tapechar_exit(void)
 {
 	unregister_chrdev_region(MKDEV(tapechar_major, 0), 256);
 }

drivers/s390/char/tape_class.c

Diff comments View file @ bb50991

 /*
  * (C) Copyright IBM Corp. 2004
  * tape_class.c
  *
  * Tape class device support
  *
  * Author: Stefan Bader <shbader@de.ibm.com>
  * Based on simple class device code by Greg K-H
  */
+#define KMSG_COMPONENT "tape"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include "tape_class.h"
 MODULE_AUTHOR("Stefan Bader <shbader@de.ibm.com>");
 MODULE_DESCRIPTION(
 	"(C) Copyright IBM Corp. 2004   All Rights Reserved.\n"
 	"tape_class.c"
 );
 MODULE_LICENSE("GPL");
 static struct class *tape_class;
 /*
  * Register a tape device and return a pointer to the cdev structure.
  *
  * device
  *	The pointer to the struct device of the physical (base) device.
  * drivername
  *	The pointer to the drivers name for it's character devices.
  * dev
  *	The intended major/minor number. The major number may be 0 to
  *	get a dynamic major number.
  * fops
  *	The pointer to the drivers file operations for the tape device.
  * devname
  *	The pointer to the name of the character device.
  */
 struct tape_class_device *register_tape_dev(
 	struct device *		device,
 	dev_t			dev,
 	const struct file_operations *fops,
 	char *			device_name,
 	char *			mode_name)
 {
 	struct tape_class_device *	tcd;
 	int		rc;
 	char *		s;
 	tcd = kzalloc(sizeof(struct tape_class_device), GFP_KERNEL);
 	if (!tcd)
 		return ERR_PTR(-ENOMEM);
 	strncpy(tcd->device_name, device_name, TAPECLASS_NAME_LEN);
 	for (s = strchr(tcd->device_name, '/'); s; s = strchr(s, '/'))
 		*s = '!';
 	strncpy(tcd->mode_name, mode_name, TAPECLASS_NAME_LEN);
 	for (s = strchr(tcd->mode_name, '/'); s; s = strchr(s, '/'))
 		*s = '!';
 	tcd->char_device = cdev_alloc();
 	if (!tcd->char_device) {
 		rc = -ENOMEM;
 		goto fail_with_tcd;
 	}
 	tcd->char_device->owner = fops->owner;
 	tcd->char_device->ops   = fops;
 	tcd->char_device->dev   = dev;
 	rc = cdev_add(tcd->char_device, tcd->char_device->dev, 1);
 	if (rc)
 		goto fail_with_cdev;
 	tcd->class_device = device_create(tape_class, device,
 					  tcd->char_device->dev, NULL,
 					  "%s", tcd->device_name);
 	rc = IS_ERR(tcd->class_device) ? PTR_ERR(tcd->class_device) : 0;
 	if (rc)
 		goto fail_with_cdev;
 	rc = sysfs_create_link(
 		&device->kobj,
 		&tcd->class_device->kobj,
 		tcd->mode_name
 	);
 	if (rc)
 		goto fail_with_class_device;
 	return tcd;
 fail_with_class_device:
 	device_destroy(tape_class, tcd->char_device->dev);
 fail_with_cdev:
 	cdev_del(tcd->char_device);
 fail_with_tcd:
 	kfree(tcd);
 	return ERR_PTR(rc);
 }
 EXPORT_SYMBOL(register_tape_dev);
 void unregister_tape_dev(struct device *device, struct tape_class_device *tcd)
 {
 	if (tcd != NULL && !IS_ERR(tcd)) {
 		sysfs_remove_link(&device->kobj, tcd->mode_name);
 		device_destroy(tape_class, tcd->char_device->dev);
 		cdev_del(tcd->char_device);
 		kfree(tcd);
 	}
 }
 EXPORT_SYMBOL(unregister_tape_dev);
 static int __init tape_init(void)
 {
 	tape_class = class_create(THIS_MODULE, "tape390");
 	return 0;
 }
 static void __exit tape_exit(void)
 {
 	class_destroy(tape_class);
 	tape_class = NULL;
 }
 postcore_initcall(tape_init);
 module_exit(tape_exit);

drivers/s390/char/tape_core.c

Diff comments View file @ bb50991

 /*
  *  drivers/s390/char/tape_core.c
  *    basic function of the tape device driver
  *
  *  S390 and zSeries version
  *    Copyright IBM Corp. 2001, 2009
  *    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/module.h>
 #include <linux/init.h>	     // for kernel parameters
 #include <linux/kmod.h>	     // for requesting modules
 #include <linux/spinlock.h>  // for locks
 #include <linux/vmalloc.h>
 #include <linux/list.h>
 #include <asm/types.h>	     // for variable types
 #define TAPE_DBF_AREA	tape_core_dbf
 #include "tape.h"
 #include "tape_std.h"
 #define LONG_BUSY_TIMEOUT 180 /* seconds */
 static void __tape_do_irq (struct ccw_device *, unsigned long, struct irb *);
 static void tape_delayed_next_request(struct work_struct *);
 static void tape_long_busy_timeout(unsigned long data);
 /*
  * One list to contain all tape devices of all disciplines, so
  * we can assign the devices to minor numbers of the same major
  * The list is protected by the rwlock
  */
 static LIST_HEAD(tape_device_list);
 static DEFINE_RWLOCK(tape_device_lock);
 /*
  * Pointer to debug area.
  */
 debug_info_t *TAPE_DBF_AREA = NULL;
 EXPORT_SYMBOL(TAPE_DBF_AREA);
 /*
  * Printable strings for tape enumerations.
  */
 const char *tape_state_verbose[TS_SIZE] =
 {
 	[TS_UNUSED]   = "UNUSED",
 	[TS_IN_USE]   = "IN_USE",
 	[TS_BLKUSE]   = "BLKUSE",
 	[TS_INIT]     = "INIT  ",
 	[TS_NOT_OPER] = "NOT_OP"
 };
 const char *tape_op_verbose[TO_SIZE] =
 {
 	[TO_BLOCK] = "BLK",	[TO_BSB] = "BSB",
 	[TO_BSF] = "BSF",	[TO_DSE] = "DSE",
 	[TO_FSB] = "FSB",	[TO_FSF] = "FSF",
 	[TO_LBL] = "LBL",	[TO_NOP] = "NOP",
 	[TO_RBA] = "RBA",	[TO_RBI] = "RBI",
 	[TO_RFO] = "RFO",	[TO_REW] = "REW",
 	[TO_RUN] = "RUN",	[TO_WRI] = "WRI",
 	[TO_WTM] = "WTM",	[TO_MSEN] = "MSN",
 	[TO_LOAD] = "LOA",	[TO_READ_CONFIG] = "RCF",
 	[TO_READ_ATTMSG] = "RAT",
 	[TO_DIS] = "DIS",	[TO_ASSIGN] = "ASS",
 	[TO_UNASSIGN] = "UAS",  [TO_CRYPT_ON] = "CON",
 	[TO_CRYPT_OFF] = "COF",	[TO_KEKL_SET] = "KLS",
 	[TO_KEKL_QUERY] = "KLQ",[TO_RDC] = "RDC",
 };
 static int devid_to_int(struct ccw_dev_id *dev_id)
 {
 	return dev_id->devno + (dev_id->ssid << 16);
 }
 /*
  * Some channel attached tape specific attributes.
  *
  * FIXME: In the future the first_minor and blocksize attribute should be
  *        replaced by a link to the cdev tree.
  */
 static ssize_t
 tape_medium_state_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct tape_device *tdev;
 	tdev = dev_get_drvdata(dev);
 	return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->medium_state);
 }
 static
 DEVICE_ATTR(medium_state, 0444, tape_medium_state_show, NULL);
 static ssize_t
 tape_first_minor_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct tape_device *tdev;
 	tdev = dev_get_drvdata(dev);
 	return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->first_minor);
 }
 static
 DEVICE_ATTR(first_minor, 0444, tape_first_minor_show, NULL);
 static ssize_t
 tape_state_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct tape_device *tdev;
 	tdev = dev_get_drvdata(dev);
 	return scnprintf(buf, PAGE_SIZE, "%s\n", (tdev->first_minor < 0) ?
 		"OFFLINE" : tape_state_verbose[tdev->tape_state]);
 }
 static
 DEVICE_ATTR(state, 0444, tape_state_show, NULL);
 static ssize_t
 tape_operation_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct tape_device *tdev;
 	ssize_t rc;
 	tdev = dev_get_drvdata(dev);
 	if (tdev->first_minor < 0)
 		return scnprintf(buf, PAGE_SIZE, "N/A\n");
 	spin_lock_irq(get_ccwdev_lock(tdev->cdev));
 	if (list_empty(&tdev->req_queue))
 		rc = scnprintf(buf, PAGE_SIZE, "---\n");
 	else {
 		struct tape_request *req;
 		req = list_entry(tdev->req_queue.next, struct tape_request,
 			list);
 		rc = scnprintf(buf,PAGE_SIZE, "%s\n", tape_op_verbose[req->op]);
 	}
 	spin_unlock_irq(get_ccwdev_lock(tdev->cdev));
 	return rc;
 }
 static
 DEVICE_ATTR(operation, 0444, tape_operation_show, NULL);
 static ssize_t
 tape_blocksize_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct tape_device *tdev;
 	tdev = dev_get_drvdata(dev);
 	return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->char_data.block_size);
 }
 static
 DEVICE_ATTR(blocksize, 0444, tape_blocksize_show, NULL);
 static struct attribute *tape_attrs[] = {
 	&dev_attr_medium_state.attr,
 	&dev_attr_first_minor.attr,
 	&dev_attr_state.attr,
 	&dev_attr_operation.attr,
 	&dev_attr_blocksize.attr,
 	NULL
 };
 static struct attribute_group tape_attr_group = {
 	.attrs = tape_attrs,
 };
 /*
  * Tape state functions
  */
 void
 tape_state_set(struct tape_device *device, enum tape_state newstate)
 {
 	const char *str;
 	if (device->tape_state == TS_NOT_OPER) {
 		DBF_EVENT(3, "ts_set err: not oper\n");
 		return;
 	}
 	DBF_EVENT(4, "ts. dev:	%x\n", device->first_minor);
 	DBF_EVENT(4, "old ts:\t\n");
 	if (device->tape_state < TS_SIZE && device->tape_state >=0 )
 		str = tape_state_verbose[device->tape_state];
 	else
 		str = "UNKNOWN TS";
 	DBF_EVENT(4, "%s\n", str);
 	DBF_EVENT(4, "new ts:\t\n");
 	if (newstate < TS_SIZE && newstate >= 0)
 		str = tape_state_verbose[newstate];
 	else
 		str = "UNKNOWN TS";
 	DBF_EVENT(4, "%s\n", str);
 	device->tape_state = newstate;
 	wake_up(&device->state_change_wq);
 }
 void
 tape_med_state_set(struct tape_device *device, enum tape_medium_state newstate)
 {
 	if (device->medium_state == newstate)
 		return;
 	switch(newstate){
 	case MS_UNLOADED:
 		device->tape_generic_status |= GMT_DR_OPEN(~0);
 		if (device->medium_state == MS_LOADED)
 			pr_info("%s: The tape cartridge has been successfully "
 				"unloaded\n", dev_name(&device->cdev->dev));
 		break;
 	case MS_LOADED:
 		device->tape_generic_status &= ~GMT_DR_OPEN(~0);
 		if (device->medium_state == MS_UNLOADED)
 			pr_info("%s: A tape cartridge has been mounted\n",
 				dev_name(&device->cdev->dev));
 		break;
 	default:
 		// print nothing
 		break;
 	}
 	device->medium_state = newstate;
 	wake_up(&device->state_change_wq);
 }
 /*
  * Stop running ccw. Has to be called with the device lock held.
  */
 static int
 __tape_cancel_io(struct tape_device *device, struct tape_request *request)
 {
 	int retries;
 	int rc;
 	/* Check if interrupt has already been processed */
 	if (request->callback == NULL)
 		return 0;
 	rc = 0;
 	for (retries = 0; retries < 5; retries++) {
 		rc = ccw_device_clear(device->cdev, (long) request);
 		switch (rc) {
 			case 0:
 				request->status	= TAPE_REQUEST_DONE;
 				return 0;
 			case -EBUSY:
 				request->status	= TAPE_REQUEST_CANCEL;
 				schedule_delayed_work(&device->tape_dnr, 0);
 				return 0;
 			case -ENODEV:
 				DBF_EXCEPTION(2, "device gone, retry\n");
 				break;
 			case -EIO:
 				DBF_EXCEPTION(2, "I/O error, retry\n");
 				break;
 			default:
 				BUG();
 		}
 	}
 	return rc;
 }
 /*
  * Add device into the sorted list, giving it the first
  * available minor number.
  */
 static int
 tape_assign_minor(struct tape_device *device)
 {
 	struct tape_device *tmp;
 	int minor;
 	minor = 0;
 	write_lock(&tape_device_lock);
 	list_for_each_entry(tmp, &tape_device_list, node) {
 		if (minor < tmp->first_minor)
 			break;
 		minor += TAPE_MINORS_PER_DEV;
 	}
 	if (minor >= 256) {
 		write_unlock(&tape_device_lock);
 		return -ENODEV;
 	}
 	device->first_minor = minor;
 	list_add_tail(&device->node, &tmp->node);
 	write_unlock(&tape_device_lock);
 	return 0;
 }
 /* remove device from the list */
 static void
 tape_remove_minor(struct tape_device *device)
 {
 	write_lock(&tape_device_lock);
 	list_del_init(&device->node);
 	device->first_minor = -1;
 	write_unlock(&tape_device_lock);
 }
 /*
  * Set a device online.
  *
  * This function is called by the common I/O layer to move a device from the
  * detected but offline into the online state.
  * If we return an error (RC < 0) the device remains in the offline state. This
  * can happen if the device is assigned somewhere else, for example.
  */
 int
 tape_generic_online(struct tape_device *device,
 		   struct tape_discipline *discipline)
 {
 	int rc;
 	DBF_LH(6, "tape_enable_device(%p, %p)\n", device, discipline);
 	if (device->tape_state != TS_INIT) {
 		DBF_LH(3, "Tapestate not INIT (%d)\n", device->tape_state);
 		return -EINVAL;
 	}
 	init_timer(&device->lb_timeout);
 	device->lb_timeout.function = tape_long_busy_timeout;
 	/* Let the discipline have a go at the device. */
 	device->discipline = discipline;
 	if (!try_module_get(discipline->owner)) {
 		return -EINVAL;
 	}
 	rc = discipline->setup_device(device);
 	if (rc)
 		goto out;
 	rc = tape_assign_minor(device);
 	if (rc)
 		goto out_discipline;
 	rc = tapechar_setup_device(device);
 	if (rc)
 		goto out_minor;
 	rc = tapeblock_setup_device(device);
 	if (rc)
 		goto out_char;
 	tape_state_set(device, TS_UNUSED);
 	DBF_LH(3, "(%08x): Drive set online\n", device->cdev_id);
 	return 0;
 out_char:
 	tapechar_cleanup_device(device);
 out_minor:
 	tape_remove_minor(device);
 out_discipline:
 	device->discipline->cleanup_device(device);
 	device->discipline = NULL;
 out:
 	module_put(discipline->owner);
 	return rc;
 }
 static void
 tape_cleanup_device(struct tape_device *device)
 {
 	tapeblock_cleanup_device(device);
 	tapechar_cleanup_device(device);
 	device->discipline->cleanup_device(device);
 	module_put(device->discipline->owner);
 	tape_remove_minor(device);
 	tape_med_state_set(device, MS_UNKNOWN);
 }
 /*
  * Suspend device.
  *
  * Called by the common I/O layer if the drive should be suspended on user
  * request. We refuse to suspend if the device is loaded or in use for the
  * following reason:
  * While the Linux guest is suspended, it might be logged off which causes
  * devices to be detached. Tape devices are automatically rewound and unloaded
  * during DETACH processing (unless the tape device was attached with the
  * NOASSIGN or MULTIUSER option). After rewind/unload, there is no way to
  * resume the original state of the tape device, since we would need to
  * manually re-load the cartridge which was active at suspend time.
  */
 int tape_generic_pm_suspend(struct ccw_device *cdev)
 {
 	struct tape_device *device;
 	device = dev_get_drvdata(&cdev->dev);
 	if (!device) {
 		return -ENODEV;
 	}
 	DBF_LH(3, "(%08x): tape_generic_pm_suspend(%p)\n",
 		device->cdev_id, device);
 	if (device->medium_state != MS_UNLOADED) {
 		pr_err("A cartridge is loaded in tape device %s, "
 		       "refusing to suspend\n", dev_name(&cdev->dev));
 		return -EBUSY;
 	}
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	switch (device->tape_state) {
 		case TS_INIT:
 		case TS_NOT_OPER:
 		case TS_UNUSED:
 			spin_unlock_irq(get_ccwdev_lock(device->cdev));
 			break;
 		default:
 			pr_err("Tape device %s is busy, refusing to "
 			       "suspend\n", dev_name(&cdev->dev));
 			spin_unlock_irq(get_ccwdev_lock(device->cdev));
 			return -EBUSY;
 	}
 	DBF_LH(3, "(%08x): Drive suspended.\n", device->cdev_id);
 	return 0;
 }
 /*
  * Set device offline.
  *
  * Called by the common I/O layer if the drive should set offline on user
  * request. We may prevent this by returning an error.
  * Manual offline is only allowed while the drive is not in use.
  */
 int
 tape_generic_offline(struct ccw_device *cdev)
 {
 	struct tape_device *device;
 	device = dev_get_drvdata(&cdev->dev);
 	if (!device) {
 		return -ENODEV;
 	}
 	DBF_LH(3, "(%08x): tape_generic_offline(%p)\n",
 		device->cdev_id, device);
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	switch (device->tape_state) {
 		case TS_INIT:
 		case TS_NOT_OPER:
 			spin_unlock_irq(get_ccwdev_lock(device->cdev));
 			break;
 		case TS_UNUSED:
 			tape_state_set(device, TS_INIT);
 			spin_unlock_irq(get_ccwdev_lock(device->cdev));
 			tape_cleanup_device(device);
 			break;
 		default:
 			DBF_EVENT(3, "(%08x): Set offline failed "
 				"- drive in use.\n",
 				device->cdev_id);
 			spin_unlock_irq(get_ccwdev_lock(device->cdev));
 			return -EBUSY;
 	}
 	DBF_LH(3, "(%08x): Drive set offline.\n", device->cdev_id);
 	return 0;
 }
 /*
  * Allocate memory for a new device structure.
  */
 static struct tape_device *
 tape_alloc_device(void)
 {
 	struct tape_device *device;
 	device = kzalloc(sizeof(struct tape_device), GFP_KERNEL);
 	if (device == NULL) {
 		DBF_EXCEPTION(2, "ti:no mem\n");
 		return ERR_PTR(-ENOMEM);
 	}
 	device->modeset_byte = kmalloc(1, GFP_KERNEL | GFP_DMA);
 	if (device->modeset_byte == NULL) {
 		DBF_EXCEPTION(2, "ti:no mem\n");
 		kfree(device);
 		return ERR_PTR(-ENOMEM);
 	}
 	mutex_init(&device->mutex);
 	INIT_LIST_HEAD(&device->req_queue);
 	INIT_LIST_HEAD(&device->node);
 	init_waitqueue_head(&device->state_change_wq);
 	init_waitqueue_head(&device->wait_queue);
 	device->tape_state = TS_INIT;
 	device->medium_state = MS_UNKNOWN;
 	*device->modeset_byte = 0;
 	device->first_minor = -1;
 	atomic_set(&device->ref_count, 1);
 	INIT_DELAYED_WORK(&device->tape_dnr, tape_delayed_next_request);
 	return device;
 }
 /*
  * Get a reference to an existing device structure. This will automatically
  * increment the reference count.
  */
 struct tape_device *
 tape_get_device(struct tape_device *device)
 {
 	int count;
 	count = atomic_inc_return(&device->ref_count);
 	DBF_EVENT(4, "tape_get_device(%p) = %i\n", device, count);
 	return device;
 }
 /*
  * Decrease the reference counter of a devices structure. If the
  * reference counter reaches zero free the device structure.
  * The function returns a NULL pointer to be used by the caller
  * for clearing reference pointers.
  */
 void
 tape_put_device(struct tape_device *device)
 {
 	int count;
 	count = atomic_dec_return(&device->ref_count);
 	DBF_EVENT(4, "tape_put_device(%p) -> %i\n", device, count);
 	BUG_ON(count < 0);
 	if (count == 0) {
 		kfree(device->modeset_byte);
 		kfree(device);
 	}
 }
 /*
  * Find tape device by a device index.
  */
 struct tape_device *
 tape_find_device(int devindex)
 {
 	struct tape_device *device, *tmp;
 	device = ERR_PTR(-ENODEV);
 	read_lock(&tape_device_lock);
 	list_for_each_entry(tmp, &tape_device_list, node) {
 		if (tmp->first_minor / TAPE_MINORS_PER_DEV == devindex) {
 			device = tape_get_device(tmp);
 			break;
 		}
 	}
 	read_unlock(&tape_device_lock);
 	return device;
 }
 /*
  * Driverfs tape probe function.
  */
 int
 tape_generic_probe(struct ccw_device *cdev)
 {
 	struct tape_device *device;
 	int ret;
 	struct ccw_dev_id dev_id;
 	device = tape_alloc_device();
 	if (IS_ERR(device))
 		return -ENODEV;
 	ccw_device_set_options(cdev, CCWDEV_DO_PATHGROUP |
 				     CCWDEV_DO_MULTIPATH);
 	ret = sysfs_create_group(&cdev->dev.kobj, &tape_attr_group);
 	if (ret) {
 		tape_put_device(device);
 		return ret;
 	}
 	dev_set_drvdata(&cdev->dev, device);
 	cdev->handler = __tape_do_irq;
 	device->cdev = cdev;
 	ccw_device_get_id(cdev, &dev_id);
 	device->cdev_id = devid_to_int(&dev_id);
 	return ret;
 }
 static void
 __tape_discard_requests(struct tape_device *device)
 {
 	struct tape_request *	request;
 	struct list_head *	l, *n;
 	list_for_each_safe(l, n, &device->req_queue) {
 		request = list_entry(l, struct tape_request, list);
 		if (request->status == TAPE_REQUEST_IN_IO)
 			request->status = TAPE_REQUEST_DONE;
 		list_del(&request->list);
 		/* Decrease ref_count for removed request. */
 		request->device = NULL;
 		tape_put_device(device);
 		request->rc = -EIO;
 		if (request->callback != NULL)
 			request->callback(request, request->callback_data);
 	}
 }
 /*
  * Driverfs tape remove function.
  *
  * This function is called whenever the common I/O layer detects the device
  * gone. This can happen at any time and we cannot refuse.
  */
 void
 tape_generic_remove(struct ccw_device *cdev)
 {
 	struct tape_device *	device;
 	device = dev_get_drvdata(&cdev->dev);
 	if (!device) {
 		return;
 	}
 	DBF_LH(3, "(%08x): tape_generic_remove(%p)\n", device->cdev_id, cdev);
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	switch (device->tape_state) {
 		case TS_INIT:
 			tape_state_set(device, TS_NOT_OPER);
 		case TS_NOT_OPER:
 			/*
 			 * Nothing to do.
 			 */
 			spin_unlock_irq(get_ccwdev_lock(device->cdev));
 			break;
 		case TS_UNUSED:
 			/*
 			 * Need only to release the device.
 			 */
 			tape_state_set(device, TS_NOT_OPER);
 			spin_unlock_irq(get_ccwdev_lock(device->cdev));
 			tape_cleanup_device(device);
 			break;
 		default:
 			/*
 			 * There may be requests on the queue. We will not get
 			 * an interrupt for a request that was running. So we
 			 * just post them all as I/O errors.
 			 */
 			DBF_EVENT(3, "(%08x): Drive in use vanished!\n",
 				device->cdev_id);
 			pr_warning("%s: A tape unit was detached while in "
 				   "use\n", dev_name(&device->cdev->dev));
 			tape_state_set(device, TS_NOT_OPER);
 			__tape_discard_requests(device);
 			spin_unlock_irq(get_ccwdev_lock(device->cdev));
 			tape_cleanup_device(device);
 	}
 	device = dev_get_drvdata(&cdev->dev);
 	if (device) {
 		sysfs_remove_group(&cdev->dev.kobj, &tape_attr_group);
 		dev_set_drvdata(&cdev->dev, NULL);
 		tape_put_device(device);
 	}
 }
 /*
  * Allocate a new tape ccw request
  */
 struct tape_request *
 tape_alloc_request(int cplength, int datasize)
 {
 	struct tape_request *request;
 	BUG_ON(datasize > PAGE_SIZE || (cplength*sizeof(struct ccw1)) > PAGE_SIZE);
 	DBF_LH(6, "tape_alloc_request(%d, %d)\n", cplength, datasize);
 	request = kzalloc(sizeof(struct tape_request), GFP_KERNEL);
 	if (request == NULL) {
 		DBF_EXCEPTION(1, "cqra nomem\n");
 		return ERR_PTR(-ENOMEM);
 	}
 	/* allocate channel program */
 	if (cplength > 0) {
 		request->cpaddr = kcalloc(cplength, sizeof(struct ccw1),
 					  GFP_ATOMIC | GFP_DMA);
 		if (request->cpaddr == NULL) {
 			DBF_EXCEPTION(1, "cqra nomem\n");
 			kfree(request);
 			return ERR_PTR(-ENOMEM);
 		}
 	}
 	/* alloc small kernel buffer */
 	if (datasize > 0) {
 		request->cpdata = kzalloc(datasize, GFP_KERNEL | GFP_DMA);
 		if (request->cpdata == NULL) {
 			DBF_EXCEPTION(1, "cqra nomem\n");
 			kfree(request->cpaddr);
 			kfree(request);
 			return ERR_PTR(-ENOMEM);
 		}
 	}
 	DBF_LH(6, "New request %p(%p/%p)\n", request, request->cpaddr,
 		request->cpdata);
 	return request;
 }
 /*
  * Free tape ccw request
  */
 void
 tape_free_request (struct tape_request * request)
 {
 	DBF_LH(6, "Free request %p\n", request);
 	if (request->device)
 		tape_put_device(request->device);
 	kfree(request->cpdata);
 	kfree(request->cpaddr);
 	kfree(request);
 }
 static int
 __tape_start_io(struct tape_device *device, struct tape_request *request)
 {
 	int rc;
 #ifdef CONFIG_S390_TAPE_BLOCK
 	if (request->op == TO_BLOCK)
 		device->discipline->check_locate(device, request);
 #endif
 	rc = ccw_device_start(
 		device->cdev,
 		request->cpaddr,
 		(unsigned long) request,
 		0x00,
 		request->options
 	);
 	if (rc == 0) {
 		request->status = TAPE_REQUEST_IN_IO;
 	} else if (rc == -EBUSY) {
 		/* The common I/O subsystem is currently busy. Retry later. */
 		request->status = TAPE_REQUEST_QUEUED;
 		schedule_delayed_work(&device->tape_dnr, 0);
 		rc = 0;
 	} else {
 		/* Start failed. Remove request and indicate failure. */
 		DBF_EVENT(1, "tape: start request failed with RC = %i\n", rc);
 	}
 	return rc;
 }
 static void
 __tape_start_next_request(struct tape_device *device)
 {
 	struct list_head *l, *n;
 	struct tape_request *request;
 	int rc;
 	DBF_LH(6, "__tape_start_next_request(%p)\n", device);
 	/*
 	 * Try to start each request on request queue until one is
 	 * started successful.
 	 */
 	list_for_each_safe(l, n, &device->req_queue) {
 		request = list_entry(l, struct tape_request, list);
 		/*
 		 * Avoid race condition if bottom-half was triggered more than
 		 * once.
 		 */
 		if (request->status == TAPE_REQUEST_IN_IO)
 			return;
 		/*
 		 * Request has already been stopped. We have to wait until
 		 * the request is removed from the queue in the interrupt
 		 * handling.
 		 */
 		if (request->status == TAPE_REQUEST_DONE)
 			return;
 		/*
 		 * We wanted to cancel the request but the common I/O layer
 		 * was busy at that time. This can only happen if this
 		 * function is called by delayed_next_request.
 		 * Otherwise we start the next request on the queue.
 		 */
 		if (request->status == TAPE_REQUEST_CANCEL) {
 			rc = __tape_cancel_io(device, request);
 		} else {
 			rc = __tape_start_io(device, request);
 		}
 		if (rc == 0)
 			return;
 		/* Set ending status. */
 		request->rc = rc;
 		request->status = TAPE_REQUEST_DONE;
 		/* Remove from request queue. */
 		list_del(&request->list);
 		/* Do callback. */
 		if (request->callback != NULL)
 			request->callback(request, request->callback_data);
 	}
 }
 static void
 tape_delayed_next_request(struct work_struct *work)
 {
 	struct tape_device *device =
 		container_of(work, struct tape_device, tape_dnr.work);
 	DBF_LH(6, "tape_delayed_next_request(%p)\n", device);
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	__tape_start_next_request(device);
 	spin_unlock_irq(get_ccwdev_lock(device->cdev));
 }
 static void tape_long_busy_timeout(unsigned long data)
 {
 	struct tape_request *request;
 	struct tape_device *device;
 	device = (struct tape_device *) data;
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	request = list_entry(device->req_queue.next, struct tape_request, list);
 	BUG_ON(request->status != TAPE_REQUEST_LONG_BUSY);
 	DBF_LH(6, "%08x: Long busy timeout.\n", device->cdev_id);
 	__tape_start_next_request(device);
 	device->lb_timeout.data = 0UL;
 	tape_put_device(device);
 	spin_unlock_irq(get_ccwdev_lock(device->cdev));
 }
 static void
 __tape_end_request(
 	struct tape_device *	device,
 	struct tape_request *	request,
 	int			rc)
 {
 	DBF_LH(6, "__tape_end_request(%p, %p, %i)\n", device, request, rc);
 	if (request) {
 		request->rc = rc;
 		request->status = TAPE_REQUEST_DONE;
 		/* Remove from request queue. */
 		list_del(&request->list);
 		/* Do callback. */
 		if (request->callback != NULL)
 			request->callback(request, request->callback_data);
 	}
 	/* Start next request. */
 	if (!list_empty(&device->req_queue))
 		__tape_start_next_request(device);
 }
 /*
  * Write sense data to dbf
  */
 void
 tape_dump_sense_dbf(struct tape_device *device, struct tape_request *request,
 		    struct irb *irb)
 {
 	unsigned int *sptr;
 	const char* op;
 	if (request != NULL)
 		op = tape_op_verbose[request->op];
 	else
 		op = "---";
 	DBF_EVENT(3, "DSTAT : %02x   CSTAT: %02x\n",
 		  irb->scsw.cmd.dstat, irb->scsw.cmd.cstat);
 	DBF_EVENT(3, "DEVICE: %08x OP\t: %s\n", device->cdev_id, op);
 	sptr = (unsigned int *) irb->ecw;
 	DBF_EVENT(3, "%08x %08x\n", sptr[0], sptr[1]);
 	DBF_EVENT(3, "%08x %08x\n", sptr[2], sptr[3]);
 	DBF_EVENT(3, "%08x %08x\n", sptr[4], sptr[5]);
 	DBF_EVENT(3, "%08x %08x\n", sptr[6], sptr[7]);
 }
 /*
  * I/O helper function. Adds the request to the request queue
  * and starts it if the tape is idle. Has to be called with
  * the device lock held.
  */
 static int
 __tape_start_request(struct tape_device *device, struct tape_request *request)
 {
 	int rc;
 	switch (request->op) {
 		case TO_MSEN:
 		case TO_ASSIGN:
 		case TO_UNASSIGN:
 		case TO_READ_ATTMSG:
 		case TO_RDC:
 			if (device->tape_state == TS_INIT)
 				break;
 			if (device->tape_state == TS_UNUSED)
 				break;
 		default:
 			if (device->tape_state == TS_BLKUSE)
 				break;
 			if (device->tape_state != TS_IN_USE)
 				return -ENODEV;
 	}
 	/* Increase use count of device for the added request. */
 	request->device = tape_get_device(device);
 	if (list_empty(&device->req_queue)) {
 		/* No other requests are on the queue. Start this one. */
 		rc = __tape_start_io(device, request);
 		if (rc)
 			return rc;
 		DBF_LH(5, "Request %p added for execution.\n", request);
 		list_add(&request->list, &device->req_queue);
 	} else {
 		DBF_LH(5, "Request %p add to queue.\n", request);
 		request->status = TAPE_REQUEST_QUEUED;
 		list_add_tail(&request->list, &device->req_queue);
 	}
 	return 0;
 }
 /*
  * Add the request to the request queue, try to start it if the
  * tape is idle. Return without waiting for end of i/o.
  */
 int
 tape_do_io_async(struct tape_device *device, struct tape_request *request)
 {
 	int rc;
 	DBF_LH(6, "tape_do_io_async(%p, %p)\n", device, request);
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	/* Add request to request queue and try to start it. */
 	rc = __tape_start_request(device, request);
 	spin_unlock_irq(get_ccwdev_lock(device->cdev));
 	return rc;
 }
 /*
  * tape_do_io/__tape_wake_up
  * Add the request to the request queue, try to start it if the
  * tape is idle and wait uninterruptible for its completion.
  */
 static void
 __tape_wake_up(struct tape_request *request, void *data)
 {
 	request->callback = NULL;
 	wake_up((wait_queue_head_t *) data);
 }
 int
 tape_do_io(struct tape_device *device, struct tape_request *request)
 {
 	int rc;
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	/* Setup callback */
 	request->callback = __tape_wake_up;
 	request->callback_data = &device->wait_queue;
 	/* Add request to request queue and try to start it. */
 	rc = __tape_start_request(device, request);
 	spin_unlock_irq(get_ccwdev_lock(device->cdev));
 	if (rc)
 		return rc;
 	/* Request added to the queue. Wait for its completion. */
 	wait_event(device->wait_queue, (request->callback == NULL));
 	/* Get rc from request */
 	return request->rc;
 }
 /*
  * tape_do_io_interruptible/__tape_wake_up_interruptible
  * Add the request to the request queue, try to start it if the
  * tape is idle and wait uninterruptible for its completion.
  */
 static void
 __tape_wake_up_interruptible(struct tape_request *request, void *data)
 {
 	request->callback = NULL;
 	wake_up_interruptible((wait_queue_head_t *) data);
 }
 int
 tape_do_io_interruptible(struct tape_device *device,
 			 struct tape_request *request)
 {
 	int rc;
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	/* Setup callback */
 	request->callback = __tape_wake_up_interruptible;
 	request->callback_data = &device->wait_queue;
 	rc = __tape_start_request(device, request);
 	spin_unlock_irq(get_ccwdev_lock(device->cdev));
 	if (rc)
 		return rc;
 	/* Request added to the queue. Wait for its completion. */
 	rc = wait_event_interruptible(device->wait_queue,
 				      (request->callback == NULL));
 	if (rc != -ERESTARTSYS)
 		/* Request finished normally. */
 		return request->rc;
 	/* Interrupted by a signal. We have to stop the current request. */
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	rc = __tape_cancel_io(device, request);
 	spin_unlock_irq(get_ccwdev_lock(device->cdev));
 	if (rc == 0) {
 		/* Wait for the interrupt that acknowledges the halt. */
 		do {
 			rc = wait_event_interruptible(
 				device->wait_queue,
 				(request->callback == NULL)
 			);
 		} while (rc == -ERESTARTSYS);
 		DBF_EVENT(3, "IO stopped on %08x\n", device->cdev_id);
 		rc = -ERESTARTSYS;
 	}
 	return rc;
 }
 /*
  * Stop running ccw.
  */
 int
 tape_cancel_io(struct tape_device *device, struct tape_request *request)
 {
 	int rc;
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	rc = __tape_cancel_io(device, request);
 	spin_unlock_irq(get_ccwdev_lock(device->cdev));
 	return rc;
 }
 /*
  * Tape interrupt routine, called from the ccw_device layer
  */
 static void
 __tape_do_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
 {
 	struct tape_device *device;
 	struct tape_request *request;
 	int rc;
 	device = dev_get_drvdata(&cdev->dev);
 	if (device == NULL) {
 		return;
 	}
 	request = (struct tape_request *) intparm;
 	DBF_LH(6, "__tape_do_irq(device=%p, request=%p)\n", device, request);
 	/* On special conditions irb is an error pointer */
 	if (IS_ERR(irb)) {
 		/* FIXME: What to do with the request? */
 		switch (PTR_ERR(irb)) {
 			case -ETIMEDOUT:
 				DBF_LH(1, "(%s): Request timed out\n",
 					dev_name(&cdev->dev));
 			case -EIO:
 				__tape_end_request(device, request, -EIO);
 				break;
 			default:
 				DBF_LH(1, "(%s): Unexpected i/o error %li\n",
 					dev_name(&cdev->dev),
 					PTR_ERR(irb));
 		}
 		return;
 	}
 	/*
 	 * If the condition code is not zero and the start function bit is
 	 * still set, this is an deferred error and the last start I/O did
 	 * not succeed. At this point the condition that caused the deferred
 	 * error might still apply. So we just schedule the request to be
 	 * started later.
 	 */
 	if (irb->scsw.cmd.cc != 0 &&
 	    (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) &&
 	    (request->status == TAPE_REQUEST_IN_IO)) {
 		DBF_EVENT(3,"(%08x): deferred cc=%i, fctl=%i. restarting\n",
 			device->cdev_id, irb->scsw.cmd.cc, irb->scsw.cmd.fctl);
 		request->status = TAPE_REQUEST_QUEUED;
 		schedule_delayed_work(&device->tape_dnr, HZ);
 		return;
 	}
 	/* May be an unsolicited irq */
 	if(request != NULL)
 		request->rescnt = irb->scsw.cmd.count;
 	else if ((irb->scsw.cmd.dstat == 0x85 || irb->scsw.cmd.dstat == 0x80) &&
 		 !list_empty(&device->req_queue)) {
 		/* Not Ready to Ready after long busy ? */
 		struct tape_request *req;
 		req = list_entry(device->req_queue.next,
 				 struct tape_request, list);
 		if (req->status == TAPE_REQUEST_LONG_BUSY) {
 			DBF_EVENT(3, "(%08x): del timer\n", device->cdev_id);
 			if (del_timer(&device->lb_timeout)) {
 				device->lb_timeout.data = 0UL;
 				tape_put_device(device);
 				__tape_start_next_request(device);
 			}
 			return;
 		}
 	}
 	if (irb->scsw.cmd.dstat != 0x0c) {
 		/* Set the 'ONLINE' flag depending on sense byte 1 */
 		if(*(((__u8 *) irb->ecw) + 1) & SENSE_DRIVE_ONLINE)
 			device->tape_generic_status |= GMT_ONLINE(~0);
 		else
 			device->tape_generic_status &= ~GMT_ONLINE(~0);
 		/*
 		 * Any request that does not come back with channel end
 		 * and device end is unusual. Log the sense data.
 		 */
 		DBF_EVENT(3,"-- Tape Interrupthandler --\n");
 		tape_dump_sense_dbf(device, request, irb);
 	} else {
 		/* Upon normal completion the device _is_ online */
 		device->tape_generic_status |= GMT_ONLINE(~0);
 	}
 	if (device->tape_state == TS_NOT_OPER) {
 		DBF_EVENT(6, "tape:device is not operational\n");
 		return;
 	}
 	/*
 	 * Request that were canceled still come back with an interrupt.
 	 * To detect these request the state will be set to TAPE_REQUEST_DONE.
 	 */
 	if(request != NULL && request->status == TAPE_REQUEST_DONE) {
 		__tape_end_request(device, request, -EIO);
 		return;
 	}
 	rc = device->discipline->irq(device, request, irb);
 	/*
 	 * rc < 0 : request finished unsuccessfully.
 	 * rc == TAPE_IO_SUCCESS: request finished successfully.
 	 * rc == TAPE_IO_PENDING: request is still running. Ignore rc.
 	 * rc == TAPE_IO_RETRY: request finished but needs another go.
 	 * rc == TAPE_IO_STOP: request needs to get terminated.
 	 */
 	switch (rc) {
 		case TAPE_IO_SUCCESS:
 			/* Upon normal completion the device _is_ online */
 			device->tape_generic_status |= GMT_ONLINE(~0);
 			__tape_end_request(device, request, rc);
 			break;
 		case TAPE_IO_PENDING:
 			break;
 		case TAPE_IO_LONG_BUSY:
 			device->lb_timeout.data =
 				(unsigned long) tape_get_device(device);
 			device->lb_timeout.expires = jiffies +
 				LONG_BUSY_TIMEOUT * HZ;
 			DBF_EVENT(3, "(%08x): add timer\n", device->cdev_id);
 			add_timer(&device->lb_timeout);
 			request->status = TAPE_REQUEST_LONG_BUSY;
 			break;
 		case TAPE_IO_RETRY:
 			rc = __tape_start_io(device, request);
 			if (rc)
 				__tape_end_request(device, request, rc);
 			break;
 		case TAPE_IO_STOP:
 			rc = __tape_cancel_io(device, request);
 			if (rc)
 				__tape_end_request(device, request, rc);
 			break;
 		default:
 			if (rc > 0) {
 				DBF_EVENT(6, "xunknownrc\n");
 				__tape_end_request(device, request, -EIO);
 			} else {
 				__tape_end_request(device, request, rc);
 			}
 			break;
 	}
 }
 /*
  * Tape device open function used by tape_char & tape_block frontends.
  */
 int
 tape_open(struct tape_device *device)
 {
 	int rc;
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	if (device->tape_state == TS_NOT_OPER) {
 		DBF_EVENT(6, "TAPE:nodev\n");
 		rc = -ENODEV;
 	} else if (device->tape_state == TS_IN_USE) {
 		DBF_EVENT(6, "TAPE:dbusy\n");
 		rc = -EBUSY;
 	} else if (device->tape_state == TS_BLKUSE) {
 		DBF_EVENT(6, "TAPE:dbusy\n");
 		rc = -EBUSY;
 	} else if (device->discipline != NULL &&
 		   !try_module_get(device->discipline->owner)) {
 		DBF_EVENT(6, "TAPE:nodisc\n");
 		rc = -ENODEV;
 	} else {
 		tape_state_set(device, TS_IN_USE);
 		rc = 0;
 	}
 	spin_unlock_irq(get_ccwdev_lock(device->cdev));
 	return rc;
 }
 /*
  * Tape device release function used by tape_char & tape_block frontends.
  */
 int
 tape_release(struct tape_device *device)
 {
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	if (device->tape_state == TS_IN_USE)
 		tape_state_set(device, TS_UNUSED);
 	module_put(device->discipline->owner);
 	spin_unlock_irq(get_ccwdev_lock(device->cdev));
 	return 0;
 }
 /*
  * Execute a magnetic tape command a number of times.
  */
 int
 tape_mtop(struct tape_device *device, int mt_op, int mt_count)
 {
 	tape_mtop_fn fn;
 	int rc;
 	DBF_EVENT(6, "TAPE:mtio\n");
 	DBF_EVENT(6, "TAPE:ioop: %x\n", mt_op);
 	DBF_EVENT(6, "TAPE:arg:	 %x\n", mt_count);
 	if (mt_op < 0 || mt_op >= TAPE_NR_MTOPS)
 		return -EINVAL;
 	fn = device->discipline->mtop_array[mt_op];
 	if (fn == NULL)
 		return -EINVAL;
 	/* We assume that the backends can handle count up to 500. */
 	if (mt_op == MTBSR  || mt_op == MTFSR  || mt_op == MTFSF  ||
 	    mt_op == MTBSF  || mt_op == MTFSFM || mt_op == MTBSFM) {
 		rc = 0;
 		for (; mt_count > 500; mt_count -= 500)
 			if ((rc = fn(device, 500)) != 0)
 				break;
 		if (rc == 0)
 			rc = fn(device, mt_count);
 	} else
 		rc = fn(device, mt_count);
 	return rc;
 }
 /*
  * Tape init function.
  */
 static int
 tape_init (void)
 {
 	TAPE_DBF_AREA = debug_register ( "tape", 2, 2, 4*sizeof(long));
 	debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
 #ifdef DBF_LIKE_HELL
 	debug_set_level(TAPE_DBF_AREA, 6);
 #endif
 	DBF_EVENT(3, "tape init\n");
 	tape_proc_init();
 	tapechar_init ();
 	tapeblock_init ();
 	return 0;
 }
 /*
  * Tape exit function.
  */
 static void
 tape_exit(void)
 {
 	DBF_EVENT(6, "tape exit\n");
 	/* Get rid of the frontends */
 	tapechar_exit();
 	tapeblock_exit();
 	tape_proc_cleanup();
 	debug_unregister (TAPE_DBF_AREA);
 }
 MODULE_AUTHOR("(C) 2001 IBM Deutschland Entwicklung GmbH by Carsten Otte and "
 	      "Michael Holzheu (cotte@de.ibm.com,holzheu@de.ibm.com)");
 MODULE_DESCRIPTION("Linux on zSeries channel attached tape device driver");
 MODULE_LICENSE("GPL");
 module_init(tape_init);
 module_exit(tape_exit);
 EXPORT_SYMBOL(tape_generic_remove);
 EXPORT_SYMBOL(tape_generic_probe);
 EXPORT_SYMBOL(tape_generic_online);
 EXPORT_SYMBOL(tape_generic_offline);
 EXPORT_SYMBOL(tape_generic_pm_suspend);
 EXPORT_SYMBOL(tape_put_device);
 EXPORT_SYMBOL(tape_get_device);
 EXPORT_SYMBOL(tape_state_verbose);
 EXPORT_SYMBOL(tape_op_verbose);
 EXPORT_SYMBOL(tape_state_set);
 EXPORT_SYMBOL(tape_med_state_set);
 EXPORT_SYMBOL(tape_alloc_request);
 EXPORT_SYMBOL(tape_free_request);
 EXPORT_SYMBOL(tape_dump_sense_dbf);
 EXPORT_SYMBOL(tape_do_io);
 EXPORT_SYMBOL(tape_do_io_async);
 EXPORT_SYMBOL(tape_do_io_interruptible);
 EXPORT_SYMBOL(tape_cancel_io);
 EXPORT_SYMBOL(tape_mtop);

drivers/s390/char/tape_proc.c

Diff comments View file @ bb50991

 /*
  *  drivers/s390/char/tape.c
  *    tape device driver for S/390 and zSeries tapes.
  *
  *  S390 and zSeries version
  *    Copyright (C) 2001 IBM Corporation
  *    Author(s): Carsten Otte <cotte@de.ibm.com>
  *		 Michael Holzheu <holzheu@de.ibm.com>
  *		 Tuan Ngo-Anh <ngoanh@de.ibm.com>
  *
  * PROCFS Functions
  */
+#define KMSG_COMPONENT "tape"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include <linux/module.h>
 #include <linux/vmalloc.h>
 #include <linux/seq_file.h>
 #include <linux/proc_fs.h>
 #define TAPE_DBF_AREA	tape_core_dbf
 #include "tape.h"
 static const char *tape_med_st_verbose[MS_SIZE] =
 {
 	[MS_UNKNOWN] = "UNKNOWN ",
 	[MS_LOADED] = "LOADED  ",
 	[MS_UNLOADED] = "UNLOADED"
 };
 /* our proc tapedevices entry */
 static struct proc_dir_entry *tape_proc_devices;
 /*
  * Show function for /proc/tapedevices
  */
 static int tape_proc_show(struct seq_file *m, void *v)
 {
 	struct tape_device *device;
 	struct tape_request *request;
 	const char *str;
 	unsigned long n;
 	n = (unsigned long) v - 1;
 	if (!n) {
 		seq_printf(m, "TapeNo\tBusID      CuType/Model\t"
 			"DevType/Model\tBlkSize\tState\tOp\tMedState\n");
 	}
 	device = tape_find_device(n);
 	if (IS_ERR(device))
 		return 0;
 	spin_lock_irq(get_ccwdev_lock(device->cdev));
 	seq_printf(m, "%d\t", (int) n);
 	seq_printf(m, "%-10.10s ", dev_name(&device->cdev->dev));
 	seq_printf(m, "%04X/", device->cdev->id.cu_type);
 	seq_printf(m, "%02X\t", device->cdev->id.cu_model);
 	seq_printf(m, "%04X/", device->cdev->id.dev_type);
 	seq_printf(m, "%02X\t\t", device->cdev->id.dev_model);
 	if (device->char_data.block_size == 0)
 		seq_printf(m, "auto\t");
 	else
 		seq_printf(m, "%i\t", device->char_data.block_size);
 	if (device->tape_state >= 0 &&
 	    device->tape_state < TS_SIZE)
 		str = tape_state_verbose[device->tape_state];
 	else
 		str = "UNKNOWN";
 	seq_printf(m, "%s\t", str);
 	if (!list_empty(&device->req_queue)) {
 		request = list_entry(device->req_queue.next,
 				     struct tape_request, list);
 		str = tape_op_verbose[request->op];
 	} else
 		str = "---";
 	seq_printf(m, "%s\t", str);
 	seq_printf(m, "%s\n", tape_med_st_verbose[device->medium_state]);
 	spin_unlock_irq(get_ccwdev_lock(device->cdev));
 	tape_put_device(device);
         return 0;
 }
 static void *tape_proc_start(struct seq_file *m, loff_t *pos)
 {
 	if (*pos >= 256 / TAPE_MINORS_PER_DEV)
 		return NULL;
 	return (void *)((unsigned long) *pos + 1);
 }
 static void *tape_proc_next(struct seq_file *m, void *v, loff_t *pos)
 {
 	++*pos;
 	return tape_proc_start(m, pos);
 }
 static void tape_proc_stop(struct seq_file *m, void *v)
 {
 }
 static const struct seq_operations tape_proc_seq = {
 	.start		= tape_proc_start,
 	.next		= tape_proc_next,
 	.stop		= tape_proc_stop,
 	.show		= tape_proc_show,
 };
 static int tape_proc_open(struct inode *inode, struct file *file)
 {
 	return seq_open(file, &tape_proc_seq);
 }
 static const struct file_operations tape_proc_ops =
 {
 	.owner		= THIS_MODULE,
 	.open		= tape_proc_open,
 	.read		= seq_read,
 	.llseek		= seq_lseek,
 	.release	= seq_release,
 };
 /*
  * Initialize procfs stuff on startup
  */
 void
 tape_proc_init(void)
 {
 	tape_proc_devices =
 		proc_create("tapedevices", S_IFREG | S_IRUGO | S_IWUSR, NULL,
 			    &tape_proc_ops);
 	if (tape_proc_devices == NULL) {
 		return;
 	}
 }
 /*
  * Cleanup all stuff registered to the procfs
  */
 void
 tape_proc_cleanup(void)
 {
 	if (tape_proc_devices != NULL)
 		remove_proc_entry ("tapedevices", NULL);
 }

drivers/s390/char/tape_std.c

Diff comments View file @ bb50991

 /*
  *  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, "(%s): Assign timeout: Cancel failed with rc = %i\n",
 			dev_name(&device->cdev->dev), 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);