2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2008-02-03 02:56:48 +08:00
|
|
|
* IDE ATAPI streaming tape driver.
|
|
|
|
*
|
2008-02-02 06:09:33 +08:00
|
|
|
* Copyright (C) 1995-1999 Gadi Oxman <gadio@netvision.net.il>
|
|
|
|
* Copyright (C) 2003-2005 Bartlomiej Zolnierkiewicz
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* This driver was constructed as a student project in the software laboratory
|
|
|
|
* of the faculty of electrical engineering in the Technion - Israel's
|
|
|
|
* Institute Of Technology, with the guide of Avner Lottem and Dr. Ilana David.
|
|
|
|
*
|
|
|
|
* It is hereby placed under the terms of the GNU general public license.
|
|
|
|
* (See linux/COPYING).
|
|
|
|
*
|
2008-02-03 02:56:48 +08:00
|
|
|
* For a historical changelog see
|
|
|
|
* Documentation/ide/ChangeLog.ide-tape.1995-2002
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
2008-10-11 04:39:34 +08:00
|
|
|
#define DRV_NAME "ide-tape"
|
|
|
|
|
2008-02-06 09:57:55 +08:00
|
|
|
#define IDETAPE_VERSION "1.20"
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-09-07 22:49:43 +08:00
|
|
|
#include <linux/compat.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/interrupt.h>
|
2006-03-28 17:56:46 +08:00
|
|
|
#include <linux/jiffies.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/genhd.h>
|
2009-09-02 08:52:57 +08:00
|
|
|
#include <linux/seq_file.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/ide.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/bitops.h>
|
2006-03-23 19:00:45 +08:00
|
|
|
#include <linux/mutex.h>
|
2008-02-03 02:56:50 +08:00
|
|
|
#include <scsi/scsi.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#include <asm/byteorder.h>
|
2008-02-06 09:57:54 +08:00
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <linux/io.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/unaligned.h>
|
|
|
|
#include <linux/mtio.h>
|
|
|
|
|
2008-02-06 09:57:51 +08:00
|
|
|
/* define to see debug info */
|
2009-07-18 07:55:16 +08:00
|
|
|
#undef IDETAPE_DEBUG_LOG
|
2008-02-06 09:57:51 +08:00
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
#ifdef IDETAPE_DEBUG_LOG
|
|
|
|
#define ide_debug_log(lvl, fmt, args...) __ide_debug_log(lvl, fmt, ## args)
|
2008-02-06 09:57:51 +08:00
|
|
|
#else
|
2009-07-18 07:55:16 +08:00
|
|
|
#define ide_debug_log(lvl, fmt, args...) do {} while (0)
|
2008-02-06 09:57:51 +08:00
|
|
|
#endif
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**************************** Tunable parameters *****************************/
|
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* After each failed packet command we issue a request sense command and retry
|
|
|
|
* the packet command IDETAPE_MAX_PC_RETRIES times.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Setting IDETAPE_MAX_PC_RETRIES to 0 will disable retries.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
#define IDETAPE_MAX_PC_RETRIES 3
|
|
|
|
|
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* The following parameter is used to select the point in the internal tape fifo
|
|
|
|
* in which we will start to refill the buffer. Decreasing the following
|
|
|
|
* parameter will improve the system's latency and interactive response, while
|
|
|
|
* using a high value might improve system throughput.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2008-02-06 09:57:53 +08:00
|
|
|
#define IDETAPE_FIFO_THRESHOLD 2
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* DSC polling parameters.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Polling for DSC (a single bit in the status register) is a very important
|
|
|
|
* function in ide-tape. There are two cases in which we poll for DSC:
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* 1. Before a read/write packet command, to ensure that we can transfer data
|
|
|
|
* from/to the tape's data buffers, without causing an actual media access.
|
|
|
|
* In case the tape is not ready yet, we take out our request from the device
|
|
|
|
* request queue, so that ide.c could service requests from the other device
|
|
|
|
* on the same interface in the meantime.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* 2. After the successful initialization of a "media access packet command",
|
|
|
|
* which is a command that can take a long time to complete (the interval can
|
|
|
|
* range from several seconds to even an hour). Again, we postpone our request
|
|
|
|
* in the middle to free the bus for the other device. The polling frequency
|
|
|
|
* here should be lower than the read/write frequency since those media access
|
|
|
|
* commands are slow. We start from a "fast" frequency - IDETAPE_DSC_MA_FAST
|
|
|
|
* (1 second), and if we don't receive DSC after IDETAPE_DSC_MA_THRESHOLD
|
|
|
|
* (5 min), we switch it to a lower frequency - IDETAPE_DSC_MA_SLOW (1 min).
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* We also set a timeout for the timer, in case something goes wrong. The
|
|
|
|
* timeout should be longer then the maximum execution time of a tape operation.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2008-02-06 09:57:53 +08:00
|
|
|
|
|
|
|
/* DSC timings. */
|
2005-04-17 06:20:36 +08:00
|
|
|
#define IDETAPE_DSC_RW_MIN 5*HZ/100 /* 50 msec */
|
|
|
|
#define IDETAPE_DSC_RW_MAX 40*HZ/100 /* 400 msec */
|
|
|
|
#define IDETAPE_DSC_RW_TIMEOUT 2*60*HZ /* 2 minutes */
|
|
|
|
#define IDETAPE_DSC_MA_FAST 2*HZ /* 2 seconds */
|
|
|
|
#define IDETAPE_DSC_MA_THRESHOLD 5*60*HZ /* 5 minutes */
|
|
|
|
#define IDETAPE_DSC_MA_SLOW 30*HZ /* 30 seconds */
|
|
|
|
#define IDETAPE_DSC_MA_TIMEOUT 2*60*60*HZ /* 2 hours */
|
|
|
|
|
|
|
|
/*************************** End of tunable parameters ***********************/
|
|
|
|
|
2008-02-06 09:57:52 +08:00
|
|
|
/* tape directions */
|
|
|
|
enum {
|
|
|
|
IDETAPE_DIR_NONE = (1 << 0),
|
|
|
|
IDETAPE_DIR_READ = (1 << 1),
|
|
|
|
IDETAPE_DIR_WRITE = (1 << 2),
|
|
|
|
};
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-04-18 06:46:26 +08:00
|
|
|
/* Tape door status */
|
|
|
|
#define DOOR_UNLOCKED 0
|
|
|
|
#define DOOR_LOCKED 1
|
|
|
|
#define DOOR_EXPLICITLY_LOCKED 2
|
|
|
|
|
|
|
|
/* Some defines for the SPACE command */
|
|
|
|
#define IDETAPE_SPACE_OVER_FILEMARK 1
|
|
|
|
#define IDETAPE_SPACE_TO_EOD 3
|
|
|
|
|
|
|
|
/* Some defines for the LOAD UNLOAD command */
|
|
|
|
#define IDETAPE_LU_LOAD_MASK 1
|
|
|
|
#define IDETAPE_LU_RETENSION_MASK 2
|
|
|
|
#define IDETAPE_LU_EOT_MASK 4
|
|
|
|
|
|
|
|
/* Structures related to the SELECT SENSE / MODE SENSE packet commands. */
|
|
|
|
#define IDETAPE_BLOCK_DESCRIPTOR 0
|
|
|
|
#define IDETAPE_CAPABILITIES_PAGE 0x2a
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Most of our global data which we need to save even as we leave the driver due
|
|
|
|
* to an interrupt or a timer event is stored in the struct defined below.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
typedef struct ide_tape_obj {
|
2009-01-07 00:20:53 +08:00
|
|
|
ide_drive_t *drive;
|
|
|
|
struct ide_driver *driver;
|
|
|
|
struct gendisk *disk;
|
2009-02-26 03:28:24 +08:00
|
|
|
struct device dev;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-10-11 04:39:36 +08:00
|
|
|
/* used by REQ_IDETAPE_{READ,WRITE} requests */
|
|
|
|
struct ide_atapi_pc queued_pc;
|
2008-10-11 04:39:35 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* DSC polling variables.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* While polling for DSC we use postponed_rq to postpone the current
|
|
|
|
* request so that ide.c will be able to service pending requests on the
|
|
|
|
* other device. Note that at most we will have only one DSC (usually
|
2008-04-27 21:38:28 +08:00
|
|
|
* data transfer) request in the device request queue.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
ide-tape: fix handling of postponed rqs
ide-tape used to hit
[ 58.614854] ide-tape: ht0: BUG: Two DSC requests queued!
due to the fact that another rq was being issued while the driver was
waiting for DSC to get set for the device executing ATAPI commands which
set the DSC to 1 to indicate completion.
Here's a sample output of that case:
issue REZERO_UNIT
[ 143.088505] ide-tape: ide_tape_issue_pc: retry #0, cmd: 0x01
[ 143.095122] ide: Enter ide_pc_intr - interrupt handler
[ 143.096118] ide: Packet command completed, 0 bytes transferred
[ 143.106319] ide-tape: ide_tape_callback: cmd: 0x1, dsc: 1, err: 0
[ 143.112601] ide-tape: idetape_postpone_request: cmd: 0x1, dsc_poll_freq: 2000
we stall the ide-tape queue here waiting for DSC
[ 143.119936] ide-tape: ide_tape_read_position: enter
[ 145.119019] ide-tape: idetape_do_request: sector: 4294967295, nr_sectors: 0
and issue the new READ_POSITION rq and hit the check.
[ 145.126247] ide-tape: ht0: BUG: Two DSC requests queued!
[ 145.131748] ide-tape: ide_tape_read_position: BOP - No
[ 145.137059] ide-tape: ide_tape_read_position: EOP - No
Also, ->postponed_rq used to point to that postponed request. To make
things worse, in certain circumstances the rq it was pointing to got
replaced unterneath it by swiftly reusing the same rq from the mempool
of the block layer practically confusing stuff even more.
However, we don't need to keep a pointer to that rq but simply wait for
DSC to be set first before issuing the follow-up request in the drive's
queue. In order to do that, we make idetape_do_request() first check the
DSC and if not set, we stall the drive queue giving the other device on
that IDE channel a chance.
Signed-off-by: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-07-22 14:08:23 +08:00
|
|
|
bool postponed_rq;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* The time in which we started polling for DSC */
|
|
|
|
unsigned long dsc_polling_start;
|
|
|
|
/* Timer used to poll for dsc */
|
|
|
|
struct timer_list dsc_timer;
|
|
|
|
/* Read/Write dsc polling frequency */
|
2008-02-06 09:57:52 +08:00
|
|
|
unsigned long best_dsc_rw_freq;
|
|
|
|
unsigned long dsc_poll_freq;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long dsc_timeout;
|
|
|
|
|
2008-02-06 09:57:53 +08:00
|
|
|
/* Read position information */
|
2005-04-17 06:20:36 +08:00
|
|
|
u8 partition;
|
|
|
|
/* Current block */
|
2008-02-06 09:57:52 +08:00
|
|
|
unsigned int first_frame;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-06 09:57:53 +08:00
|
|
|
/* Last error information */
|
2005-04-17 06:20:36 +08:00
|
|
|
u8 sense_key, asc, ascq;
|
|
|
|
|
2008-02-06 09:57:53 +08:00
|
|
|
/* Character device operation */
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int minor;
|
|
|
|
/* device name */
|
|
|
|
char name[4];
|
|
|
|
/* Current character device data transfer direction */
|
2008-02-06 09:57:52 +08:00
|
|
|
u8 chrdev_dir;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-06 09:57:52 +08:00
|
|
|
/* tape block size, usually 512 or 1024 bytes */
|
|
|
|
unsigned short blk_size;
|
2005-04-17 06:20:36 +08:00
|
|
|
int user_bs_factor;
|
2008-02-03 02:56:49 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Copy of the tape's Capabilities and Mechanical Page */
|
2008-02-03 02:56:49 +08:00
|
|
|
u8 caps[20];
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Active data transfer request parameters.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* At most, there is only one ide-tape originated data transfer request
|
|
|
|
* in the device request queue. This allows ide.c to easily service
|
|
|
|
* requests from the other device when we postpone our active request.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2008-04-27 21:38:27 +08:00
|
|
|
|
2008-02-06 09:57:53 +08:00
|
|
|
/* Data buffer size chosen based on the tape's recommendation */
|
2008-04-27 21:38:33 +08:00
|
|
|
int buffer_size;
|
2009-04-19 07:46:02 +08:00
|
|
|
/* Staging buffer of buffer_size bytes */
|
|
|
|
void *buf;
|
|
|
|
/* The read/write cursor */
|
|
|
|
void *cur;
|
|
|
|
/* The number of valid bytes in buf */
|
|
|
|
size_t valid;
|
2008-02-06 09:57:53 +08:00
|
|
|
|
|
|
|
/* Measures average tape speed */
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long avg_time;
|
|
|
|
int avg_size;
|
|
|
|
int avg_speed;
|
|
|
|
|
|
|
|
/* the door is currently locked */
|
|
|
|
int door_locked;
|
|
|
|
/* the tape hardware is write protected */
|
|
|
|
char drv_write_prot;
|
|
|
|
/* the tape is write protected (hardware or opened as read-only) */
|
|
|
|
char write_prot;
|
|
|
|
} idetape_tape_t;
|
|
|
|
|
2010-06-02 20:28:52 +08:00
|
|
|
static DEFINE_MUTEX(ide_tape_mutex);
|
2006-03-23 19:00:45 +08:00
|
|
|
static DEFINE_MUTEX(idetape_ref_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-10-11 08:25:19 +08:00
|
|
|
static DEFINE_MUTEX(idetape_chrdev_mutex);
|
|
|
|
|
2005-09-16 17:55:07 +08:00
|
|
|
static struct class *idetape_sysfs_class;
|
|
|
|
|
2009-02-26 03:28:24 +08:00
|
|
|
static void ide_tape_release(struct device *);
|
2008-07-25 04:53:15 +08:00
|
|
|
|
2009-06-09 04:03:03 +08:00
|
|
|
static struct ide_tape_obj *idetape_devs[MAX_HWIFS * MAX_DRIVES];
|
|
|
|
|
|
|
|
static struct ide_tape_obj *ide_tape_get(struct gendisk *disk, bool cdev,
|
|
|
|
unsigned int i)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct ide_tape_obj *tape = NULL;
|
|
|
|
|
2006-03-23 19:00:45 +08:00
|
|
|
mutex_lock(&idetape_ref_mutex);
|
2009-06-09 04:03:03 +08:00
|
|
|
|
|
|
|
if (cdev)
|
|
|
|
tape = idetape_devs[i];
|
|
|
|
else
|
|
|
|
tape = ide_drv_g(disk, ide_tape_obj);
|
|
|
|
|
2008-07-25 04:53:15 +08:00
|
|
|
if (tape) {
|
2008-08-06 00:16:59 +08:00
|
|
|
if (ide_device_get(tape->drive))
|
2008-07-25 04:53:15 +08:00
|
|
|
tape = NULL;
|
2008-08-06 00:16:59 +08:00
|
|
|
else
|
2009-02-26 03:28:24 +08:00
|
|
|
get_device(&tape->dev);
|
2008-07-25 04:53:15 +08:00
|
|
|
}
|
2009-06-09 04:03:03 +08:00
|
|
|
|
2006-03-23 19:00:45 +08:00
|
|
|
mutex_unlock(&idetape_ref_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
return tape;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ide_tape_put(struct ide_tape_obj *tape)
|
|
|
|
{
|
2008-08-06 00:16:59 +08:00
|
|
|
ide_drive_t *drive = tape->drive;
|
|
|
|
|
2006-03-23 19:00:45 +08:00
|
|
|
mutex_lock(&idetape_ref_mutex);
|
2009-02-26 03:28:24 +08:00
|
|
|
put_device(&tape->dev);
|
2008-08-06 00:16:59 +08:00
|
|
|
ide_device_put(drive);
|
2006-03-23 19:00:45 +08:00
|
|
|
mutex_unlock(&idetape_ref_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-02-03 02:56:48 +08:00
|
|
|
* called on each failed packet command retry to analyze the request sense. We
|
|
|
|
* currently do not utilize this information.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2009-05-02 16:58:17 +08:00
|
|
|
static void idetape_analyze_error(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2009-03-27 19:46:34 +08:00
|
|
|
struct ide_atapi_pc *pc = drive->failed_pc;
|
2009-05-02 02:35:21 +08:00
|
|
|
struct request *rq = drive->hwif->rq;
|
2009-05-02 16:58:17 +08:00
|
|
|
u8 *sense = bio_data(rq->bio);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-03 02:56:48 +08:00
|
|
|
tape->sense_key = sense[2] & 0xF;
|
|
|
|
tape->asc = sense[12];
|
|
|
|
tape->ascq = sense[13];
|
2008-02-06 09:57:51 +08:00
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC,
|
|
|
|
"cmd: 0x%x, sense key = %x, asc = %x, ascq = %x",
|
|
|
|
rq->cmd[0], tape->sense_key, tape->asc, tape->ascq);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-05-02 03:21:02 +08:00
|
|
|
/* correct remaining bytes to transfer */
|
2009-04-19 07:46:02 +08:00
|
|
|
if (pc->flags & PC_FLAG_DMA_ERROR)
|
2017-01-27 16:46:29 +08:00
|
|
|
scsi_req(rq)->resid_len = tape->blk_size * get_unaligned_be32(&sense[3]);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If error was the result of a zero-length read or write command,
|
|
|
|
* with sense key=5, asc=0x22, ascq=0, let it slide. Some drives
|
|
|
|
* (i.e. Seagate STT3401A Travan) don't support 0-length read/writes.
|
|
|
|
*/
|
2008-02-03 02:56:50 +08:00
|
|
|
if ((pc->c[0] == READ_6 || pc->c[0] == WRITE_6)
|
2008-02-03 02:56:48 +08:00
|
|
|
/* length == 0 */
|
|
|
|
&& pc->c[4] == 0 && pc->c[3] == 0 && pc->c[2] == 0) {
|
|
|
|
if (tape->sense_key == 5) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* don't report an error, everything's ok */
|
|
|
|
pc->error = 0;
|
|
|
|
/* don't retry read/write */
|
2008-04-18 06:46:26 +08:00
|
|
|
pc->flags |= PC_FLAG_ABORT;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
2008-02-03 02:56:50 +08:00
|
|
|
if (pc->c[0] == READ_6 && (sense[2] & 0x80)) {
|
2009-03-27 19:46:34 +08:00
|
|
|
pc->error = IDE_DRV_ERROR_FILEMARK;
|
2008-04-18 06:46:26 +08:00
|
|
|
pc->flags |= PC_FLAG_ABORT;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-02-03 02:56:50 +08:00
|
|
|
if (pc->c[0] == WRITE_6) {
|
2008-02-03 02:56:48 +08:00
|
|
|
if ((sense[2] & 0x40) || (tape->sense_key == 0xd
|
|
|
|
&& tape->asc == 0x0 && tape->ascq == 0x2)) {
|
2009-03-27 19:46:34 +08:00
|
|
|
pc->error = IDE_DRV_ERROR_EOD;
|
2008-04-18 06:46:26 +08:00
|
|
|
pc->flags |= PC_FLAG_ABORT;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
2008-02-03 02:56:50 +08:00
|
|
|
if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) {
|
2008-02-03 02:56:48 +08:00
|
|
|
if (tape->sense_key == 8) {
|
2009-03-27 19:46:34 +08:00
|
|
|
pc->error = IDE_DRV_ERROR_EOD;
|
2008-04-18 06:46:26 +08:00
|
|
|
pc->flags |= PC_FLAG_ABORT;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-04-18 06:46:26 +08:00
|
|
|
if (!(pc->flags & PC_FLAG_ABORT) &&
|
2017-01-27 16:46:29 +08:00
|
|
|
(blk_rq_bytes(rq) - scsi_req(rq)->resid_len))
|
2005-04-17 06:20:36 +08:00
|
|
|
pc->retries = IDETAPE_MAX_PC_RETRIES + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-14 03:39:30 +08:00
|
|
|
static void ide_tape_handle_dsc(ide_drive_t *);
|
|
|
|
|
2009-03-27 19:46:36 +08:00
|
|
|
static int ide_tape_callback(ide_drive_t *drive, int dsc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-10-14 03:39:31 +08:00
|
|
|
struct ide_atapi_pc *pc = drive->pc;
|
2009-03-27 19:46:34 +08:00
|
|
|
struct request *rq = drive->hwif->rq;
|
2008-07-16 03:21:55 +08:00
|
|
|
int uptodate = pc->error ? 0 : 1;
|
2009-03-27 19:46:34 +08:00
|
|
|
int err = uptodate ? 0 : IDE_DRV_ERROR_GENERAL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "cmd: 0x%x, dsc: %d, err: %d", rq->cmd[0],
|
|
|
|
dsc, err);
|
2008-02-06 09:57:51 +08:00
|
|
|
|
2008-10-14 03:39:30 +08:00
|
|
|
if (dsc)
|
|
|
|
ide_tape_handle_dsc(drive);
|
|
|
|
|
2009-03-27 19:46:34 +08:00
|
|
|
if (drive->failed_pc == pc)
|
|
|
|
drive->failed_pc = NULL;
|
2008-07-16 03:22:01 +08:00
|
|
|
|
2008-07-16 03:21:55 +08:00
|
|
|
if (pc->c[0] == REQUEST_SENSE) {
|
|
|
|
if (uptodate)
|
2009-05-02 16:58:17 +08:00
|
|
|
idetape_analyze_error(drive);
|
2008-07-16 03:21:55 +08:00
|
|
|
else
|
|
|
|
printk(KERN_ERR "ide-tape: Error in REQUEST SENSE "
|
|
|
|
"itself - Aborting request!\n");
|
|
|
|
} else if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) {
|
2009-05-02 03:21:02 +08:00
|
|
|
unsigned int blocks =
|
2017-01-27 16:46:29 +08:00
|
|
|
(blk_rq_bytes(rq) - scsi_req(rq)->resid_len) / tape->blk_size;
|
2008-07-16 03:21:55 +08:00
|
|
|
|
|
|
|
tape->avg_size += blocks * tape->blk_size;
|
|
|
|
|
|
|
|
if (time_after_eq(jiffies, tape->avg_time + HZ)) {
|
|
|
|
tape->avg_speed = tape->avg_size * HZ /
|
|
|
|
(jiffies - tape->avg_time) / 1024;
|
|
|
|
tape->avg_size = 0;
|
|
|
|
tape->avg_time = jiffies;
|
|
|
|
}
|
|
|
|
|
|
|
|
tape->first_frame += blocks;
|
|
|
|
|
2009-03-27 19:46:34 +08:00
|
|
|
if (pc->error) {
|
|
|
|
uptodate = 0;
|
|
|
|
err = pc->error;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2017-04-20 22:03:01 +08:00
|
|
|
scsi_req(rq)->result = err;
|
2009-03-27 19:46:34 +08:00
|
|
|
|
2009-03-27 19:46:36 +08:00
|
|
|
return uptodate;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Postpone the current request so that ide.c will be able to service requests
|
2009-01-07 00:20:50 +08:00
|
|
|
* from another device on the same port while we are polling for DSC.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
ide-tape: fix handling of postponed rqs
ide-tape used to hit
[ 58.614854] ide-tape: ht0: BUG: Two DSC requests queued!
due to the fact that another rq was being issued while the driver was
waiting for DSC to get set for the device executing ATAPI commands which
set the DSC to 1 to indicate completion.
Here's a sample output of that case:
issue REZERO_UNIT
[ 143.088505] ide-tape: ide_tape_issue_pc: retry #0, cmd: 0x01
[ 143.095122] ide: Enter ide_pc_intr - interrupt handler
[ 143.096118] ide: Packet command completed, 0 bytes transferred
[ 143.106319] ide-tape: ide_tape_callback: cmd: 0x1, dsc: 1, err: 0
[ 143.112601] ide-tape: idetape_postpone_request: cmd: 0x1, dsc_poll_freq: 2000
we stall the ide-tape queue here waiting for DSC
[ 143.119936] ide-tape: ide_tape_read_position: enter
[ 145.119019] ide-tape: idetape_do_request: sector: 4294967295, nr_sectors: 0
and issue the new READ_POSITION rq and hit the check.
[ 145.126247] ide-tape: ht0: BUG: Two DSC requests queued!
[ 145.131748] ide-tape: ide_tape_read_position: BOP - No
[ 145.137059] ide-tape: ide_tape_read_position: EOP - No
Also, ->postponed_rq used to point to that postponed request. To make
things worse, in certain circumstances the rq it was pointing to got
replaced unterneath it by swiftly reusing the same rq from the mempool
of the block layer practically confusing stuff even more.
However, we don't need to keep a pointer to that rq but simply wait for
DSC to be set first before issuing the follow-up request in the drive's
queue. In order to do that, we make idetape_do_request() first check the
DSC and if not set, we stall the drive queue giving the other device on
that IDE channel a chance.
Signed-off-by: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-07-22 14:08:23 +08:00
|
|
|
static void ide_tape_stall_queue(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "cmd: 0x%x, dsc_poll_freq: %lu",
|
ide-tape: fix handling of postponed rqs
ide-tape used to hit
[ 58.614854] ide-tape: ht0: BUG: Two DSC requests queued!
due to the fact that another rq was being issued while the driver was
waiting for DSC to get set for the device executing ATAPI commands which
set the DSC to 1 to indicate completion.
Here's a sample output of that case:
issue REZERO_UNIT
[ 143.088505] ide-tape: ide_tape_issue_pc: retry #0, cmd: 0x01
[ 143.095122] ide: Enter ide_pc_intr - interrupt handler
[ 143.096118] ide: Packet command completed, 0 bytes transferred
[ 143.106319] ide-tape: ide_tape_callback: cmd: 0x1, dsc: 1, err: 0
[ 143.112601] ide-tape: idetape_postpone_request: cmd: 0x1, dsc_poll_freq: 2000
we stall the ide-tape queue here waiting for DSC
[ 143.119936] ide-tape: ide_tape_read_position: enter
[ 145.119019] ide-tape: idetape_do_request: sector: 4294967295, nr_sectors: 0
and issue the new READ_POSITION rq and hit the check.
[ 145.126247] ide-tape: ht0: BUG: Two DSC requests queued!
[ 145.131748] ide-tape: ide_tape_read_position: BOP - No
[ 145.137059] ide-tape: ide_tape_read_position: EOP - No
Also, ->postponed_rq used to point to that postponed request. To make
things worse, in certain circumstances the rq it was pointing to got
replaced unterneath it by swiftly reusing the same rq from the mempool
of the block layer practically confusing stuff even more.
However, we don't need to keep a pointer to that rq but simply wait for
DSC to be set first before issuing the follow-up request in the drive's
queue. In order to do that, we make idetape_do_request() first check the
DSC and if not set, we stall the drive queue giving the other device on
that IDE channel a chance.
Signed-off-by: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-07-22 14:08:23 +08:00
|
|
|
drive->hwif->rq->cmd[0], tape->dsc_poll_freq);
|
2008-02-06 09:57:51 +08:00
|
|
|
|
ide-tape: fix handling of postponed rqs
ide-tape used to hit
[ 58.614854] ide-tape: ht0: BUG: Two DSC requests queued!
due to the fact that another rq was being issued while the driver was
waiting for DSC to get set for the device executing ATAPI commands which
set the DSC to 1 to indicate completion.
Here's a sample output of that case:
issue REZERO_UNIT
[ 143.088505] ide-tape: ide_tape_issue_pc: retry #0, cmd: 0x01
[ 143.095122] ide: Enter ide_pc_intr - interrupt handler
[ 143.096118] ide: Packet command completed, 0 bytes transferred
[ 143.106319] ide-tape: ide_tape_callback: cmd: 0x1, dsc: 1, err: 0
[ 143.112601] ide-tape: idetape_postpone_request: cmd: 0x1, dsc_poll_freq: 2000
we stall the ide-tape queue here waiting for DSC
[ 143.119936] ide-tape: ide_tape_read_position: enter
[ 145.119019] ide-tape: idetape_do_request: sector: 4294967295, nr_sectors: 0
and issue the new READ_POSITION rq and hit the check.
[ 145.126247] ide-tape: ht0: BUG: Two DSC requests queued!
[ 145.131748] ide-tape: ide_tape_read_position: BOP - No
[ 145.137059] ide-tape: ide_tape_read_position: EOP - No
Also, ->postponed_rq used to point to that postponed request. To make
things worse, in certain circumstances the rq it was pointing to got
replaced unterneath it by swiftly reusing the same rq from the mempool
of the block layer practically confusing stuff even more.
However, we don't need to keep a pointer to that rq but simply wait for
DSC to be set first before issuing the follow-up request in the drive's
queue. In order to do that, we make idetape_do_request() first check the
DSC and if not set, we stall the drive queue giving the other device on
that IDE channel a chance.
Signed-off-by: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-07-22 14:08:23 +08:00
|
|
|
tape->postponed_rq = true;
|
2009-01-07 00:20:50 +08:00
|
|
|
|
2008-02-06 09:57:52 +08:00
|
|
|
ide_stall_queue(drive, tape->dsc_poll_freq);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-16 03:22:01 +08:00
|
|
|
static void ide_tape_handle_dsc(ide_drive_t *drive)
|
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
|
|
|
|
|
|
|
/* Media access command */
|
|
|
|
tape->dsc_polling_start = jiffies;
|
|
|
|
tape->dsc_poll_freq = IDETAPE_DSC_MA_FAST;
|
|
|
|
tape->dsc_timeout = jiffies + IDETAPE_DSC_MA_TIMEOUT;
|
|
|
|
/* Allow ide.c to handle other requests */
|
ide-tape: fix handling of postponed rqs
ide-tape used to hit
[ 58.614854] ide-tape: ht0: BUG: Two DSC requests queued!
due to the fact that another rq was being issued while the driver was
waiting for DSC to get set for the device executing ATAPI commands which
set the DSC to 1 to indicate completion.
Here's a sample output of that case:
issue REZERO_UNIT
[ 143.088505] ide-tape: ide_tape_issue_pc: retry #0, cmd: 0x01
[ 143.095122] ide: Enter ide_pc_intr - interrupt handler
[ 143.096118] ide: Packet command completed, 0 bytes transferred
[ 143.106319] ide-tape: ide_tape_callback: cmd: 0x1, dsc: 1, err: 0
[ 143.112601] ide-tape: idetape_postpone_request: cmd: 0x1, dsc_poll_freq: 2000
we stall the ide-tape queue here waiting for DSC
[ 143.119936] ide-tape: ide_tape_read_position: enter
[ 145.119019] ide-tape: idetape_do_request: sector: 4294967295, nr_sectors: 0
and issue the new READ_POSITION rq and hit the check.
[ 145.126247] ide-tape: ht0: BUG: Two DSC requests queued!
[ 145.131748] ide-tape: ide_tape_read_position: BOP - No
[ 145.137059] ide-tape: ide_tape_read_position: EOP - No
Also, ->postponed_rq used to point to that postponed request. To make
things worse, in certain circumstances the rq it was pointing to got
replaced unterneath it by swiftly reusing the same rq from the mempool
of the block layer practically confusing stuff even more.
However, we don't need to keep a pointer to that rq but simply wait for
DSC to be set first before issuing the follow-up request in the drive's
queue. In order to do that, we make idetape_do_request() first check the
DSC and if not set, we stall the drive queue giving the other device on
that IDE channel a chance.
Signed-off-by: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-07-22 14:08:23 +08:00
|
|
|
ide_tape_stall_queue(drive);
|
2008-07-16 03:22:01 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Packet Command Interface
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-10-14 03:39:31 +08:00
|
|
|
* The current Packet Command is available in drive->pc, and will not change
|
2008-02-06 09:57:53 +08:00
|
|
|
* until we finish handling it. Each packet command is associated with a
|
|
|
|
* callback function that will be called when the command is finished.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* The handling will be done in three stages:
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2009-03-27 19:46:46 +08:00
|
|
|
* 1. ide_tape_issue_pc will send the packet command to the drive, and will set
|
2008-10-14 03:39:32 +08:00
|
|
|
* the interrupt handler to ide_pc_intr.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-10-14 03:39:32 +08:00
|
|
|
* 2. On each interrupt, ide_pc_intr will be called. This step will be
|
2008-02-06 09:57:53 +08:00
|
|
|
* repeated until the device signals us that no more interrupts will be issued.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* 3. ATAPI Tape media access commands have immediate status with a delayed
|
|
|
|
* process. In case of a successful initiation of a media access packet command,
|
|
|
|
* the DSC bit will be set when the actual execution of the command is finished.
|
|
|
|
* Since the tape drive will not issue an interrupt, we have to poll for this
|
|
|
|
* event. In this case, we define the request as "low priority request" by
|
|
|
|
* setting rq_status to IDETAPE_RQ_POSTPONED, set a timer to poll for DSC and
|
|
|
|
* exit the driver.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* ide.c will then give higher priority to requests which originate from the
|
|
|
|
* other device, until will change rq_status to RQ_ACTIVE.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* 4. When the packet command is finished, it will be checked for errors.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* 5. In case an error was found, we queue a request sense packet command in
|
|
|
|
* front of the request queue and retry the operation up to
|
|
|
|
* IDETAPE_MAX_PC_RETRIES times.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* 6. In case no error was found, or we decided to give up and not to retry
|
|
|
|
* again, the callback function will be called and then we will handle the next
|
|
|
|
* request.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
2009-03-27 19:46:46 +08:00
|
|
|
static ide_startstop_t ide_tape_issue_pc(ide_drive_t *drive,
|
|
|
|
struct ide_cmd *cmd,
|
|
|
|
struct ide_atapi_pc *pc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2009-05-02 02:35:21 +08:00
|
|
|
struct request *rq = drive->hwif->rq;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-03-27 19:46:34 +08:00
|
|
|
if (drive->failed_pc == NULL && pc->c[0] != REQUEST_SENSE)
|
|
|
|
drive->failed_pc = pc;
|
2008-10-14 03:39:31 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Set the current packet command */
|
2008-10-14 03:39:31 +08:00
|
|
|
drive->pc = pc;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (pc->retries > IDETAPE_MAX_PC_RETRIES ||
|
2008-04-18 06:46:26 +08:00
|
|
|
(pc->flags & PC_FLAG_ABORT)) {
|
2009-04-19 07:46:02 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* We will "abort" retrying a packet command in case legitimate
|
|
|
|
* error code was received (crossing a filemark, or end of the
|
|
|
|
* media, for example).
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2008-04-18 06:46:26 +08:00
|
|
|
if (!(pc->flags & PC_FLAG_ABORT)) {
|
2008-02-03 02:56:50 +08:00
|
|
|
if (!(pc->c[0] == TEST_UNIT_READY &&
|
2005-04-17 06:20:36 +08:00
|
|
|
tape->sense_key == 2 && tape->asc == 4 &&
|
|
|
|
(tape->ascq == 1 || tape->ascq == 8))) {
|
|
|
|
printk(KERN_ERR "ide-tape: %s: I/O error, "
|
|
|
|
"pc = %2x, key = %2x, "
|
|
|
|
"asc = %2x, ascq = %2x\n",
|
|
|
|
tape->name, pc->c[0],
|
|
|
|
tape->sense_key, tape->asc,
|
|
|
|
tape->ascq);
|
|
|
|
}
|
|
|
|
/* Giving up */
|
2009-03-27 19:46:34 +08:00
|
|
|
pc->error = IDE_DRV_ERROR_GENERAL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-04-19 07:46:02 +08:00
|
|
|
|
2009-03-27 19:46:34 +08:00
|
|
|
drive->failed_pc = NULL;
|
2008-10-14 03:39:30 +08:00
|
|
|
drive->pc_callback(drive, 0);
|
2017-06-03 15:38:04 +08:00
|
|
|
ide_complete_rq(drive, BLK_STS_IOERR, blk_rq_bytes(rq));
|
2008-07-16 03:21:55 +08:00
|
|
|
return ide_stopped;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_SENSE, "retry #%d, cmd: 0x%02x", pc->retries,
|
|
|
|
pc->c[0]);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
pc->retries++;
|
|
|
|
|
2009-03-27 19:46:46 +08:00
|
|
|
return ide_issue_pc(drive, cmd);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:53 +08:00
|
|
|
/* A mode sense command is used to "sense" tape parameters. */
|
2008-04-18 06:46:27 +08:00
|
|
|
static void idetape_create_mode_sense_cmd(struct ide_atapi_pc *pc, u8 page_code)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-11 04:39:37 +08:00
|
|
|
ide_init_pc(pc);
|
2008-02-03 02:56:50 +08:00
|
|
|
pc->c[0] = MODE_SENSE;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (page_code != IDETAPE_BLOCK_DESCRIPTOR)
|
2008-02-06 09:57:53 +08:00
|
|
|
/* DBD = 1 - Don't return block descriptors */
|
|
|
|
pc->c[1] = 8;
|
2005-04-17 06:20:36 +08:00
|
|
|
pc->c[2] = page_code;
|
|
|
|
/*
|
|
|
|
* Changed pc->c[3] to 0 (255 will at best return unused info).
|
|
|
|
*
|
|
|
|
* For SCSI this byte is defined as subpage instead of high byte
|
|
|
|
* of length and some IDE drives seem to interpret it this way
|
|
|
|
* and return an error when 255 is used.
|
|
|
|
*/
|
|
|
|
pc->c[3] = 0;
|
2008-02-06 09:57:53 +08:00
|
|
|
/* We will just discard data in that case */
|
|
|
|
pc->c[4] = 255;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (page_code == IDETAPE_BLOCK_DESCRIPTOR)
|
2008-04-18 06:46:27 +08:00
|
|
|
pc->req_xfer = 12;
|
2005-04-17 06:20:36 +08:00
|
|
|
else if (page_code == IDETAPE_CAPABILITIES_PAGE)
|
2008-04-18 06:46:27 +08:00
|
|
|
pc->req_xfer = 24;
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
2008-04-18 06:46:27 +08:00
|
|
|
pc->req_xfer = 50;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:54 +08:00
|
|
|
static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-07-24 01:55:52 +08:00
|
|
|
ide_hwif_t *hwif = drive->hwif;
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-10-14 03:39:31 +08:00
|
|
|
struct ide_atapi_pc *pc = drive->pc;
|
2008-01-26 05:17:11 +08:00
|
|
|
u8 stat;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-24 01:55:56 +08:00
|
|
|
stat = hwif->tp_ops->read_status(hwif);
|
2008-02-06 09:57:51 +08:00
|
|
|
|
2008-10-11 04:39:21 +08:00
|
|
|
if (stat & ATA_DSC) {
|
|
|
|
if (stat & ATA_ERR) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Error detected */
|
2008-02-03 02:56:50 +08:00
|
|
|
if (pc->c[0] != TEST_UNIT_READY)
|
2005-04-17 06:20:36 +08:00
|
|
|
printk(KERN_ERR "ide-tape: %s: I/O error, ",
|
|
|
|
tape->name);
|
|
|
|
/* Retry operation */
|
2009-04-19 06:00:42 +08:00
|
|
|
ide_retry_pc(drive);
|
2008-07-16 03:21:55 +08:00
|
|
|
return ide_stopped;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
pc->error = 0;
|
|
|
|
} else {
|
2009-03-27 19:46:34 +08:00
|
|
|
pc->error = IDE_DRV_ERROR_GENERAL;
|
2009-03-27 19:46:34 +08:00
|
|
|
drive->failed_pc = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-10-14 03:39:30 +08:00
|
|
|
drive->pc_callback(drive, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
return ide_stopped;
|
|
|
|
}
|
|
|
|
|
2008-07-16 03:22:03 +08:00
|
|
|
static void ide_tape_create_rw_cmd(idetape_tape_t *tape,
|
2008-07-24 01:56:00 +08:00
|
|
|
struct ide_atapi_pc *pc, struct request *rq,
|
|
|
|
u8 opcode)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-05-02 02:29:53 +08:00
|
|
|
unsigned int length = blk_rq_sectors(rq) / (tape->blk_size >> 9);
|
2008-07-24 01:56:00 +08:00
|
|
|
|
2008-10-11 04:39:37 +08:00
|
|
|
ide_init_pc(pc);
|
2008-02-03 02:56:50 +08:00
|
|
|
put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]);
|
2005-04-17 06:20:36 +08:00
|
|
|
pc->c[1] = 1;
|
2009-05-04 15:53:03 +08:00
|
|
|
|
|
|
|
if (blk_rq_bytes(rq) == tape->buffer_size)
|
2008-07-16 03:21:56 +08:00
|
|
|
pc->flags |= PC_FLAG_DMA_OK;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-04-19 07:46:02 +08:00
|
|
|
if (opcode == READ_6)
|
2008-07-16 03:22:03 +08:00
|
|
|
pc->c[0] = READ_6;
|
2009-04-19 07:46:02 +08:00
|
|
|
else if (opcode == WRITE_6) {
|
2008-07-16 03:22:03 +08:00
|
|
|
pc->c[0] = WRITE_6;
|
|
|
|
pc->flags |= PC_FLAG_WRITING;
|
|
|
|
}
|
2008-07-24 01:56:00 +08:00
|
|
|
|
2017-01-27 16:46:29 +08:00
|
|
|
memcpy(scsi_req(rq)->cmd, pc->c, 12);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static ide_startstop_t idetape_do_request(ide_drive_t *drive,
|
|
|
|
struct request *rq, sector_t block)
|
|
|
|
{
|
2008-07-24 01:55:52 +08:00
|
|
|
ide_hwif_t *hwif = drive->hwif;
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-04-18 06:46:27 +08:00
|
|
|
struct ide_atapi_pc *pc = NULL;
|
2009-03-27 19:46:46 +08:00
|
|
|
struct ide_cmd cmd;
|
2017-01-27 16:46:29 +08:00
|
|
|
struct scsi_request *req = scsi_req(rq);
|
2008-01-26 05:17:11 +08:00
|
|
|
u8 stat;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_RQ, "cmd: 0x%x, sector: %llu, nr_sectors: %u",
|
2017-01-27 16:46:29 +08:00
|
|
|
req->cmd[0], (unsigned long long)blk_rq_pos(rq),
|
2009-07-18 07:55:16 +08:00
|
|
|
blk_rq_sectors(rq));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-01-31 23:57:31 +08:00
|
|
|
BUG_ON(!blk_rq_is_private(rq));
|
2017-01-31 23:57:30 +08:00
|
|
|
BUG_ON(ide_req(rq)->type != ATA_PRIV_MISC &&
|
|
|
|
ide_req(rq)->type != ATA_PRIV_SENSE);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-06 09:57:53 +08:00
|
|
|
/* Retry a failed packet command */
|
2009-03-27 19:46:34 +08:00
|
|
|
if (drive->failed_pc && drive->pc->c[0] == REQUEST_SENSE) {
|
|
|
|
pc = drive->failed_pc;
|
2008-07-16 03:21:59 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2008-02-06 09:57:54 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* If the tape is still busy, postpone our request and service
|
|
|
|
* the other device meanwhile.
|
|
|
|
*/
|
2008-07-24 01:55:56 +08:00
|
|
|
stat = hwif->tp_ops->read_status(hwif);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-10-14 03:39:36 +08:00
|
|
|
if ((drive->dev_flags & IDE_DFLAG_DSC_OVERLAP) == 0 &&
|
2017-01-27 16:46:29 +08:00
|
|
|
(req->cmd[13] & REQ_IDETAPE_PC2) == 0)
|
2009-06-07 21:37:05 +08:00
|
|
|
drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-10-14 03:39:36 +08:00
|
|
|
if (drive->dev_flags & IDE_DFLAG_POST_RESET) {
|
2009-06-07 21:37:05 +08:00
|
|
|
drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC;
|
2008-10-14 03:39:36 +08:00
|
|
|
drive->dev_flags &= ~IDE_DFLAG_POST_RESET;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-06-07 21:37:05 +08:00
|
|
|
if (!(drive->atapi_flags & IDE_AFLAG_IGNORE_DSC) &&
|
|
|
|
!(stat & ATA_DSC)) {
|
ide-tape: fix handling of postponed rqs
ide-tape used to hit
[ 58.614854] ide-tape: ht0: BUG: Two DSC requests queued!
due to the fact that another rq was being issued while the driver was
waiting for DSC to get set for the device executing ATAPI commands which
set the DSC to 1 to indicate completion.
Here's a sample output of that case:
issue REZERO_UNIT
[ 143.088505] ide-tape: ide_tape_issue_pc: retry #0, cmd: 0x01
[ 143.095122] ide: Enter ide_pc_intr - interrupt handler
[ 143.096118] ide: Packet command completed, 0 bytes transferred
[ 143.106319] ide-tape: ide_tape_callback: cmd: 0x1, dsc: 1, err: 0
[ 143.112601] ide-tape: idetape_postpone_request: cmd: 0x1, dsc_poll_freq: 2000
we stall the ide-tape queue here waiting for DSC
[ 143.119936] ide-tape: ide_tape_read_position: enter
[ 145.119019] ide-tape: idetape_do_request: sector: 4294967295, nr_sectors: 0
and issue the new READ_POSITION rq and hit the check.
[ 145.126247] ide-tape: ht0: BUG: Two DSC requests queued!
[ 145.131748] ide-tape: ide_tape_read_position: BOP - No
[ 145.137059] ide-tape: ide_tape_read_position: EOP - No
Also, ->postponed_rq used to point to that postponed request. To make
things worse, in certain circumstances the rq it was pointing to got
replaced unterneath it by swiftly reusing the same rq from the mempool
of the block layer practically confusing stuff even more.
However, we don't need to keep a pointer to that rq but simply wait for
DSC to be set first before issuing the follow-up request in the drive's
queue. In order to do that, we make idetape_do_request() first check the
DSC and if not set, we stall the drive queue giving the other device on
that IDE channel a chance.
Signed-off-by: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-07-22 14:08:23 +08:00
|
|
|
if (!tape->postponed_rq) {
|
2005-04-17 06:20:36 +08:00
|
|
|
tape->dsc_polling_start = jiffies;
|
2008-02-06 09:57:52 +08:00
|
|
|
tape->dsc_poll_freq = tape->best_dsc_rw_freq;
|
2005-04-17 06:20:36 +08:00
|
|
|
tape->dsc_timeout = jiffies + IDETAPE_DSC_RW_TIMEOUT;
|
|
|
|
} else if (time_after(jiffies, tape->dsc_timeout)) {
|
|
|
|
printk(KERN_ERR "ide-tape: %s: DSC timeout\n",
|
|
|
|
tape->name);
|
2017-01-27 16:46:29 +08:00
|
|
|
if (req->cmd[13] & REQ_IDETAPE_PC2) {
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_media_access_finished(drive);
|
|
|
|
return ide_stopped;
|
|
|
|
} else {
|
|
|
|
return ide_do_reset(drive);
|
|
|
|
}
|
2008-02-06 09:57:54 +08:00
|
|
|
} else if (time_after(jiffies,
|
|
|
|
tape->dsc_polling_start +
|
|
|
|
IDETAPE_DSC_MA_THRESHOLD))
|
2008-02-06 09:57:52 +08:00
|
|
|
tape->dsc_poll_freq = IDETAPE_DSC_MA_SLOW;
|
ide-tape: fix handling of postponed rqs
ide-tape used to hit
[ 58.614854] ide-tape: ht0: BUG: Two DSC requests queued!
due to the fact that another rq was being issued while the driver was
waiting for DSC to get set for the device executing ATAPI commands which
set the DSC to 1 to indicate completion.
Here's a sample output of that case:
issue REZERO_UNIT
[ 143.088505] ide-tape: ide_tape_issue_pc: retry #0, cmd: 0x01
[ 143.095122] ide: Enter ide_pc_intr - interrupt handler
[ 143.096118] ide: Packet command completed, 0 bytes transferred
[ 143.106319] ide-tape: ide_tape_callback: cmd: 0x1, dsc: 1, err: 0
[ 143.112601] ide-tape: idetape_postpone_request: cmd: 0x1, dsc_poll_freq: 2000
we stall the ide-tape queue here waiting for DSC
[ 143.119936] ide-tape: ide_tape_read_position: enter
[ 145.119019] ide-tape: idetape_do_request: sector: 4294967295, nr_sectors: 0
and issue the new READ_POSITION rq and hit the check.
[ 145.126247] ide-tape: ht0: BUG: Two DSC requests queued!
[ 145.131748] ide-tape: ide_tape_read_position: BOP - No
[ 145.137059] ide-tape: ide_tape_read_position: EOP - No
Also, ->postponed_rq used to point to that postponed request. To make
things worse, in certain circumstances the rq it was pointing to got
replaced unterneath it by swiftly reusing the same rq from the mempool
of the block layer practically confusing stuff even more.
However, we don't need to keep a pointer to that rq but simply wait for
DSC to be set first before issuing the follow-up request in the drive's
queue. In order to do that, we make idetape_do_request() first check the
DSC and if not set, we stall the drive queue giving the other device on
that IDE channel a chance.
Signed-off-by: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-07-22 14:08:23 +08:00
|
|
|
ide_tape_stall_queue(drive);
|
2005-04-17 06:20:36 +08:00
|
|
|
return ide_stopped;
|
ide-tape: fix handling of postponed rqs
ide-tape used to hit
[ 58.614854] ide-tape: ht0: BUG: Two DSC requests queued!
due to the fact that another rq was being issued while the driver was
waiting for DSC to get set for the device executing ATAPI commands which
set the DSC to 1 to indicate completion.
Here's a sample output of that case:
issue REZERO_UNIT
[ 143.088505] ide-tape: ide_tape_issue_pc: retry #0, cmd: 0x01
[ 143.095122] ide: Enter ide_pc_intr - interrupt handler
[ 143.096118] ide: Packet command completed, 0 bytes transferred
[ 143.106319] ide-tape: ide_tape_callback: cmd: 0x1, dsc: 1, err: 0
[ 143.112601] ide-tape: idetape_postpone_request: cmd: 0x1, dsc_poll_freq: 2000
we stall the ide-tape queue here waiting for DSC
[ 143.119936] ide-tape: ide_tape_read_position: enter
[ 145.119019] ide-tape: idetape_do_request: sector: 4294967295, nr_sectors: 0
and issue the new READ_POSITION rq and hit the check.
[ 145.126247] ide-tape: ht0: BUG: Two DSC requests queued!
[ 145.131748] ide-tape: ide_tape_read_position: BOP - No
[ 145.137059] ide-tape: ide_tape_read_position: EOP - No
Also, ->postponed_rq used to point to that postponed request. To make
things worse, in certain circumstances the rq it was pointing to got
replaced unterneath it by swiftly reusing the same rq from the mempool
of the block layer practically confusing stuff even more.
However, we don't need to keep a pointer to that rq but simply wait for
DSC to be set first before issuing the follow-up request in the drive's
queue. In order to do that, we make idetape_do_request() first check the
DSC and if not set, we stall the drive queue giving the other device on
that IDE channel a chance.
Signed-off-by: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-07-22 14:08:23 +08:00
|
|
|
} else {
|
2009-06-07 21:37:05 +08:00
|
|
|
drive->atapi_flags &= ~IDE_AFLAG_IGNORE_DSC;
|
ide-tape: fix handling of postponed rqs
ide-tape used to hit
[ 58.614854] ide-tape: ht0: BUG: Two DSC requests queued!
due to the fact that another rq was being issued while the driver was
waiting for DSC to get set for the device executing ATAPI commands which
set the DSC to 1 to indicate completion.
Here's a sample output of that case:
issue REZERO_UNIT
[ 143.088505] ide-tape: ide_tape_issue_pc: retry #0, cmd: 0x01
[ 143.095122] ide: Enter ide_pc_intr - interrupt handler
[ 143.096118] ide: Packet command completed, 0 bytes transferred
[ 143.106319] ide-tape: ide_tape_callback: cmd: 0x1, dsc: 1, err: 0
[ 143.112601] ide-tape: idetape_postpone_request: cmd: 0x1, dsc_poll_freq: 2000
we stall the ide-tape queue here waiting for DSC
[ 143.119936] ide-tape: ide_tape_read_position: enter
[ 145.119019] ide-tape: idetape_do_request: sector: 4294967295, nr_sectors: 0
and issue the new READ_POSITION rq and hit the check.
[ 145.126247] ide-tape: ht0: BUG: Two DSC requests queued!
[ 145.131748] ide-tape: ide_tape_read_position: BOP - No
[ 145.137059] ide-tape: ide_tape_read_position: EOP - No
Also, ->postponed_rq used to point to that postponed request. To make
things worse, in certain circumstances the rq it was pointing to got
replaced unterneath it by swiftly reusing the same rq from the mempool
of the block layer practically confusing stuff even more.
However, we don't need to keep a pointer to that rq but simply wait for
DSC to be set first before issuing the follow-up request in the drive's
queue. In order to do that, we make idetape_do_request() first check the
DSC and if not set, we stall the drive queue giving the other device on
that IDE channel a chance.
Signed-off-by: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-07-22 14:08:23 +08:00
|
|
|
tape->postponed_rq = false;
|
|
|
|
}
|
2009-06-07 21:37:05 +08:00
|
|
|
|
2017-01-27 16:46:29 +08:00
|
|
|
if (req->cmd[13] & REQ_IDETAPE_READ) {
|
2008-10-11 04:39:36 +08:00
|
|
|
pc = &tape->queued_pc;
|
2008-07-24 01:56:00 +08:00
|
|
|
ide_tape_create_rw_cmd(tape, pc, rq, READ_6);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2017-01-27 16:46:29 +08:00
|
|
|
if (req->cmd[13] & REQ_IDETAPE_WRITE) {
|
2008-10-11 04:39:36 +08:00
|
|
|
pc = &tape->queued_pc;
|
2008-07-24 01:56:00 +08:00
|
|
|
ide_tape_create_rw_cmd(tape, pc, rq, WRITE_6);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2017-01-27 16:46:29 +08:00
|
|
|
if (req->cmd[13] & REQ_IDETAPE_PC1) {
|
2018-11-10 16:30:49 +08:00
|
|
|
pc = (struct ide_atapi_pc *)ide_req(rq)->special;
|
2017-01-27 16:46:29 +08:00
|
|
|
req->cmd[13] &= ~(REQ_IDETAPE_PC1);
|
|
|
|
req->cmd[13] |= REQ_IDETAPE_PC2;
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2017-01-27 16:46:29 +08:00
|
|
|
if (req->cmd[13] & REQ_IDETAPE_PC2) {
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_media_access_finished(drive);
|
|
|
|
return ide_stopped;
|
|
|
|
}
|
|
|
|
BUG();
|
2008-07-16 03:21:59 +08:00
|
|
|
|
2008-07-24 01:56:01 +08:00
|
|
|
out:
|
2009-04-19 06:00:42 +08:00
|
|
|
/* prepare sense request for this command */
|
|
|
|
ide_prep_sense(drive, rq);
|
|
|
|
|
2009-03-27 19:46:46 +08:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
|
|
|
|
if (rq_data_dir(rq))
|
|
|
|
cmd.tf_flags |= IDE_TFLAG_WRITE;
|
|
|
|
|
|
|
|
cmd.rq = rq;
|
|
|
|
|
2009-05-02 02:35:21 +08:00
|
|
|
ide_init_sg_cmd(&cmd, blk_rq_bytes(rq));
|
2009-04-19 06:00:42 +08:00
|
|
|
ide_map_sg(drive, &cmd);
|
|
|
|
|
2009-03-27 19:46:46 +08:00
|
|
|
return ide_tape_issue_pc(drive, &cmd, pc);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Write a filemark if write_filemark=1. Flush the device buffers without
|
|
|
|
* writing a filemark otherwise.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2008-02-06 09:57:54 +08:00
|
|
|
static void idetape_create_write_filemark_cmd(ide_drive_t *drive,
|
2008-04-18 06:46:27 +08:00
|
|
|
struct ide_atapi_pc *pc, int write_filemark)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-11 04:39:37 +08:00
|
|
|
ide_init_pc(pc);
|
2008-02-03 02:56:50 +08:00
|
|
|
pc->c[0] = WRITE_FILEMARKS;
|
2005-04-17 06:20:36 +08:00
|
|
|
pc->c[4] = write_filemark;
|
2008-04-18 06:46:26 +08:00
|
|
|
pc->flags |= PC_FLAG_WAIT_FOR_DSC;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
|
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-10-11 04:39:38 +08:00
|
|
|
struct gendisk *disk = tape->disk;
|
2005-04-17 06:20:36 +08:00
|
|
|
int load_attempted = 0;
|
|
|
|
|
2008-02-06 09:57:53 +08:00
|
|
|
/* Wait for the tape to become ready */
|
2009-06-07 21:37:06 +08:00
|
|
|
set_bit(ilog2(IDE_AFLAG_MEDIUM_PRESENT), &drive->atapi_flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
timeout += jiffies;
|
|
|
|
while (time_before(jiffies, timeout)) {
|
2008-10-11 04:39:39 +08:00
|
|
|
if (ide_do_test_unit_ready(drive, disk) == 0)
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2)
|
2008-02-06 09:57:53 +08:00
|
|
|
|| (tape->asc == 0x3A)) {
|
|
|
|
/* no media */
|
2005-04-17 06:20:36 +08:00
|
|
|
if (load_attempted)
|
|
|
|
return -ENOMEDIUM;
|
2008-10-11 04:39:39 +08:00
|
|
|
ide_do_start_stop(drive, disk, IDETAPE_LU_LOAD_MASK);
|
2005-04-17 06:20:36 +08:00
|
|
|
load_attempted = 1;
|
|
|
|
/* not about to be ready */
|
|
|
|
} else if (!(tape->sense_key == 2 && tape->asc == 4 &&
|
|
|
|
(tape->ascq == 1 || tape->ascq == 8)))
|
|
|
|
return -EIO;
|
2005-09-10 15:27:08 +08:00
|
|
|
msleep(100);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:54 +08:00
|
|
|
static int idetape_flush_tape_buffers(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-11 04:39:38 +08:00
|
|
|
struct ide_tape_obj *tape = drive->driver_data;
|
2008-04-18 06:46:27 +08:00
|
|
|
struct ide_atapi_pc pc;
|
2005-04-17 06:20:36 +08:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
idetape_create_write_filemark_cmd(drive, &pc, 0);
|
2009-05-02 16:26:12 +08:00
|
|
|
rc = ide_queue_pc_tail(drive, tape->disk, &pc, NULL, 0);
|
2008-02-06 09:57:54 +08:00
|
|
|
if (rc)
|
2005-04-17 06:20:36 +08:00
|
|
|
return rc;
|
|
|
|
idetape_wait_ready(drive, 60 * 5 * HZ);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-04 15:38:15 +08:00
|
|
|
static int ide_tape_read_position(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-04-18 06:46:27 +08:00
|
|
|
struct ide_atapi_pc pc;
|
2009-05-04 15:38:15 +08:00
|
|
|
u8 buf[20];
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "enter");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-05-04 15:38:15 +08:00
|
|
|
/* prep cmd */
|
|
|
|
ide_init_pc(&pc);
|
|
|
|
pc.c[0] = READ_POSITION;
|
|
|
|
pc.req_xfer = 20;
|
|
|
|
|
|
|
|
if (ide_queue_pc_tail(drive, tape->disk, &pc, buf, pc.req_xfer))
|
2005-04-17 06:20:36 +08:00
|
|
|
return -1;
|
2009-05-04 15:38:15 +08:00
|
|
|
|
|
|
|
if (!pc.error) {
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "BOP - %s",
|
2009-05-04 15:38:15 +08:00
|
|
|
(buf[0] & 0x80) ? "Yes" : "No");
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "EOP - %s",
|
2009-05-04 15:38:15 +08:00
|
|
|
(buf[0] & 0x40) ? "Yes" : "No");
|
|
|
|
|
|
|
|
if (buf[0] & 0x4) {
|
|
|
|
printk(KERN_INFO "ide-tape: Block location is unknown"
|
|
|
|
"to the tape\n");
|
2009-06-13 18:00:54 +08:00
|
|
|
clear_bit(ilog2(IDE_AFLAG_ADDRESS_VALID),
|
|
|
|
&drive->atapi_flags);
|
2009-05-04 15:38:15 +08:00
|
|
|
return -1;
|
|
|
|
} else {
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "Block Location: %u",
|
|
|
|
be32_to_cpup((__be32 *)&buf[4]));
|
2009-05-04 15:38:15 +08:00
|
|
|
|
|
|
|
tape->partition = buf[1];
|
|
|
|
tape->first_frame = be32_to_cpup((__be32 *)&buf[4]);
|
2009-06-13 18:00:54 +08:00
|
|
|
set_bit(ilog2(IDE_AFLAG_ADDRESS_VALID),
|
|
|
|
&drive->atapi_flags);
|
2009-05-04 15:38:15 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return tape->first_frame;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-04-18 06:46:27 +08:00
|
|
|
static void idetape_create_locate_cmd(ide_drive_t *drive,
|
|
|
|
struct ide_atapi_pc *pc,
|
2008-02-06 09:57:54 +08:00
|
|
|
unsigned int block, u8 partition, int skip)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-11 04:39:37 +08:00
|
|
|
ide_init_pc(pc);
|
2008-02-03 02:56:50 +08:00
|
|
|
pc->c[0] = POSITION_TO_ELEMENT;
|
2005-04-17 06:20:36 +08:00
|
|
|
pc->c[1] = 2;
|
2008-02-03 02:56:50 +08:00
|
|
|
put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[3]);
|
2005-04-17 06:20:36 +08:00
|
|
|
pc->c[8] = partition;
|
2008-04-18 06:46:26 +08:00
|
|
|
pc->flags |= PC_FLAG_WAIT_FOR_DSC;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-04-27 21:38:34 +08:00
|
|
|
static void __ide_tape_discard_merge_buffer(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
|
|
|
|
2008-02-06 09:57:52 +08:00
|
|
|
if (tape->chrdev_dir != IDETAPE_DIR_READ)
|
2008-04-27 21:38:34 +08:00
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-06-07 21:37:06 +08:00
|
|
|
clear_bit(ilog2(IDE_AFLAG_FILEMARK), &drive->atapi_flags);
|
2009-04-19 07:46:02 +08:00
|
|
|
tape->valid = 0;
|
|
|
|
if (tape->buf != NULL) {
|
|
|
|
kfree(tape->buf);
|
|
|
|
tape->buf = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:52 +08:00
|
|
|
tape->chrdev_dir = IDETAPE_DIR_NONE;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Position the tape to the requested block using the LOCATE packet command.
|
|
|
|
* A READ POSITION command is then issued to check where we are positioned. Like
|
|
|
|
* all higher level operations, we queue the commands at the tail of the request
|
|
|
|
* queue and wait for their completion.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2008-02-06 09:57:54 +08:00
|
|
|
static int idetape_position_tape(ide_drive_t *drive, unsigned int block,
|
|
|
|
u8 partition, int skip)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-10-11 04:39:38 +08:00
|
|
|
struct gendisk *disk = tape->disk;
|
2009-05-04 15:38:15 +08:00
|
|
|
int ret;
|
2008-04-18 06:46:27 +08:00
|
|
|
struct ide_atapi_pc pc;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-06 09:57:52 +08:00
|
|
|
if (tape->chrdev_dir == IDETAPE_DIR_READ)
|
2008-04-27 21:38:34 +08:00
|
|
|
__ide_tape_discard_merge_buffer(drive);
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_wait_ready(drive, 60 * 5 * HZ);
|
|
|
|
idetape_create_locate_cmd(drive, &pc, block, partition, skip);
|
2009-05-04 15:38:15 +08:00
|
|
|
ret = ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-05-04 15:38:15 +08:00
|
|
|
ret = ide_tape_read_position(drive);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-04-27 21:38:34 +08:00
|
|
|
static void ide_tape_discard_merge_buffer(ide_drive_t *drive,
|
2008-02-06 09:57:54 +08:00
|
|
|
int restore_position)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
|
|
|
int seek, position;
|
|
|
|
|
2008-04-27 21:38:34 +08:00
|
|
|
__ide_tape_discard_merge_buffer(drive);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (restore_position) {
|
2009-05-04 15:38:15 +08:00
|
|
|
position = ide_tape_read_position(drive);
|
2008-04-27 21:38:34 +08:00
|
|
|
seek = position > 0 ? position : 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (idetape_position_tape(drive, seek, 0, 0)) {
|
2008-02-06 09:57:54 +08:00
|
|
|
printk(KERN_INFO "ide-tape: %s: position_tape failed in"
|
2008-04-27 21:38:34 +08:00
|
|
|
" %s\n", tape->name, __func__);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Generate a read/write request for the block device interface and wait for it
|
|
|
|
* to be serviced.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2009-04-19 07:46:03 +08:00
|
|
|
static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int size)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-07-16 03:21:43 +08:00
|
|
|
struct request *rq;
|
2009-04-19 07:46:02 +08:00
|
|
|
int ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "cmd: 0x%x, size: %d", cmd, size);
|
|
|
|
|
2009-04-19 07:46:02 +08:00
|
|
|
BUG_ON(cmd != REQ_IDETAPE_READ && cmd != REQ_IDETAPE_WRITE);
|
2009-04-19 07:46:03 +08:00
|
|
|
BUG_ON(size < 0 || size % tape->blk_size);
|
2008-02-06 09:57:51 +08:00
|
|
|
|
2018-05-09 15:54:05 +08:00
|
|
|
rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0);
|
2017-01-31 23:57:30 +08:00
|
|
|
ide_req(rq)->type = ATA_PRIV_MISC;
|
2017-01-27 16:46:29 +08:00
|
|
|
scsi_req(rq)->cmd[13] = cmd;
|
2008-07-16 03:21:43 +08:00
|
|
|
rq->rq_disk = tape->disk;
|
2009-06-12 01:52:27 +08:00
|
|
|
rq->__sector = tape->first_frame;
|
2009-04-19 07:46:02 +08:00
|
|
|
|
|
|
|
if (size) {
|
2009-04-19 07:46:02 +08:00
|
|
|
ret = blk_rq_map_kern(drive->queue, rq, tape->buf, size,
|
2018-05-09 15:54:08 +08:00
|
|
|
GFP_NOIO);
|
2009-04-19 07:46:02 +08:00
|
|
|
if (ret)
|
|
|
|
goto out_put;
|
|
|
|
}
|
|
|
|
|
2008-07-16 03:21:43 +08:00
|
|
|
blk_execute_rq(drive->queue, tape->disk, rq, 0);
|
|
|
|
|
2009-04-19 07:46:02 +08:00
|
|
|
/* calculate the number of transferred bytes and update buffer state */
|
2017-01-27 16:46:29 +08:00
|
|
|
size -= scsi_req(rq)->resid_len;
|
2009-04-19 07:46:02 +08:00
|
|
|
tape->cur = tape->buf;
|
2009-04-19 07:46:02 +08:00
|
|
|
if (cmd == REQ_IDETAPE_READ)
|
2009-04-19 07:46:02 +08:00
|
|
|
tape->valid = size;
|
|
|
|
else
|
|
|
|
tape->valid = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-04-19 07:46:02 +08:00
|
|
|
ret = size;
|
2017-04-20 22:03:01 +08:00
|
|
|
if (scsi_req(rq)->result == IDE_DRV_ERROR_GENERAL)
|
2009-04-19 07:46:02 +08:00
|
|
|
ret = -EIO;
|
|
|
|
out_put:
|
|
|
|
blk_put_request(rq);
|
2008-07-16 03:21:43 +08:00
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-04-18 06:46:27 +08:00
|
|
|
static void idetape_create_inquiry_cmd(struct ide_atapi_pc *pc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-11 04:39:37 +08:00
|
|
|
ide_init_pc(pc);
|
2008-02-03 02:56:50 +08:00
|
|
|
pc->c[0] = INQUIRY;
|
2008-02-06 09:57:54 +08:00
|
|
|
pc->c[4] = 254;
|
2008-04-18 06:46:27 +08:00
|
|
|
pc->req_xfer = 254;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-04-18 06:46:27 +08:00
|
|
|
static void idetape_create_rewind_cmd(ide_drive_t *drive,
|
|
|
|
struct ide_atapi_pc *pc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-11 04:39:37 +08:00
|
|
|
ide_init_pc(pc);
|
2008-02-03 02:56:50 +08:00
|
|
|
pc->c[0] = REZERO_UNIT;
|
2008-04-18 06:46:26 +08:00
|
|
|
pc->flags |= PC_FLAG_WAIT_FOR_DSC;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-04-18 06:46:27 +08:00
|
|
|
static void idetape_create_erase_cmd(struct ide_atapi_pc *pc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-11 04:39:37 +08:00
|
|
|
ide_init_pc(pc);
|
2008-02-03 02:56:50 +08:00
|
|
|
pc->c[0] = ERASE;
|
2005-04-17 06:20:36 +08:00
|
|
|
pc->c[1] = 1;
|
2008-04-18 06:46:26 +08:00
|
|
|
pc->flags |= PC_FLAG_WAIT_FOR_DSC;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-04-18 06:46:27 +08:00
|
|
|
static void idetape_create_space_cmd(struct ide_atapi_pc *pc, int count, u8 cmd)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-11 04:39:37 +08:00
|
|
|
ide_init_pc(pc);
|
2008-02-03 02:56:50 +08:00
|
|
|
pc->c[0] = SPACE;
|
2008-02-03 02:56:50 +08:00
|
|
|
put_unaligned(cpu_to_be32(count), (unsigned int *) &pc->c[1]);
|
2005-04-17 06:20:36 +08:00
|
|
|
pc->c[1] = cmd;
|
2008-04-18 06:46:26 +08:00
|
|
|
pc->flags |= PC_FLAG_WAIT_FOR_DSC;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-04-27 21:38:34 +08:00
|
|
|
static void ide_tape_flush_merge_buffer(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-02-03 02:56:49 +08:00
|
|
|
|
2008-02-06 09:57:52 +08:00
|
|
|
if (tape->chrdev_dir != IDETAPE_DIR_WRITE) {
|
2008-04-27 21:38:34 +08:00
|
|
|
printk(KERN_ERR "ide-tape: bug: Trying to empty merge buffer"
|
2008-02-06 09:57:54 +08:00
|
|
|
" but we are not writing.\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-04-19 07:46:02 +08:00
|
|
|
if (tape->buf) {
|
2009-04-19 07:46:03 +08:00
|
|
|
size_t aligned = roundup(tape->valid, tape->blk_size);
|
|
|
|
|
|
|
|
memset(tape->cur, 0, aligned - tape->valid);
|
2009-04-19 07:46:03 +08:00
|
|
|
idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, aligned);
|
2009-04-19 07:46:02 +08:00
|
|
|
kfree(tape->buf);
|
|
|
|
tape->buf = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-02-06 09:57:52 +08:00
|
|
|
tape->chrdev_dir = IDETAPE_DIR_NONE;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-04-19 07:46:02 +08:00
|
|
|
static int idetape_init_rw(ide_drive_t *drive, int dir)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2009-04-19 07:46:02 +08:00
|
|
|
int rc;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-04-19 07:46:02 +08:00
|
|
|
BUG_ON(dir != IDETAPE_DIR_READ && dir != IDETAPE_DIR_WRITE);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-04-19 07:46:02 +08:00
|
|
|
if (tape->chrdev_dir == dir)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (tape->chrdev_dir == IDETAPE_DIR_READ)
|
|
|
|
ide_tape_discard_merge_buffer(drive, 1);
|
|
|
|
else if (tape->chrdev_dir == IDETAPE_DIR_WRITE) {
|
|
|
|
ide_tape_flush_merge_buffer(drive);
|
|
|
|
idetape_flush_tape_buffers(drive);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tape->buf || tape->valid) {
|
|
|
|
printk(KERN_ERR "ide-tape: valid should be 0 now\n");
|
|
|
|
tape->valid = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
tape->buf = kmalloc(tape->buffer_size, GFP_KERNEL);
|
|
|
|
if (!tape->buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
tape->chrdev_dir = dir;
|
|
|
|
tape->cur = tape->buf;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Issue a 0 rw command to ensure that DSC handshake is
|
|
|
|
* switched from completion mode to buffer available mode. No
|
|
|
|
* point in issuing this if DSC overlap isn't supported, some
|
|
|
|
* drives (Seagate STT3401A) will return an error.
|
|
|
|
*/
|
|
|
|
if (drive->dev_flags & IDE_DFLAG_DSC_OVERLAP) {
|
|
|
|
int cmd = dir == IDETAPE_DIR_READ ? REQ_IDETAPE_READ
|
|
|
|
: REQ_IDETAPE_WRITE;
|
|
|
|
|
|
|
|
rc = idetape_queue_rw_tail(drive, cmd, 0);
|
|
|
|
if (rc < 0) {
|
|
|
|
kfree(tape->buf);
|
|
|
|
tape->buf = NULL;
|
|
|
|
tape->chrdev_dir = IDETAPE_DIR_NONE;
|
|
|
|
return rc;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
2008-04-27 21:38:25 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:54 +08:00
|
|
|
static void idetape_pad_zeros(ide_drive_t *drive, int bcount)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2009-04-19 07:46:02 +08:00
|
|
|
|
|
|
|
memset(tape->buf, 0, tape->buffer_size);
|
2008-02-06 09:57:53 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
while (bcount) {
|
2009-04-19 07:46:02 +08:00
|
|
|
unsigned int count = min(tape->buffer_size, bcount);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-04-19 07:46:03 +08:00
|
|
|
idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, count);
|
2005-04-17 06:20:36 +08:00
|
|
|
bcount -= count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Rewinds the tape to the Beginning Of the current Partition (BOP). We
|
|
|
|
* currently support only one partition.
|
|
|
|
*/
|
2008-02-06 09:57:54 +08:00
|
|
|
static int idetape_rewind_tape(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-11 04:39:38 +08:00
|
|
|
struct ide_tape_obj *tape = drive->driver_data;
|
|
|
|
struct gendisk *disk = tape->disk;
|
2008-04-18 06:46:27 +08:00
|
|
|
struct ide_atapi_pc pc;
|
2009-05-04 15:38:15 +08:00
|
|
|
int ret;
|
2008-02-06 09:57:51 +08:00
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "enter");
|
2008-02-06 09:57:51 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_create_rewind_cmd(drive, &pc);
|
2009-05-04 15:38:15 +08:00
|
|
|
ret = ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-05-04 15:38:15 +08:00
|
|
|
ret = ide_tape_read_position(drive);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:53 +08:00
|
|
|
/* mtio.h compatible commands should be issued to the chrdev interface. */
|
2008-02-06 09:57:54 +08:00
|
|
|
static int idetape_blkdev_ioctl(ide_drive_t *drive, unsigned int cmd,
|
|
|
|
unsigned long arg)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
|
|
|
void __user *argp = (void __user *)arg;
|
|
|
|
|
2008-02-03 02:56:51 +08:00
|
|
|
struct idetape_config {
|
|
|
|
int dsc_rw_frequency;
|
|
|
|
int dsc_media_access_frequency;
|
|
|
|
int nr_stages;
|
|
|
|
} config;
|
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "cmd: 0x%04x", cmd);
|
2008-02-06 09:57:51 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (cmd) {
|
2008-02-06 09:57:54 +08:00
|
|
|
case 0x0340:
|
|
|
|
if (copy_from_user(&config, argp, sizeof(config)))
|
|
|
|
return -EFAULT;
|
|
|
|
tape->best_dsc_rw_freq = config.dsc_rw_frequency;
|
|
|
|
break;
|
|
|
|
case 0x0350:
|
2009-07-19 17:15:19 +08:00
|
|
|
memset(&config, 0, sizeof(config));
|
2008-02-06 09:57:54 +08:00
|
|
|
config.dsc_rw_frequency = (int) tape->best_dsc_rw_freq;
|
2008-04-27 21:38:27 +08:00
|
|
|
config.nr_stages = 1;
|
2008-02-06 09:57:54 +08:00
|
|
|
if (copy_to_user(argp, &config, sizeof(config)))
|
|
|
|
return -EFAULT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EIO;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:54 +08:00
|
|
|
static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op,
|
|
|
|
int mt_count)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-10-11 04:39:38 +08:00
|
|
|
struct gendisk *disk = tape->disk;
|
2008-04-18 06:46:27 +08:00
|
|
|
struct ide_atapi_pc pc;
|
2008-02-06 09:57:54 +08:00
|
|
|
int retval, count = 0;
|
2008-02-03 02:56:49 +08:00
|
|
|
int sprev = !!(tape->caps[4] & 0x20);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
|
|
|
|
ide_debug_log(IDE_DBG_FUNC, "mt_op: %d, mt_count: %d", mt_op, mt_count);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (mt_count == 0)
|
|
|
|
return 0;
|
|
|
|
if (MTBSF == mt_op || MTBSFM == mt_op) {
|
2008-02-03 02:56:49 +08:00
|
|
|
if (!sprev)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EIO;
|
2008-02-06 09:57:54 +08:00
|
|
|
mt_count = -mt_count;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:52 +08:00
|
|
|
if (tape->chrdev_dir == IDETAPE_DIR_READ) {
|
2009-04-19 07:46:02 +08:00
|
|
|
tape->valid = 0;
|
2009-06-07 21:37:06 +08:00
|
|
|
if (test_and_clear_bit(ilog2(IDE_AFLAG_FILEMARK),
|
|
|
|
&drive->atapi_flags))
|
2005-04-17 06:20:36 +08:00
|
|
|
++count;
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_discard_merge_buffer(drive, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (mt_op) {
|
2008-02-06 09:57:54 +08:00
|
|
|
case MTFSF:
|
|
|
|
case MTBSF:
|
|
|
|
idetape_create_space_cmd(&pc, mt_count - count,
|
|
|
|
IDETAPE_SPACE_OVER_FILEMARK);
|
2009-05-02 16:26:12 +08:00
|
|
|
return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
|
2008-02-06 09:57:54 +08:00
|
|
|
case MTFSFM:
|
|
|
|
case MTBSFM:
|
|
|
|
if (!sprev)
|
|
|
|
return -EIO;
|
|
|
|
retval = idetape_space_over_filemarks(drive, MTFSF,
|
|
|
|
mt_count - count);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
count = (MTBSFM == mt_op ? 1 : -1);
|
|
|
|
return idetape_space_over_filemarks(drive, MTFSF, count);
|
|
|
|
default:
|
|
|
|
printk(KERN_ERR "ide-tape: MTIO operation %d not supported\n",
|
|
|
|
mt_op);
|
|
|
|
return -EIO;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Our character device read / write functions.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* The tape is optimized to maximize throughput when it is transferring an
|
|
|
|
* integral number of the "continuous transfer limit", which is a parameter of
|
|
|
|
* the specific tape (26kB on my particular tape, 32kB for Onstream).
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* As of version 1.3 of the driver, the character device provides an abstract
|
|
|
|
* continuous view of the media - any mix of block sizes (even 1 byte) on the
|
|
|
|
* same backup/restore procedure is supported. The driver will internally
|
|
|
|
* convert the requests to the recommended transfer unit, so that an unmatch
|
|
|
|
* between the user's block size to the recommended size will only result in a
|
|
|
|
* (slightly) increased driver overhead, but will no longer hit performance.
|
|
|
|
* This is not applicable to Onstream.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2008-02-06 09:57:54 +08:00
|
|
|
static ssize_t idetape_chrdev_read(struct file *file, char __user *buf,
|
|
|
|
size_t count, loff_t *ppos)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-14 03:39:34 +08:00
|
|
|
struct ide_tape_obj *tape = file->private_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
ide_drive_t *drive = tape->drive;
|
2009-04-19 07:46:03 +08:00
|
|
|
size_t done = 0;
|
2006-06-25 20:47:37 +08:00
|
|
|
ssize_t ret = 0;
|
2009-04-19 07:46:03 +08:00
|
|
|
int rc;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-02-28 06:30:02 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "count %zd", count);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-06 09:57:52 +08:00
|
|
|
if (tape->chrdev_dir != IDETAPE_DIR_READ) {
|
2009-06-07 21:37:06 +08:00
|
|
|
if (test_bit(ilog2(IDE_AFLAG_DETECT_BS), &drive->atapi_flags))
|
2008-02-06 09:57:52 +08:00
|
|
|
if (count > tape->blk_size &&
|
|
|
|
(count % tape->blk_size) == 0)
|
|
|
|
tape->user_bs_factor = count / tape->blk_size;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-04-19 07:46:03 +08:00
|
|
|
|
2009-04-19 07:46:02 +08:00
|
|
|
rc = idetape_init_rw(drive, IDETAPE_DIR_READ);
|
2008-02-06 09:57:53 +08:00
|
|
|
if (rc < 0)
|
2005-04-17 06:20:36 +08:00
|
|
|
return rc;
|
2009-04-19 07:46:03 +08:00
|
|
|
|
|
|
|
while (done < count) {
|
|
|
|
size_t todo;
|
|
|
|
|
|
|
|
/* refill if staging buffer is empty */
|
|
|
|
if (!tape->valid) {
|
|
|
|
/* If we are at a filemark, nothing more to read */
|
2009-06-07 21:37:06 +08:00
|
|
|
if (test_bit(ilog2(IDE_AFLAG_FILEMARK),
|
|
|
|
&drive->atapi_flags))
|
2009-04-19 07:46:03 +08:00
|
|
|
break;
|
|
|
|
/* read */
|
|
|
|
if (idetape_queue_rw_tail(drive, REQ_IDETAPE_READ,
|
|
|
|
tape->buffer_size) <= 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* copy out */
|
|
|
|
todo = min_t(size_t, count - done, tape->valid);
|
|
|
|
if (copy_to_user(buf + done, tape->cur, todo))
|
2006-06-25 20:47:37 +08:00
|
|
|
ret = -EFAULT;
|
2009-04-19 07:46:03 +08:00
|
|
|
|
|
|
|
tape->cur += todo;
|
|
|
|
tape->valid -= todo;
|
|
|
|
done += todo;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-04-19 07:46:03 +08:00
|
|
|
|
2009-06-07 21:37:06 +08:00
|
|
|
if (!done && test_bit(ilog2(IDE_AFLAG_FILEMARK), &drive->atapi_flags)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_space_over_filemarks(drive, MTFSF, 1);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-06-25 20:47:37 +08:00
|
|
|
|
2009-04-19 07:46:03 +08:00
|
|
|
return ret ? ret : done;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:54 +08:00
|
|
|
static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf,
|
2005-04-17 06:20:36 +08:00
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
2008-10-14 03:39:34 +08:00
|
|
|
struct ide_tape_obj *tape = file->private_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
ide_drive_t *drive = tape->drive;
|
2009-04-19 07:46:03 +08:00
|
|
|
size_t done = 0;
|
2006-06-25 20:47:37 +08:00
|
|
|
ssize_t ret = 0;
|
2009-04-19 07:46:02 +08:00
|
|
|
int rc;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* The drive is write protected. */
|
|
|
|
if (tape->write_prot)
|
|
|
|
return -EACCES;
|
|
|
|
|
2017-02-28 06:30:02 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "count %zd", count);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Initialize write operation */
|
2009-04-19 07:46:02 +08:00
|
|
|
rc = idetape_init_rw(drive, IDETAPE_DIR_WRITE);
|
|
|
|
if (rc < 0)
|
|
|
|
return rc;
|
2009-04-19 07:46:03 +08:00
|
|
|
|
|
|
|
while (done < count) {
|
|
|
|
size_t todo;
|
|
|
|
|
|
|
|
/* flush if staging buffer is full */
|
|
|
|
if (tape->valid == tape->buffer_size &&
|
|
|
|
idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE,
|
|
|
|
tape->buffer_size) <= 0)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
/* copy in */
|
|
|
|
todo = min_t(size_t, count - done,
|
|
|
|
tape->buffer_size - tape->valid);
|
|
|
|
if (copy_from_user(tape->cur, buf + done, todo))
|
2006-06-25 20:47:37 +08:00
|
|
|
ret = -EFAULT;
|
2009-04-19 07:46:03 +08:00
|
|
|
|
|
|
|
tape->cur += todo;
|
|
|
|
tape->valid += todo;
|
|
|
|
done += todo;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-04-19 07:46:03 +08:00
|
|
|
|
|
|
|
return ret ? ret : done;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:54 +08:00
|
|
|
static int idetape_write_filemark(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-11 04:39:38 +08:00
|
|
|
struct ide_tape_obj *tape = drive->driver_data;
|
2008-04-18 06:46:27 +08:00
|
|
|
struct ide_atapi_pc pc;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Write a filemark */
|
|
|
|
idetape_create_write_filemark_cmd(drive, &pc, 1);
|
2009-05-02 16:26:12 +08:00
|
|
|
if (ide_queue_pc_tail(drive, tape->disk, &pc, NULL, 0)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
printk(KERN_ERR "ide-tape: Couldn't write a filemark\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-02-03 02:56:51 +08:00
|
|
|
* Called from idetape_chrdev_ioctl when the general mtio MTIOCTOP ioctl is
|
|
|
|
* requested.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-03 02:56:51 +08:00
|
|
|
* Note: MTBSF and MTBSFM are not supported when the tape doesn't support
|
|
|
|
* spacing over filemarks in the reverse direction. In this case, MTFSFM is also
|
2008-04-27 21:38:28 +08:00
|
|
|
* usually not supported.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-03 02:56:51 +08:00
|
|
|
* The following commands are currently not supported:
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-03 02:56:51 +08:00
|
|
|
* MTFSS, MTBSS, MTWSM, MTSETDENSITY, MTSETDRVBUFFER, MT_ST_BOOLEANS,
|
|
|
|
* MT_ST_WRITE_THRESHOLD.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2008-02-03 02:56:51 +08:00
|
|
|
static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-10-11 04:39:38 +08:00
|
|
|
struct gendisk *disk = tape->disk;
|
2008-04-18 06:46:27 +08:00
|
|
|
struct ide_atapi_pc pc;
|
2008-02-06 09:57:54 +08:00
|
|
|
int i, retval;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "MTIOCTOP ioctl: mt_op: %d, mt_count: %d",
|
|
|
|
mt_op, mt_count);
|
2008-02-06 09:57:54 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (mt_op) {
|
2008-02-06 09:57:54 +08:00
|
|
|
case MTFSF:
|
|
|
|
case MTFSFM:
|
|
|
|
case MTBSF:
|
|
|
|
case MTBSFM:
|
|
|
|
if (!mt_count)
|
|
|
|
return 0;
|
|
|
|
return idetape_space_over_filemarks(drive, mt_op, mt_count);
|
|
|
|
default:
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-02-06 09:57:54 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (mt_op) {
|
2008-02-06 09:57:54 +08:00
|
|
|
case MTWEOF:
|
|
|
|
if (tape->write_prot)
|
|
|
|
return -EACCES;
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_discard_merge_buffer(drive, 1);
|
2008-02-06 09:57:54 +08:00
|
|
|
for (i = 0; i < mt_count; i++) {
|
|
|
|
retval = idetape_write_filemark(drive);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
case MTREW:
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_discard_merge_buffer(drive, 0);
|
2008-02-06 09:57:54 +08:00
|
|
|
if (idetape_rewind_tape(drive))
|
|
|
|
return -EIO;
|
|
|
|
return 0;
|
|
|
|
case MTLOAD:
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_discard_merge_buffer(drive, 0);
|
2008-10-11 04:39:39 +08:00
|
|
|
return ide_do_start_stop(drive, disk, IDETAPE_LU_LOAD_MASK);
|
2008-02-06 09:57:54 +08:00
|
|
|
case MTUNLOAD:
|
|
|
|
case MTOFFL:
|
|
|
|
/*
|
|
|
|
* If door is locked, attempt to unlock before
|
|
|
|
* attempting to eject.
|
|
|
|
*/
|
|
|
|
if (tape->door_locked) {
|
2008-10-11 04:39:38 +08:00
|
|
|
if (!ide_set_media_lock(drive, disk, 0))
|
2008-10-11 04:39:37 +08:00
|
|
|
tape->door_locked = DOOR_UNLOCKED;
|
2008-02-06 09:57:54 +08:00
|
|
|
}
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_discard_merge_buffer(drive, 0);
|
2008-10-11 04:39:39 +08:00
|
|
|
retval = ide_do_start_stop(drive, disk, !IDETAPE_LU_LOAD_MASK);
|
2008-02-06 09:57:54 +08:00
|
|
|
if (!retval)
|
2009-06-07 21:37:06 +08:00
|
|
|
clear_bit(ilog2(IDE_AFLAG_MEDIUM_PRESENT),
|
|
|
|
&drive->atapi_flags);
|
2008-02-06 09:57:54 +08:00
|
|
|
return retval;
|
|
|
|
case MTNOP:
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_discard_merge_buffer(drive, 0);
|
2008-02-06 09:57:54 +08:00
|
|
|
return idetape_flush_tape_buffers(drive);
|
|
|
|
case MTRETEN:
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_discard_merge_buffer(drive, 0);
|
2008-10-11 04:39:39 +08:00
|
|
|
return ide_do_start_stop(drive, disk,
|
2008-02-06 09:57:54 +08:00
|
|
|
IDETAPE_LU_RETENSION_MASK | IDETAPE_LU_LOAD_MASK);
|
|
|
|
case MTEOM:
|
|
|
|
idetape_create_space_cmd(&pc, 0, IDETAPE_SPACE_TO_EOD);
|
2009-05-02 16:26:12 +08:00
|
|
|
return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
|
2008-02-06 09:57:54 +08:00
|
|
|
case MTERASE:
|
|
|
|
(void)idetape_rewind_tape(drive);
|
|
|
|
idetape_create_erase_cmd(&pc);
|
2009-05-02 16:26:12 +08:00
|
|
|
return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
|
2008-02-06 09:57:54 +08:00
|
|
|
case MTSETBLK:
|
|
|
|
if (mt_count) {
|
|
|
|
if (mt_count < tape->blk_size ||
|
|
|
|
mt_count % tape->blk_size)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EIO;
|
2008-02-06 09:57:54 +08:00
|
|
|
tape->user_bs_factor = mt_count / tape->blk_size;
|
2009-06-07 21:37:06 +08:00
|
|
|
clear_bit(ilog2(IDE_AFLAG_DETECT_BS),
|
|
|
|
&drive->atapi_flags);
|
2008-02-06 09:57:54 +08:00
|
|
|
} else
|
2009-06-07 21:37:06 +08:00
|
|
|
set_bit(ilog2(IDE_AFLAG_DETECT_BS),
|
|
|
|
&drive->atapi_flags);
|
2008-02-06 09:57:54 +08:00
|
|
|
return 0;
|
|
|
|
case MTSEEK:
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_discard_merge_buffer(drive, 0);
|
2008-02-06 09:57:54 +08:00
|
|
|
return idetape_position_tape(drive,
|
|
|
|
mt_count * tape->user_bs_factor, tape->partition, 0);
|
|
|
|
case MTSETPART:
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_discard_merge_buffer(drive, 0);
|
2008-02-06 09:57:54 +08:00
|
|
|
return idetape_position_tape(drive, 0, mt_count, 0);
|
|
|
|
case MTFSR:
|
|
|
|
case MTBSR:
|
|
|
|
case MTLOCK:
|
2008-10-11 04:39:38 +08:00
|
|
|
retval = ide_set_media_lock(drive, disk, 1);
|
2008-02-06 09:57:54 +08:00
|
|
|
if (retval)
|
2005-04-17 06:20:36 +08:00
|
|
|
return retval;
|
2008-02-06 09:57:54 +08:00
|
|
|
tape->door_locked = DOOR_EXPLICITLY_LOCKED;
|
|
|
|
return 0;
|
|
|
|
case MTUNLOCK:
|
2008-10-11 04:39:38 +08:00
|
|
|
retval = ide_set_media_lock(drive, disk, 0);
|
2008-02-06 09:57:54 +08:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
tape->door_locked = DOOR_UNLOCKED;
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
printk(KERN_ERR "ide-tape: MTIO operation %d not supported\n",
|
|
|
|
mt_op);
|
|
|
|
return -EIO;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-02-03 02:56:51 +08:00
|
|
|
* Our character device ioctls. General mtio.h magnetic io commands are
|
|
|
|
* supported here, and not in the corresponding block interface. Our own
|
|
|
|
* ide-tape ioctls are supported on both interfaces.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2010-01-04 14:24:00 +08:00
|
|
|
static long do_idetape_chrdev_ioctl(struct file *file,
|
2008-02-03 02:56:51 +08:00
|
|
|
unsigned int cmd, unsigned long arg)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-14 03:39:34 +08:00
|
|
|
struct ide_tape_obj *tape = file->private_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
ide_drive_t *drive = tape->drive;
|
|
|
|
struct mtop mtop;
|
|
|
|
struct mtget mtget;
|
|
|
|
struct mtpos mtpos;
|
2008-02-06 09:57:52 +08:00
|
|
|
int block_offset = 0, position = tape->first_frame;
|
2005-04-17 06:20:36 +08:00
|
|
|
void __user *argp = (void __user *)arg;
|
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "cmd: 0x%x", cmd);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-06 09:57:52 +08:00
|
|
|
if (tape->chrdev_dir == IDETAPE_DIR_WRITE) {
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_flush_merge_buffer(drive);
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_flush_tape_buffers(drive);
|
|
|
|
}
|
|
|
|
if (cmd == MTIOCGET || cmd == MTIOCPOS) {
|
2009-04-19 07:46:02 +08:00
|
|
|
block_offset = tape->valid /
|
2008-02-06 09:57:52 +08:00
|
|
|
(tape->blk_size * tape->user_bs_factor);
|
2009-05-04 15:38:15 +08:00
|
|
|
position = ide_tape_read_position(drive);
|
2008-02-06 09:57:54 +08:00
|
|
|
if (position < 0)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
switch (cmd) {
|
2008-02-06 09:57:54 +08:00
|
|
|
case MTIOCTOP:
|
|
|
|
if (copy_from_user(&mtop, argp, sizeof(struct mtop)))
|
|
|
|
return -EFAULT;
|
|
|
|
return idetape_mtioctop(drive, mtop.mt_op, mtop.mt_count);
|
|
|
|
case MTIOCGET:
|
|
|
|
memset(&mtget, 0, sizeof(struct mtget));
|
|
|
|
mtget.mt_type = MT_ISSCSI2;
|
|
|
|
mtget.mt_blkno = position / tape->user_bs_factor - block_offset;
|
|
|
|
mtget.mt_dsreg =
|
|
|
|
((tape->blk_size * tape->user_bs_factor)
|
|
|
|
<< MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK;
|
|
|
|
|
|
|
|
if (tape->drv_write_prot)
|
|
|
|
mtget.mt_gstat |= GMT_WR_PROT(0xffffffff);
|
|
|
|
|
2018-09-07 22:49:43 +08:00
|
|
|
return put_user_mtget(argp, &mtget);
|
2008-02-06 09:57:54 +08:00
|
|
|
case MTIOCPOS:
|
|
|
|
mtpos.mt_blkno = position / tape->user_bs_factor - block_offset;
|
2018-09-07 22:49:43 +08:00
|
|
|
return put_user_mtpos(argp, &mtpos);
|
2008-02-06 09:57:54 +08:00
|
|
|
default:
|
|
|
|
if (tape->chrdev_dir == IDETAPE_DIR_READ)
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_discard_merge_buffer(drive, 1);
|
2008-02-06 09:57:54 +08:00
|
|
|
return idetape_blkdev_ioctl(drive, cmd, arg);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-04 14:24:00 +08:00
|
|
|
static long idetape_chrdev_ioctl(struct file *file,
|
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
long ret;
|
2010-06-02 20:28:52 +08:00
|
|
|
mutex_lock(&ide_tape_mutex);
|
2010-01-04 14:24:00 +08:00
|
|
|
ret = do_idetape_chrdev_ioctl(file, cmd, arg);
|
2010-06-02 20:28:52 +08:00
|
|
|
mutex_unlock(&ide_tape_mutex);
|
2010-01-04 14:24:00 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-09-07 22:49:43 +08:00
|
|
|
static long idetape_chrdev_compat_ioctl(struct file *file,
|
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
long ret;
|
|
|
|
|
|
|
|
if (cmd == MTIOCPOS32)
|
|
|
|
cmd = MTIOCPOS;
|
|
|
|
else if (cmd == MTIOCGET32)
|
|
|
|
cmd = MTIOCGET;
|
|
|
|
|
|
|
|
mutex_lock(&ide_tape_mutex);
|
|
|
|
ret = do_idetape_chrdev_ioctl(file, cmd, arg);
|
|
|
|
mutex_unlock(&ide_tape_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-02-03 02:56:50 +08:00
|
|
|
/*
|
|
|
|
* Do a mode sense page 0 with block descriptor and if it succeeds set the tape
|
|
|
|
* block size with the reported value.
|
|
|
|
*/
|
|
|
|
static void ide_tape_get_bsize_from_bdesc(ide_drive_t *drive)
|
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-04-18 06:46:27 +08:00
|
|
|
struct ide_atapi_pc pc;
|
2009-05-04 15:48:57 +08:00
|
|
|
u8 buf[12];
|
2008-02-03 02:56:50 +08:00
|
|
|
|
|
|
|
idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR);
|
2009-05-04 15:48:57 +08:00
|
|
|
if (ide_queue_pc_tail(drive, tape->disk, &pc, buf, pc.req_xfer)) {
|
2008-02-03 02:56:50 +08:00
|
|
|
printk(KERN_ERR "ide-tape: Can't get block descriptor\n");
|
2008-02-06 09:57:52 +08:00
|
|
|
if (tape->blk_size == 0) {
|
2008-02-03 02:56:50 +08:00
|
|
|
printk(KERN_WARNING "ide-tape: Cannot deal with zero "
|
|
|
|
"block size, assuming 32k\n");
|
2008-02-06 09:57:52 +08:00
|
|
|
tape->blk_size = 32768;
|
2008-02-03 02:56:50 +08:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2009-05-04 15:48:57 +08:00
|
|
|
tape->blk_size = (buf[4 + 5] << 16) +
|
|
|
|
(buf[4 + 6] << 8) +
|
|
|
|
buf[4 + 7];
|
|
|
|
tape->drv_write_prot = (buf[2] & 0x80) >> 7;
|
2009-07-18 07:55:16 +08:00
|
|
|
|
|
|
|
ide_debug_log(IDE_DBG_FUNC, "blk_size: %d, write_prot: %d",
|
|
|
|
tape->blk_size, tape->drv_write_prot);
|
2008-02-03 02:56:50 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-06 09:57:54 +08:00
|
|
|
static int idetape_chrdev_open(struct inode *inode, struct file *filp)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
unsigned int minor = iminor(inode), i = minor & ~0xc0;
|
|
|
|
ide_drive_t *drive;
|
|
|
|
idetape_tape_t *tape;
|
|
|
|
int retval;
|
|
|
|
|
2008-02-06 09:57:51 +08:00
|
|
|
if (i >= MAX_HWIFS * MAX_DRIVES)
|
|
|
|
return -ENXIO;
|
|
|
|
|
2009-10-11 08:25:19 +08:00
|
|
|
mutex_lock(&idetape_chrdev_mutex);
|
|
|
|
|
2009-06-09 04:03:03 +08:00
|
|
|
tape = ide_tape_get(NULL, true, i);
|
2008-05-16 02:01:56 +08:00
|
|
|
if (!tape) {
|
2009-10-11 08:25:19 +08:00
|
|
|
mutex_unlock(&idetape_chrdev_mutex);
|
2008-02-06 09:57:51 +08:00
|
|
|
return -ENXIO;
|
2008-05-16 02:01:56 +08:00
|
|
|
}
|
2008-02-06 09:57:51 +08:00
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
drive = tape->drive;
|
|
|
|
filp->private_data = tape;
|
|
|
|
|
|
|
|
ide_debug_log(IDE_DBG_FUNC, "enter");
|
2008-02-06 09:57:51 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* We really want to do nonseekable_open(inode, filp); here, but some
|
|
|
|
* versions of tar incorrectly call lseek on tapes and bail out if that
|
|
|
|
* fails. So we disallow pread() and pwrite(), but permit lseeks.
|
|
|
|
*/
|
|
|
|
filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
|
|
|
|
|
|
|
|
|
2009-06-07 21:37:06 +08:00
|
|
|
if (test_and_set_bit(ilog2(IDE_AFLAG_BUSY), &drive->atapi_flags)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
retval = -EBUSY;
|
|
|
|
goto out_put_tape;
|
|
|
|
}
|
|
|
|
|
|
|
|
retval = idetape_wait_ready(drive, 60 * HZ);
|
|
|
|
if (retval) {
|
2009-06-07 21:37:06 +08:00
|
|
|
clear_bit(ilog2(IDE_AFLAG_BUSY), &drive->atapi_flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name);
|
|
|
|
goto out_put_tape;
|
|
|
|
}
|
|
|
|
|
2009-06-15 13:32:04 +08:00
|
|
|
ide_tape_read_position(drive);
|
2009-06-07 21:37:06 +08:00
|
|
|
if (!test_bit(ilog2(IDE_AFLAG_ADDRESS_VALID), &drive->atapi_flags))
|
2005-04-17 06:20:36 +08:00
|
|
|
(void)idetape_rewind_tape(drive);
|
|
|
|
|
|
|
|
/* Read block size and write protect status from drive. */
|
2008-02-03 02:56:50 +08:00
|
|
|
ide_tape_get_bsize_from_bdesc(drive);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Set write protect flag if device is opened as read-only. */
|
|
|
|
if ((filp->f_flags & O_ACCMODE) == O_RDONLY)
|
|
|
|
tape->write_prot = 1;
|
|
|
|
else
|
|
|
|
tape->write_prot = tape->drv_write_prot;
|
|
|
|
|
|
|
|
/* Make sure drive isn't write protected if user wants to write. */
|
|
|
|
if (tape->write_prot) {
|
|
|
|
if ((filp->f_flags & O_ACCMODE) == O_WRONLY ||
|
|
|
|
(filp->f_flags & O_ACCMODE) == O_RDWR) {
|
2009-06-07 21:37:06 +08:00
|
|
|
clear_bit(ilog2(IDE_AFLAG_BUSY), &drive->atapi_flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
retval = -EROFS;
|
|
|
|
goto out_put_tape;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:53 +08:00
|
|
|
/* Lock the tape drive door so user can't eject. */
|
2008-02-06 09:57:52 +08:00
|
|
|
if (tape->chrdev_dir == IDETAPE_DIR_NONE) {
|
2008-10-11 04:39:38 +08:00
|
|
|
if (!ide_set_media_lock(drive, tape->disk, 1)) {
|
2008-10-11 04:39:37 +08:00
|
|
|
if (tape->door_locked != DOOR_EXPLICITLY_LOCKED)
|
|
|
|
tape->door_locked = DOOR_LOCKED;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
2009-10-11 08:25:19 +08:00
|
|
|
mutex_unlock(&idetape_chrdev_mutex);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_put_tape:
|
|
|
|
ide_tape_put(tape);
|
2009-10-11 08:25:19 +08:00
|
|
|
|
|
|
|
mutex_unlock(&idetape_chrdev_mutex);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:54 +08:00
|
|
|
static void idetape_write_release(ide_drive_t *drive, unsigned int minor)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
|
|
|
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_flush_merge_buffer(drive);
|
2009-04-19 07:46:02 +08:00
|
|
|
tape->buf = kmalloc(tape->buffer_size, GFP_KERNEL);
|
|
|
|
if (tape->buf != NULL) {
|
2008-02-06 09:57:52 +08:00
|
|
|
idetape_pad_zeros(drive, tape->blk_size *
|
|
|
|
(tape->user_bs_factor - 1));
|
2009-04-19 07:46:02 +08:00
|
|
|
kfree(tape->buf);
|
|
|
|
tape->buf = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
idetape_write_filemark(drive);
|
|
|
|
idetape_flush_tape_buffers(drive);
|
|
|
|
idetape_flush_tape_buffers(drive);
|
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:54 +08:00
|
|
|
static int idetape_chrdev_release(struct inode *inode, struct file *filp)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-14 03:39:34 +08:00
|
|
|
struct ide_tape_obj *tape = filp->private_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
ide_drive_t *drive = tape->drive;
|
|
|
|
unsigned int minor = iminor(inode);
|
|
|
|
|
2009-10-11 08:25:19 +08:00
|
|
|
mutex_lock(&idetape_chrdev_mutex);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
tape = drive->driver_data;
|
2008-02-06 09:57:51 +08:00
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "enter");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-06 09:57:52 +08:00
|
|
|
if (tape->chrdev_dir == IDETAPE_DIR_WRITE)
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_write_release(drive, minor);
|
2008-02-06 09:57:52 +08:00
|
|
|
if (tape->chrdev_dir == IDETAPE_DIR_READ) {
|
2005-04-17 06:20:36 +08:00
|
|
|
if (minor < 128)
|
2008-04-27 21:38:34 +08:00
|
|
|
ide_tape_discard_merge_buffer(drive, 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-04-27 21:38:25 +08:00
|
|
|
|
2009-06-07 21:37:06 +08:00
|
|
|
if (minor < 128 && test_bit(ilog2(IDE_AFLAG_MEDIUM_PRESENT),
|
|
|
|
&drive->atapi_flags))
|
2005-04-17 06:20:36 +08:00
|
|
|
(void) idetape_rewind_tape(drive);
|
2009-06-07 21:37:06 +08:00
|
|
|
|
2008-02-06 09:57:52 +08:00
|
|
|
if (tape->chrdev_dir == IDETAPE_DIR_NONE) {
|
2005-04-17 06:20:36 +08:00
|
|
|
if (tape->door_locked == DOOR_LOCKED) {
|
2008-10-11 04:39:38 +08:00
|
|
|
if (!ide_set_media_lock(drive, tape->disk, 0))
|
2008-10-11 04:39:37 +08:00
|
|
|
tape->door_locked = DOOR_UNLOCKED;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
2009-06-07 21:37:06 +08:00
|
|
|
clear_bit(ilog2(IDE_AFLAG_BUSY), &drive->atapi_flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
ide_tape_put(tape);
|
2009-10-11 08:25:19 +08:00
|
|
|
|
|
|
|
mutex_unlock(&idetape_chrdev_mutex);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-03 02:56:49 +08:00
|
|
|
static void idetape_get_inquiry_results(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-04-18 06:46:27 +08:00
|
|
|
struct ide_atapi_pc pc;
|
2009-04-01 02:15:25 +08:00
|
|
|
u8 pc_buf[256];
|
2008-09-28 01:32:17 +08:00
|
|
|
char fw_rev[4], vendor_id[8], product_id[16];
|
2008-02-03 02:56:49 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_create_inquiry_cmd(&pc);
|
2009-05-02 16:26:12 +08:00
|
|
|
if (ide_queue_pc_tail(drive, tape->disk, &pc, pc_buf, pc.req_xfer)) {
|
2008-02-03 02:56:49 +08:00
|
|
|
printk(KERN_ERR "ide-tape: %s: can't get INQUIRY results\n",
|
|
|
|
tape->name);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-05-02 16:26:12 +08:00
|
|
|
memcpy(vendor_id, &pc_buf[8], 8);
|
|
|
|
memcpy(product_id, &pc_buf[16], 16);
|
|
|
|
memcpy(fw_rev, &pc_buf[32], 4);
|
2008-02-06 09:57:52 +08:00
|
|
|
|
2008-09-28 01:32:17 +08:00
|
|
|
ide_fixstring(vendor_id, 8, 0);
|
|
|
|
ide_fixstring(product_id, 16, 0);
|
|
|
|
ide_fixstring(fw_rev, 4, 0);
|
2008-02-06 09:57:52 +08:00
|
|
|
|
2008-09-28 01:32:17 +08:00
|
|
|
printk(KERN_INFO "ide-tape: %s <-> %s: %.8s %.16s rev %.4s\n",
|
2008-02-06 09:57:52 +08:00
|
|
|
drive->name, tape->name, vendor_id, product_id, fw_rev);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-02-03 02:56:49 +08:00
|
|
|
* Ask the tape about its various parameters. In particular, we will adjust our
|
|
|
|
* data transfer buffer size to the recommended value as returned by the tape.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2008-02-06 09:57:54 +08:00
|
|
|
static void idetape_get_mode_sense_results(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
2008-04-18 06:46:27 +08:00
|
|
|
struct ide_atapi_pc pc;
|
2009-05-02 16:26:12 +08:00
|
|
|
u8 buf[24], *caps;
|
2008-02-03 02:56:49 +08:00
|
|
|
u8 speed, max_speed;
|
2008-02-03 02:56:48 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_create_mode_sense_cmd(&pc, IDETAPE_CAPABILITIES_PAGE);
|
2009-05-02 16:26:12 +08:00
|
|
|
if (ide_queue_pc_tail(drive, tape->disk, &pc, buf, pc.req_xfer)) {
|
2008-02-03 02:56:49 +08:00
|
|
|
printk(KERN_ERR "ide-tape: Can't get tape parameters - assuming"
|
|
|
|
" some default values\n");
|
2008-02-06 09:57:52 +08:00
|
|
|
tape->blk_size = 512;
|
2008-02-03 02:56:49 +08:00
|
|
|
put_unaligned(52, (u16 *)&tape->caps[12]);
|
|
|
|
put_unaligned(540, (u16 *)&tape->caps[14]);
|
|
|
|
put_unaligned(6*52, (u16 *)&tape->caps[16]);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-05-02 16:26:12 +08:00
|
|
|
caps = buf + 4 + buf[3];
|
2008-02-03 02:56:49 +08:00
|
|
|
|
|
|
|
/* convert to host order and save for later use */
|
2008-07-25 04:53:33 +08:00
|
|
|
speed = be16_to_cpup((__be16 *)&caps[14]);
|
|
|
|
max_speed = be16_to_cpup((__be16 *)&caps[8]);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-25 04:53:33 +08:00
|
|
|
*(u16 *)&caps[8] = max_speed;
|
|
|
|
*(u16 *)&caps[12] = be16_to_cpup((__be16 *)&caps[12]);
|
|
|
|
*(u16 *)&caps[14] = speed;
|
|
|
|
*(u16 *)&caps[16] = be16_to_cpup((__be16 *)&caps[16]);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-03 02:56:49 +08:00
|
|
|
if (!speed) {
|
|
|
|
printk(KERN_INFO "ide-tape: %s: invalid tape speed "
|
|
|
|
"(assuming 650KB/sec)\n", drive->name);
|
2008-07-25 04:53:33 +08:00
|
|
|
*(u16 *)&caps[14] = 650;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-02-03 02:56:49 +08:00
|
|
|
if (!max_speed) {
|
|
|
|
printk(KERN_INFO "ide-tape: %s: invalid max_speed "
|
|
|
|
"(assuming 650KB/sec)\n", drive->name);
|
2008-07-25 04:53:33 +08:00
|
|
|
*(u16 *)&caps[8] = 650;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-02-03 02:56:49 +08:00
|
|
|
memcpy(&tape->caps, caps, 20);
|
2008-10-11 04:39:38 +08:00
|
|
|
|
|
|
|
/* device lacks locking support according to capabilities page */
|
|
|
|
if ((caps[6] & 1) == 0)
|
2008-10-18 00:09:11 +08:00
|
|
|
drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
|
2008-10-11 04:39:38 +08:00
|
|
|
|
2008-02-03 02:56:49 +08:00
|
|
|
if (caps[7] & 0x02)
|
2008-02-06 09:57:52 +08:00
|
|
|
tape->blk_size = 512;
|
2008-02-03 02:56:49 +08:00
|
|
|
else if (caps[7] & 0x04)
|
2008-02-06 09:57:52 +08:00
|
|
|
tape->blk_size = 1024;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-05-10 06:01:10 +08:00
|
|
|
#ifdef CONFIG_IDE_PROC_FS
|
ide: /proc/ide/hd*/settings rework
* Add struct ide_devset, S_* flags, *DEVSET() & ide*_devset_*() macros.
* Add 'const struct ide_devset **settings' to ide_driver_t.
* Use 'const struct ide_devset **settings' in ide_drive_t instead of
'struct ide_settings_s *settings'. Then convert core code and device
drivers to use struct ide_devset and co.:
- device settings are no longer allocated dynamically for each device
but instead there is an unique struct ide_devset instance per setting
- device driver keeps the pointer to the table of pointers to its
settings in ide_driver_t.settings
- generic settings are kept in ide_generic_setting[]
- ide_proc_[un]register_driver(), ide_find_setting_by_name(),
ide_{read,write}_setting() and proc_ide_{read,write}_settings()
are updated accordingly
- ide*_add_settings() are removed
* Remove no longer used __ide_add_setting(), ide_add_setting(),
__ide_remove_setting() and auto_remove_settings().
* Remove no longer used TYPE_*, SETTING_*, ide_procset_t
and ide_settings_t.
* ->keep_settings, ->using_dma, ->unmask, ->noflush, ->dsc_overlap,
->nice1, ->addressing, ->wcache and ->nowerr ide_drive_t fields
can now be bitfield flags.
While at it:
* Rename ide_find_setting_by_name() to ide_find_setting().
* Rename write_wcache() to set_wcache().
There should be no functional changes caused by this patch.
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
2008-10-11 04:39:28 +08:00
|
|
|
#define ide_tape_devset_get(name, field) \
|
|
|
|
static int get_##name(ide_drive_t *drive) \
|
|
|
|
{ \
|
|
|
|
idetape_tape_t *tape = drive->driver_data; \
|
|
|
|
return tape->field; \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define ide_tape_devset_set(name, field) \
|
|
|
|
static int set_##name(ide_drive_t *drive, int arg) \
|
|
|
|
{ \
|
|
|
|
idetape_tape_t *tape = drive->driver_data; \
|
|
|
|
tape->field = arg; \
|
|
|
|
return 0; \
|
|
|
|
}
|
|
|
|
|
2008-10-11 04:39:40 +08:00
|
|
|
#define ide_tape_devset_rw_field(_name, _field) \
|
ide: /proc/ide/hd*/settings rework
* Add struct ide_devset, S_* flags, *DEVSET() & ide*_devset_*() macros.
* Add 'const struct ide_devset **settings' to ide_driver_t.
* Use 'const struct ide_devset **settings' in ide_drive_t instead of
'struct ide_settings_s *settings'. Then convert core code and device
drivers to use struct ide_devset and co.:
- device settings are no longer allocated dynamically for each device
but instead there is an unique struct ide_devset instance per setting
- device driver keeps the pointer to the table of pointers to its
settings in ide_driver_t.settings
- generic settings are kept in ide_generic_setting[]
- ide_proc_[un]register_driver(), ide_find_setting_by_name(),
ide_{read,write}_setting() and proc_ide_{read,write}_settings()
are updated accordingly
- ide*_add_settings() are removed
* Remove no longer used __ide_add_setting(), ide_add_setting(),
__ide_remove_setting() and auto_remove_settings().
* Remove no longer used TYPE_*, SETTING_*, ide_procset_t
and ide_settings_t.
* ->keep_settings, ->using_dma, ->unmask, ->noflush, ->dsc_overlap,
->nice1, ->addressing, ->wcache and ->nowerr ide_drive_t fields
can now be bitfield flags.
While at it:
* Rename ide_find_setting_by_name() to ide_find_setting().
* Rename write_wcache() to set_wcache().
There should be no functional changes caused by this patch.
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
2008-10-11 04:39:28 +08:00
|
|
|
ide_tape_devset_get(_name, _field) \
|
|
|
|
ide_tape_devset_set(_name, _field) \
|
2008-10-11 04:39:40 +08:00
|
|
|
IDE_DEVSET(_name, DS_SYNC, get_##_name, set_##_name)
|
ide: /proc/ide/hd*/settings rework
* Add struct ide_devset, S_* flags, *DEVSET() & ide*_devset_*() macros.
* Add 'const struct ide_devset **settings' to ide_driver_t.
* Use 'const struct ide_devset **settings' in ide_drive_t instead of
'struct ide_settings_s *settings'. Then convert core code and device
drivers to use struct ide_devset and co.:
- device settings are no longer allocated dynamically for each device
but instead there is an unique struct ide_devset instance per setting
- device driver keeps the pointer to the table of pointers to its
settings in ide_driver_t.settings
- generic settings are kept in ide_generic_setting[]
- ide_proc_[un]register_driver(), ide_find_setting_by_name(),
ide_{read,write}_setting() and proc_ide_{read,write}_settings()
are updated accordingly
- ide*_add_settings() are removed
* Remove no longer used __ide_add_setting(), ide_add_setting(),
__ide_remove_setting() and auto_remove_settings().
* Remove no longer used TYPE_*, SETTING_*, ide_procset_t
and ide_settings_t.
* ->keep_settings, ->using_dma, ->unmask, ->noflush, ->dsc_overlap,
->nice1, ->addressing, ->wcache and ->nowerr ide_drive_t fields
can now be bitfield flags.
While at it:
* Rename ide_find_setting_by_name() to ide_find_setting().
* Rename write_wcache() to set_wcache().
There should be no functional changes caused by this patch.
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
2008-10-11 04:39:28 +08:00
|
|
|
|
2008-10-11 04:39:40 +08:00
|
|
|
#define ide_tape_devset_r_field(_name, _field) \
|
ide: /proc/ide/hd*/settings rework
* Add struct ide_devset, S_* flags, *DEVSET() & ide*_devset_*() macros.
* Add 'const struct ide_devset **settings' to ide_driver_t.
* Use 'const struct ide_devset **settings' in ide_drive_t instead of
'struct ide_settings_s *settings'. Then convert core code and device
drivers to use struct ide_devset and co.:
- device settings are no longer allocated dynamically for each device
but instead there is an unique struct ide_devset instance per setting
- device driver keeps the pointer to the table of pointers to its
settings in ide_driver_t.settings
- generic settings are kept in ide_generic_setting[]
- ide_proc_[un]register_driver(), ide_find_setting_by_name(),
ide_{read,write}_setting() and proc_ide_{read,write}_settings()
are updated accordingly
- ide*_add_settings() are removed
* Remove no longer used __ide_add_setting(), ide_add_setting(),
__ide_remove_setting() and auto_remove_settings().
* Remove no longer used TYPE_*, SETTING_*, ide_procset_t
and ide_settings_t.
* ->keep_settings, ->using_dma, ->unmask, ->noflush, ->dsc_overlap,
->nice1, ->addressing, ->wcache and ->nowerr ide_drive_t fields
can now be bitfield flags.
While at it:
* Rename ide_find_setting_by_name() to ide_find_setting().
* Rename write_wcache() to set_wcache().
There should be no functional changes caused by this patch.
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
2008-10-11 04:39:28 +08:00
|
|
|
ide_tape_devset_get(_name, _field) \
|
2008-10-11 04:39:40 +08:00
|
|
|
IDE_DEVSET(_name, 0, get_##_name, NULL)
|
ide: /proc/ide/hd*/settings rework
* Add struct ide_devset, S_* flags, *DEVSET() & ide*_devset_*() macros.
* Add 'const struct ide_devset **settings' to ide_driver_t.
* Use 'const struct ide_devset **settings' in ide_drive_t instead of
'struct ide_settings_s *settings'. Then convert core code and device
drivers to use struct ide_devset and co.:
- device settings are no longer allocated dynamically for each device
but instead there is an unique struct ide_devset instance per setting
- device driver keeps the pointer to the table of pointers to its
settings in ide_driver_t.settings
- generic settings are kept in ide_generic_setting[]
- ide_proc_[un]register_driver(), ide_find_setting_by_name(),
ide_{read,write}_setting() and proc_ide_{read,write}_settings()
are updated accordingly
- ide*_add_settings() are removed
* Remove no longer used __ide_add_setting(), ide_add_setting(),
__ide_remove_setting() and auto_remove_settings().
* Remove no longer used TYPE_*, SETTING_*, ide_procset_t
and ide_settings_t.
* ->keep_settings, ->using_dma, ->unmask, ->noflush, ->dsc_overlap,
->nice1, ->addressing, ->wcache and ->nowerr ide_drive_t fields
can now be bitfield flags.
While at it:
* Rename ide_find_setting_by_name() to ide_find_setting().
* Rename write_wcache() to set_wcache().
There should be no functional changes caused by this patch.
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
2008-10-11 04:39:28 +08:00
|
|
|
|
|
|
|
static int mulf_tdsc(ide_drive_t *drive) { return 1000; }
|
|
|
|
static int divf_tdsc(ide_drive_t *drive) { return HZ; }
|
|
|
|
static int divf_buffer(ide_drive_t *drive) { return 2; }
|
|
|
|
static int divf_buffer_size(ide_drive_t *drive) { return 1024; }
|
|
|
|
|
2008-10-14 03:39:36 +08:00
|
|
|
ide_devset_rw_flag(dsc_overlap, IDE_DFLAG_DSC_OVERLAP);
|
2008-10-11 04:39:40 +08:00
|
|
|
|
|
|
|
ide_tape_devset_rw_field(tdsc, best_dsc_rw_freq);
|
|
|
|
|
|
|
|
ide_tape_devset_r_field(avg_speed, avg_speed);
|
|
|
|
ide_tape_devset_r_field(speed, caps[14]);
|
|
|
|
ide_tape_devset_r_field(buffer, caps[16]);
|
|
|
|
ide_tape_devset_r_field(buffer_size, buffer_size);
|
|
|
|
|
|
|
|
static const struct ide_proc_devset idetape_settings[] = {
|
|
|
|
__IDE_PROC_DEVSET(avg_speed, 0, 0xffff, NULL, NULL),
|
|
|
|
__IDE_PROC_DEVSET(buffer, 0, 0xffff, NULL, divf_buffer),
|
|
|
|
__IDE_PROC_DEVSET(buffer_size, 0, 0xffff, NULL, divf_buffer_size),
|
|
|
|
__IDE_PROC_DEVSET(dsc_overlap, 0, 1, NULL, NULL),
|
|
|
|
__IDE_PROC_DEVSET(speed, 0, 0xffff, NULL, NULL),
|
|
|
|
__IDE_PROC_DEVSET(tdsc, IDETAPE_DSC_RW_MIN, IDETAPE_DSC_RW_MAX,
|
|
|
|
mulf_tdsc, divf_tdsc),
|
2009-03-05 23:10:56 +08:00
|
|
|
{ NULL },
|
ide: /proc/ide/hd*/settings rework
* Add struct ide_devset, S_* flags, *DEVSET() & ide*_devset_*() macros.
* Add 'const struct ide_devset **settings' to ide_driver_t.
* Use 'const struct ide_devset **settings' in ide_drive_t instead of
'struct ide_settings_s *settings'. Then convert core code and device
drivers to use struct ide_devset and co.:
- device settings are no longer allocated dynamically for each device
but instead there is an unique struct ide_devset instance per setting
- device driver keeps the pointer to the table of pointers to its
settings in ide_driver_t.settings
- generic settings are kept in ide_generic_setting[]
- ide_proc_[un]register_driver(), ide_find_setting_by_name(),
ide_{read,write}_setting() and proc_ide_{read,write}_settings()
are updated accordingly
- ide*_add_settings() are removed
* Remove no longer used __ide_add_setting(), ide_add_setting(),
__ide_remove_setting() and auto_remove_settings().
* Remove no longer used TYPE_*, SETTING_*, ide_procset_t
and ide_settings_t.
* ->keep_settings, ->using_dma, ->unmask, ->noflush, ->dsc_overlap,
->nice1, ->addressing, ->wcache and ->nowerr ide_drive_t fields
can now be bitfield flags.
While at it:
* Rename ide_find_setting_by_name() to ide_find_setting().
* Rename write_wcache() to set_wcache().
There should be no functional changes caused by this patch.
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
2008-10-11 04:39:28 +08:00
|
|
|
};
|
2007-05-10 06:01:10 +08:00
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* The function below is called to:
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* 1. Initialize our various state variables.
|
|
|
|
* 2. Ask the tape for its capabilities.
|
|
|
|
* 3. Allocate a buffer which will be used for data transfer. The buffer size
|
|
|
|
* is chosen based on the recommendation which we received in step 2.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Note that at this point ide.c already assigned us an irq, so that we can
|
|
|
|
* queue requests here and wait for their completion.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2008-02-06 09:57:54 +08:00
|
|
|
static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-04-27 21:38:27 +08:00
|
|
|
unsigned long t;
|
2005-04-17 06:20:36 +08:00
|
|
|
int speed;
|
2008-02-03 02:56:49 +08:00
|
|
|
u16 *ctl = (u16 *)&tape->caps[12];
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "minor: %d", minor);
|
|
|
|
|
|
|
|
drive->pc_callback = ide_tape_callback;
|
2008-07-24 01:55:59 +08:00
|
|
|
|
2008-10-14 03:39:36 +08:00
|
|
|
drive->dev_flags |= IDE_DFLAG_DSC_OVERLAP;
|
|
|
|
|
2008-02-02 06:09:30 +08:00
|
|
|
if (drive->hwif->host_flags & IDE_HFLAG_NO_DSC) {
|
|
|
|
printk(KERN_INFO "ide-tape: %s: disabling DSC overlap\n",
|
|
|
|
tape->name);
|
2008-10-14 03:39:36 +08:00
|
|
|
drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-10-14 03:39:36 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Seagate Travan drives do not support DSC overlap. */
|
2008-10-11 04:39:19 +08:00
|
|
|
if (strstr((char *)&drive->id[ATA_ID_PROD], "Seagate STT3401"))
|
2008-10-14 03:39:36 +08:00
|
|
|
drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
tape->minor = minor;
|
|
|
|
tape->name[0] = 'h';
|
|
|
|
tape->name[1] = 't';
|
|
|
|
tape->name[2] = '0' + minor;
|
2008-02-06 09:57:52 +08:00
|
|
|
tape->chrdev_dir = IDETAPE_DIR_NONE;
|
2008-10-11 04:39:19 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_get_inquiry_results(drive);
|
|
|
|
idetape_get_mode_sense_results(drive);
|
2008-02-03 02:56:50 +08:00
|
|
|
ide_tape_get_bsize_from_bdesc(drive);
|
2005-04-17 06:20:36 +08:00
|
|
|
tape->user_bs_factor = 1;
|
2008-04-27 21:38:33 +08:00
|
|
|
tape->buffer_size = *ctl * tape->blk_size;
|
|
|
|
while (tape->buffer_size > 0xffff) {
|
2005-04-17 06:20:36 +08:00
|
|
|
printk(KERN_NOTICE "ide-tape: decreasing stage size\n");
|
2008-02-03 02:56:49 +08:00
|
|
|
*ctl /= 2;
|
2008-04-27 21:38:33 +08:00
|
|
|
tape->buffer_size = *ctl * tape->blk_size;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-04-27 21:38:27 +08:00
|
|
|
/* select the "best" DSC read/write polling freq */
|
2008-02-03 02:56:49 +08:00
|
|
|
speed = max(*(u16 *)&tape->caps[14], *(u16 *)&tape->caps[8]);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-04-27 21:38:33 +08:00
|
|
|
t = (IDETAPE_FIFO_THRESHOLD * tape->buffer_size * HZ) / (speed * 1000);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
2008-02-06 09:57:53 +08:00
|
|
|
* Ensure that the number we got makes sense; limit it within
|
|
|
|
* IDETAPE_DSC_RW_MIN and IDETAPE_DSC_RW_MAX.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2008-07-16 03:21:41 +08:00
|
|
|
tape->best_dsc_rw_freq = clamp_t(unsigned long, t, IDETAPE_DSC_RW_MIN,
|
|
|
|
IDETAPE_DSC_RW_MAX);
|
2005-04-17 06:20:36 +08:00
|
|
|
printk(KERN_INFO "ide-tape: %s <-> %s: %dKBps, %d*%dkB buffer, "
|
2015-03-03 18:52:51 +08:00
|
|
|
"%ums tDSC%s\n",
|
2008-02-03 02:56:49 +08:00
|
|
|
drive->name, tape->name, *(u16 *)&tape->caps[14],
|
2008-04-27 21:38:33 +08:00
|
|
|
(*(u16 *)&tape->caps[16] * 512) / tape->buffer_size,
|
|
|
|
tape->buffer_size / 1024,
|
2015-03-03 18:52:51 +08:00
|
|
|
jiffies_to_msecs(tape->best_dsc_rw_freq),
|
2008-10-14 03:39:36 +08:00
|
|
|
(drive->dev_flags & IDE_DFLAG_USING_DMA) ? ", DMA" : "");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-10-11 04:39:27 +08:00
|
|
|
ide_proc_register_driver(drive, tape->driver);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-01-06 19:41:00 +08:00
|
|
|
static void ide_tape_remove(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
|
|
|
|
2007-05-10 06:01:10 +08:00
|
|
|
ide_proc_unregister_driver(drive, tape->driver);
|
2009-02-26 03:28:24 +08:00
|
|
|
device_del(&tape->dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
ide_unregister_region(tape->disk);
|
|
|
|
|
2009-02-26 03:28:24 +08:00
|
|
|
mutex_lock(&idetape_ref_mutex);
|
|
|
|
put_device(&tape->dev);
|
|
|
|
mutex_unlock(&idetape_ref_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-02-26 03:28:24 +08:00
|
|
|
static void ide_tape_release(struct device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-02-26 03:28:24 +08:00
|
|
|
struct ide_tape_obj *tape = to_ide_drv(dev, ide_tape_obj);
|
2005-04-17 06:20:36 +08:00
|
|
|
ide_drive_t *drive = tape->drive;
|
|
|
|
struct gendisk *g = tape->disk;
|
|
|
|
|
2009-04-19 07:46:02 +08:00
|
|
|
BUG_ON(tape->valid);
|
2005-05-26 20:55:34 +08:00
|
|
|
|
2008-10-14 03:39:36 +08:00
|
|
|
drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
|
2005-04-17 06:20:36 +08:00
|
|
|
drive->driver_data = NULL;
|
2007-09-25 08:03:03 +08:00
|
|
|
device_destroy(idetape_sysfs_class, MKDEV(IDETAPE_MAJOR, tape->minor));
|
2008-02-06 09:57:54 +08:00
|
|
|
device_destroy(idetape_sysfs_class,
|
|
|
|
MKDEV(IDETAPE_MAJOR, tape->minor + 128));
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_devs[tape->minor] = NULL;
|
|
|
|
g->private_data = NULL;
|
|
|
|
put_disk(g);
|
|
|
|
kfree(tape);
|
|
|
|
}
|
|
|
|
|
2007-05-10 06:01:09 +08:00
|
|
|
#ifdef CONFIG_IDE_PROC_FS
|
2009-09-02 08:52:57 +08:00
|
|
|
static int idetape_name_proc_show(struct seq_file *m, void *v)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-02 08:52:57 +08:00
|
|
|
ide_drive_t *drive = (ide_drive_t *) m->private;
|
2005-04-17 06:20:36 +08:00
|
|
|
idetape_tape_t *tape = drive->driver_data;
|
|
|
|
|
2009-09-02 08:52:57 +08:00
|
|
|
seq_printf(m, "%s\n", tape->name);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static ide_proc_entry_t idetape_proc[] = {
|
2018-04-14 03:25:54 +08:00
|
|
|
{ "capacity", S_IFREG|S_IRUGO, ide_capacity_proc_show },
|
|
|
|
{ "name", S_IFREG|S_IRUGO, idetape_name_proc_show },
|
2009-09-02 08:52:57 +08:00
|
|
|
{}
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
2008-10-18 00:09:13 +08:00
|
|
|
|
|
|
|
static ide_proc_entry_t *ide_tape_proc_entries(ide_drive_t *drive)
|
|
|
|
{
|
|
|
|
return idetape_proc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct ide_proc_devset *ide_tape_proc_devsets(ide_drive_t *drive)
|
|
|
|
{
|
|
|
|
return idetape_settings;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
2006-01-06 19:41:00 +08:00
|
|
|
static int ide_tape_probe(ide_drive_t *);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-01-07 00:20:53 +08:00
|
|
|
static struct ide_driver idetape_driver = {
|
2005-05-26 20:55:34 +08:00
|
|
|
.gen_driver = {
|
2005-11-19 05:15:40 +08:00
|
|
|
.owner = THIS_MODULE,
|
2005-05-26 20:55:34 +08:00
|
|
|
.name = "ide-tape",
|
|
|
|
.bus = &ide_bus_type,
|
|
|
|
},
|
2006-01-06 19:41:00 +08:00
|
|
|
.probe = ide_tape_probe,
|
|
|
|
.remove = ide_tape_remove,
|
2005-04-17 06:20:36 +08:00
|
|
|
.version = IDETAPE_VERSION,
|
|
|
|
.do_request = idetape_do_request,
|
2007-05-10 06:01:10 +08:00
|
|
|
#ifdef CONFIG_IDE_PROC_FS
|
2008-10-18 00:09:13 +08:00
|
|
|
.proc_entries = ide_tape_proc_entries,
|
|
|
|
.proc_devsets = ide_tape_proc_devsets,
|
2007-05-10 06:01:10 +08:00
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2008-02-06 09:57:53 +08:00
|
|
|
/* Our character device supporting functions, passed to register_chrdev. */
|
2007-02-12 16:55:32 +08:00
|
|
|
static const struct file_operations idetape_fops = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.read = idetape_chrdev_read,
|
|
|
|
.write = idetape_chrdev_write,
|
2010-01-04 14:24:00 +08:00
|
|
|
.unlocked_ioctl = idetape_chrdev_ioctl,
|
2018-09-07 22:49:43 +08:00
|
|
|
.compat_ioctl = IS_ENABLED(CONFIG_COMPAT) ?
|
|
|
|
idetape_chrdev_compat_ioctl : NULL,
|
2005-04-17 06:20:36 +08:00
|
|
|
.open = idetape_chrdev_open,
|
|
|
|
.release = idetape_chrdev_release,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-16 00:52:59 +08:00
|
|
|
.llseek = noop_llseek,
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2008-03-02 23:27:58 +08:00
|
|
|
static int idetape_open(struct block_device *bdev, fmode_t mode)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-08-08 00:25:34 +08:00
|
|
|
struct ide_tape_obj *tape;
|
|
|
|
|
2010-06-02 20:28:52 +08:00
|
|
|
mutex_lock(&ide_tape_mutex);
|
2010-08-08 00:25:34 +08:00
|
|
|
tape = ide_tape_get(bdev->bd_disk, false, 0);
|
2010-06-02 20:28:52 +08:00
|
|
|
mutex_unlock(&ide_tape_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-06 09:57:54 +08:00
|
|
|
if (!tape)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-05-06 09:52:57 +08:00
|
|
|
static void idetape_release(struct gendisk *disk, fmode_t mode)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-10-14 03:39:34 +08:00
|
|
|
struct ide_tape_obj *tape = ide_drv_g(disk, ide_tape_obj);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-06-02 20:28:52 +08:00
|
|
|
mutex_lock(&ide_tape_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
ide_tape_put(tape);
|
2010-06-02 20:28:52 +08:00
|
|
|
mutex_unlock(&ide_tape_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-03-02 23:27:58 +08:00
|
|
|
static int idetape_ioctl(struct block_device *bdev, fmode_t mode,
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
2008-10-14 03:39:34 +08:00
|
|
|
struct ide_tape_obj *tape = ide_drv_g(bdev->bd_disk, ide_tape_obj);
|
2005-04-17 06:20:36 +08:00
|
|
|
ide_drive_t *drive = tape->drive;
|
2010-07-08 16:18:46 +08:00
|
|
|
int err;
|
|
|
|
|
2010-06-02 20:28:52 +08:00
|
|
|
mutex_lock(&ide_tape_mutex);
|
2010-07-08 16:18:46 +08:00
|
|
|
err = generic_ide_ioctl(drive, bdev, cmd, arg);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (err == -EINVAL)
|
|
|
|
err = idetape_blkdev_ioctl(drive, cmd, arg);
|
2010-06-02 20:28:52 +08:00
|
|
|
mutex_unlock(&ide_tape_mutex);
|
2010-07-08 16:18:46 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2019-11-29 00:14:59 +08:00
|
|
|
static int idetape_compat_ioctl(struct block_device *bdev, fmode_t mode,
|
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
if (cmd == 0x0340 || cmd == 0x350)
|
|
|
|
arg = (unsigned long)compat_ptr(arg);
|
|
|
|
|
|
|
|
return idetape_ioctl(bdev, mode, cmd, arg);
|
|
|
|
}
|
|
|
|
|
2009-09-22 08:01:13 +08:00
|
|
|
static const struct block_device_operations idetape_block_ops = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.owner = THIS_MODULE,
|
2008-03-02 23:27:58 +08:00
|
|
|
.open = idetape_open,
|
|
|
|
.release = idetape_release,
|
2010-07-08 16:18:46 +08:00
|
|
|
.ioctl = idetape_ioctl,
|
2019-11-29 00:14:59 +08:00
|
|
|
.compat_ioctl = IS_ENABLED(CONFIG_COMPAT) ?
|
|
|
|
idetape_compat_ioctl : NULL,
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2006-01-06 19:41:00 +08:00
|
|
|
static int ide_tape_probe(ide_drive_t *drive)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
idetape_tape_t *tape;
|
|
|
|
struct gendisk *g;
|
|
|
|
int minor;
|
|
|
|
|
2009-07-18 07:55:16 +08:00
|
|
|
ide_debug_log(IDE_DBG_FUNC, "enter");
|
|
|
|
|
|
|
|
if (!strstr(DRV_NAME, drive->driver_req))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto failed;
|
2008-10-11 04:39:24 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (drive->media != ide_tape)
|
|
|
|
goto failed;
|
2008-10-11 04:39:24 +08:00
|
|
|
|
2008-10-14 03:39:36 +08:00
|
|
|
if ((drive->dev_flags & IDE_DFLAG_ID_READ) &&
|
|
|
|
ide_check_atapi_device(drive, DRV_NAME) == 0) {
|
2008-02-06 09:57:54 +08:00
|
|
|
printk(KERN_ERR "ide-tape: %s: not supported by this version of"
|
|
|
|
" the driver\n", drive->name);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto failed;
|
|
|
|
}
|
2008-02-06 09:57:54 +08:00
|
|
|
tape = kzalloc(sizeof(idetape_tape_t), GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (tape == NULL) {
|
2008-02-06 09:57:54 +08:00
|
|
|
printk(KERN_ERR "ide-tape: %s: Can't allocate a tape struct\n",
|
|
|
|
drive->name);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
g = alloc_disk(1 << PARTN_BITS);
|
|
|
|
if (!g)
|
|
|
|
goto out_free_tape;
|
|
|
|
|
|
|
|
ide_init_disk(g, drive);
|
|
|
|
|
2009-02-26 03:28:24 +08:00
|
|
|
tape->dev.parent = &drive->gendev;
|
|
|
|
tape->dev.release = ide_tape_release;
|
2013-07-04 06:04:56 +08:00
|
|
|
dev_set_name(&tape->dev, "%s", dev_name(&drive->gendev));
|
2009-02-26 03:28:24 +08:00
|
|
|
|
|
|
|
if (device_register(&tape->dev))
|
|
|
|
goto out_free_disk;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
tape->drive = drive;
|
|
|
|
tape->driver = &idetape_driver;
|
|
|
|
tape->disk = g;
|
|
|
|
|
|
|
|
g->private_data = &tape->driver;
|
|
|
|
|
|
|
|
drive->driver_data = tape;
|
|
|
|
|
2006-03-23 19:00:45 +08:00
|
|
|
mutex_lock(&idetape_ref_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
for (minor = 0; idetape_devs[minor]; minor++)
|
|
|
|
;
|
|
|
|
idetape_devs[minor] = tape;
|
2006-03-23 19:00:45 +08:00
|
|
|
mutex_unlock(&idetape_ref_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
idetape_setup(drive, tape, minor);
|
|
|
|
|
2008-07-22 11:03:34 +08:00
|
|
|
device_create(idetape_sysfs_class, &drive->gendev,
|
|
|
|
MKDEV(IDETAPE_MAJOR, minor), NULL, "%s", tape->name);
|
|
|
|
device_create(idetape_sysfs_class, &drive->gendev,
|
|
|
|
MKDEV(IDETAPE_MAJOR, minor + 128), NULL,
|
|
|
|
"n%s", tape->name);
|
2005-09-16 17:55:07 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
g->fops = &idetape_block_ops;
|
|
|
|
ide_register_region(g);
|
|
|
|
|
|
|
|
return 0;
|
2005-05-26 20:55:34 +08:00
|
|
|
|
2009-02-26 03:28:24 +08:00
|
|
|
out_free_disk:
|
|
|
|
put_disk(g);
|
2005-04-17 06:20:36 +08:00
|
|
|
out_free_tape:
|
|
|
|
kfree(tape);
|
|
|
|
failed:
|
2005-05-26 20:55:34 +08:00
|
|
|
return -ENODEV;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-02-06 09:57:54 +08:00
|
|
|
static void __exit idetape_exit(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-05-26 20:55:34 +08:00
|
|
|
driver_unregister(&idetape_driver.gen_driver);
|
2005-09-16 17:55:07 +08:00
|
|
|
class_destroy(idetape_sysfs_class);
|
2005-04-17 06:20:36 +08:00
|
|
|
unregister_chrdev(IDETAPE_MAJOR, "ht");
|
|
|
|
}
|
|
|
|
|
2005-11-20 05:24:35 +08:00
|
|
|
static int __init idetape_init(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-09-16 17:55:07 +08:00
|
|
|
int error = 1;
|
|
|
|
idetape_sysfs_class = class_create(THIS_MODULE, "ide_tape");
|
|
|
|
if (IS_ERR(idetape_sysfs_class)) {
|
|
|
|
idetape_sysfs_class = NULL;
|
|
|
|
printk(KERN_ERR "Unable to create sysfs class for ide tapes\n");
|
|
|
|
error = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (register_chrdev(IDETAPE_MAJOR, "ht", &idetape_fops)) {
|
2008-02-06 09:57:54 +08:00
|
|
|
printk(KERN_ERR "ide-tape: Failed to register chrdev"
|
|
|
|
" interface\n");
|
2005-09-16 17:55:07 +08:00
|
|
|
error = -EBUSY;
|
|
|
|
goto out_free_class;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2005-09-16 17:55:07 +08:00
|
|
|
|
|
|
|
error = driver_register(&idetape_driver.gen_driver);
|
|
|
|
if (error)
|
2016-04-30 06:11:12 +08:00
|
|
|
goto out_free_chrdev;
|
2005-09-16 17:55:07 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2016-04-30 06:11:12 +08:00
|
|
|
out_free_chrdev:
|
|
|
|
unregister_chrdev(IDETAPE_MAJOR, "ht");
|
2005-09-16 17:55:07 +08:00
|
|
|
out_free_class:
|
|
|
|
class_destroy(idetape_sysfs_class);
|
|
|
|
out:
|
|
|
|
return error;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
[PATCH] ide: MODALIAS support for autoloading of ide-cd, ide-disk, ...
IDE: MODALIAS support for autoloading of ide-cd, ide-disk, ...
Add MODULE_ALIAS to IDE midlayer modules: ide-disk, ide-cd, ide-floppy and
ide-tape, to autoload these modules depending on the probed media type of
the IDE device.
It is used by udev and replaces the former agent shell script of the hotplug
package, which was required to lookup the media type in the proc filesystem.
Using proc was racy, cause the media file is created after the hotplug event
is sent out.
The module autoloading does not take any effect, until something like the
following udev rule is configured:
SUBSYSTEM=="ide", ACTION=="add", ENV{MODALIAS}=="?*", RUN+="/sbin/modprobe $env{MODALIAS}"
The module ide-scsi will not be autoloaded, cause it requires manual
configuration. It can't be, and never was supported for automatic setup in
the hotplug package. Adding a MODULE_ALIAS to ide-scsi for all supported
media types, would just lead to a default blacklist entry anyway.
$ modinfo ide-disk
filename: /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
description: ATA DISK Driver
alias: ide:*m-disk*
license: GPL
...
$ modprobe -vn ide:m-disk
insmod /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
$ cat /sys/bus/ide/devices/0.0/modalias
ide:m-disk
It also adds attributes to the IDE device:
$ tree /sys/bus/ide/devices/0.0/
/sys/bus/ide/devices/0.0/
|-- bus -> ../../../../../../../bus/ide
|-- drivename
|-- media
|-- modalias
|-- power
| |-- state
| `-- wakeup
`-- uevent
$ cat /sys/bus/ide/devices/0.0/{modalias,drivename,media}
ide:m-disk
hda
disk
Signed-off-by: Kay Sievers <kay.sievers@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-12-13 01:03:44 +08:00
|
|
|
MODULE_ALIAS("ide:*m-tape*");
|
2005-04-17 06:20:36 +08:00
|
|
|
module_init(idetape_init);
|
|
|
|
module_exit(idetape_exit);
|
|
|
|
MODULE_ALIAS_CHARDEV_MAJOR(IDETAPE_MAJOR);
|
2008-02-06 09:57:54 +08:00
|
|
|
MODULE_DESCRIPTION("ATAPI Streaming TAPE Driver");
|
|
|
|
MODULE_LICENSE("GPL");
|