1233 lines
34 KiB
C
1233 lines
34 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* 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>
|
|
#include <linux/slab.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 void __tape_34xx_medium_sense(struct tape_request *request)
|
|
{
|
|
struct tape_device *device = request->device;
|
|
unsigned char *sense;
|
|
|
|
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);
|
|
}
|
|
|
|
static int tape_34xx_medium_sense(struct tape_device *device)
|
|
{
|
|
struct tape_request *request;
|
|
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);
|
|
__tape_34xx_medium_sense(request);
|
|
return rc;
|
|
}
|
|
|
|
static void tape_34xx_medium_sense_async(struct tape_device *device)
|
|
{
|
|
struct tape_request *request;
|
|
|
|
request = tape_alloc_request(1, 32);
|
|
if (IS_ERR(request)) {
|
|
DBF_EXCEPTION(6, "MSEN fail\n");
|
|
return;
|
|
}
|
|
|
|
request->op = TO_MSEN;
|
|
tape_ccw_end(request->cpaddr, SENSE, 32, request->cpdata);
|
|
request->callback = (void *) __tape_34xx_medium_sense;
|
|
request->callback_data = NULL;
|
|
tape_do_io_async(device, request);
|
|
}
|
|
|
|
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.
|
|
* Note: the work handler is called by the system work queue. The tape
|
|
* commands started by the handler need to be asynchrounous, otherwise
|
|
* a deadlock can occur e.g. in case of a deferred cc=1 (see __tape_do_irq).
|
|
*/
|
|
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_async(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;
|
|
|
|
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 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:
|
|
/*
|
|
* 3480: Attention intercept.
|
|
* 3490: 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);
|
|
}
|
|
|
|
/*
|
|
* 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,
|
|
.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 = {
|
|
.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,
|
|
.int_class = IRQIO_TAP,
|
|
};
|
|
|
|
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);
|