ide-tape.c 83.1 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2 3
 * IDE ATAPI streaming tape driver.
 *
4 5
 * Copyright (C) 1995-1999  Gadi Oxman <gadio@netvision.net.il>
 * Copyright (C) 2003-2005  Bartlomiej Zolnierkiewicz
L
Linus Torvalds 已提交
6 7 8 9 10 11 12 13
 *
 * 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).
 *
14 15
 * For a historical changelog see
 * Documentation/ide/ChangeLog.ide-tape.1995-2002
L
Linus Torvalds 已提交
16 17
 */

18
#define IDETAPE_VERSION "1.20"
L
Linus Torvalds 已提交
19 20 21 22 23 24 25 26 27

#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>
28
#include <linux/jiffies.h>
L
Linus Torvalds 已提交
29 30 31 32 33 34 35 36 37
#include <linux/major.h>
#include <linux/errno.h>
#include <linux/genhd.h>
#include <linux/slab.h>
#include <linux/pci.h>
#include <linux/ide.h>
#include <linux/smp_lock.h>
#include <linux/completion.h>
#include <linux/bitops.h>
38
#include <linux/mutex.h>
39
#include <scsi/scsi.h>
L
Linus Torvalds 已提交
40 41

#include <asm/byteorder.h>
42 43 44
#include <linux/irq.h>
#include <linux/uaccess.h>
#include <linux/io.h>
L
Linus Torvalds 已提交
45 46 47
#include <asm/unaligned.h>
#include <linux/mtio.h>

48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
enum {
	/* output errors only */
	DBG_ERR =		(1 << 0),
	/* output all sense key/asc */
	DBG_SENSE =		(1 << 1),
	/* info regarding all chrdev-related procedures */
	DBG_CHRDEV =		(1 << 2),
	/* all remaining procedures */
	DBG_PROCS =		(1 << 3),
	/* buffer alloc info (pc_stack & rq_stack) */
	DBG_PCRQ_STACK =	(1 << 4),
};

/* define to see debug info */
#define IDETAPE_DEBUG_LOG		0

#if IDETAPE_DEBUG_LOG
#define debug_log(lvl, fmt, args...)			\
{							\
	if (tape->debug_mask & lvl)			\
	printk(KERN_INFO "ide-tape: " fmt, ## args);	\
}
#else
#define debug_log(lvl, fmt, args...) do {} while (0)
#endif

L
Linus Torvalds 已提交
74 75
/**************************** Tunable parameters *****************************/
/*
76 77
 * After each failed packet command we issue a request sense command and retry
 * the packet command IDETAPE_MAX_PC_RETRIES times.
L
Linus Torvalds 已提交
78
 *
79
 * Setting IDETAPE_MAX_PC_RETRIES to 0 will disable retries.
L
Linus Torvalds 已提交
80 81 82 83
 */
#define IDETAPE_MAX_PC_RETRIES		3

/*
84 85
 * With each packet command, we allocate a buffer of IDETAPE_PC_BUFFER_SIZE
 * bytes. This is used for several packet commands (Not for READ/WRITE commands)
L
Linus Torvalds 已提交
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
 */
#define IDETAPE_PC_BUFFER_SIZE		256

/*
 *	In various places in the driver, we need to allocate storage
 *	for packet commands and requests, which will remain valid while
 *	we leave the driver to wait for an interrupt or a timeout event.
 */
#define IDETAPE_PC_STACK		(10 + IDETAPE_MAX_PC_RETRIES)

/*
 * Some drives (for example, Seagate STT3401A Travan) require a very long
 * timeout, because they don't return an interrupt or clear their busy bit
 * until after the command completes (even retension commands).
 */
#define IDETAPE_WAIT_CMD		(900*HZ)

/*
104 105 106 107
 * 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.
L
Linus Torvalds 已提交
108
 */
109
#define IDETAPE_FIFO_THRESHOLD		2
L
Linus Torvalds 已提交
110 111

/*
112
 * DSC polling parameters.
L
Linus Torvalds 已提交
113
 *
114 115
 * 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:
L
Linus Torvalds 已提交
116
 *
117 118 119 120 121
 * 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.
L
Linus Torvalds 已提交
122
 *
123 124 125 126 127 128 129 130
 * 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).
L
Linus Torvalds 已提交
131
 *
132 133
 * 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.
L
Linus Torvalds 已提交
134
 */
135 136

/* DSC timings. */
L
Linus Torvalds 已提交
137 138 139 140 141 142 143 144 145 146
#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 ***********************/

147
/* Read/Write error simulation */
L
Linus Torvalds 已提交
148 149
#define SIMULATE_ERRORS			0

150 151 152 153 154 155
/* tape directions */
enum {
	IDETAPE_DIR_NONE  = (1 << 0),
	IDETAPE_DIR_READ  = (1 << 1),
	IDETAPE_DIR_WRITE = (1 << 2),
};
L
Linus Torvalds 已提交
156 157

struct idetape_bh {
158
	u32 b_size;
L
Linus Torvalds 已提交
159 160 161 162 163
	atomic_t b_count;
	struct idetape_bh *b_reqnext;
	char *b_data;
};

164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
/* 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

/*
 * Special requests for our block device strategy routine.
 *
 * In order to service a character device command, we add special requests to
 * the tail of our block device request queue and wait for their completion.
 */

enum {
	REQ_IDETAPE_PC1		= (1 << 0), /* packet command (first stage) */
	REQ_IDETAPE_PC2		= (1 << 1), /* packet command (second stage) */
	REQ_IDETAPE_READ	= (1 << 2),
	REQ_IDETAPE_WRITE	= (1 << 3),
};

/* Error codes returned in rq->errors to the higher part of the driver. */
#define IDETAPE_ERROR_GENERAL		101
#define IDETAPE_ERROR_FILEMARK		102
#define IDETAPE_ERROR_EOD		103

/* Structures related to the SELECT SENSE / MODE SENSE packet commands. */
#define IDETAPE_BLOCK_DESCRIPTOR	0
#define IDETAPE_CAPABILITIES_PAGE	0x2a

201 202 203 204 205 206
/* Tape flag bits values. */
enum {
	IDETAPE_FLAG_IGNORE_DSC		= (1 << 0),
	/* 0 When the tape position is unknown */
	IDETAPE_FLAG_ADDRESS_VALID	= (1 <<	1),
	/* Device already opened */
207
	IDETAPE_FLAG_BUSY		= (1 << 2),
208
	/* Attempt to auto-detect the current user block size */
209
	IDETAPE_FLAG_DETECT_BS		= (1 << 3),
210
	/* Currently on a filemark */
211
	IDETAPE_FLAG_FILEMARK		= (1 << 4),
212
	/* DRQ interrupt device */
213
	IDETAPE_FLAG_DRQ_INTERRUPT	= (1 << 5),
214
	/* 0 = no tape is loaded, so we don't rewind after ejecting */
215
	IDETAPE_FLAG_MEDIUM_PRESENT	= (1 << 6),
216 217
};

L
Linus Torvalds 已提交
218
/*
219 220
 * 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.
L
Linus Torvalds 已提交
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
 */
typedef struct ide_tape_obj {
	ide_drive_t	*drive;
	ide_driver_t	*driver;
	struct gendisk	*disk;
	struct kref	kref;

	/*
	 *	Since a typical character device operation requires more
	 *	than one packet command, we provide here enough memory
	 *	for the maximum of interconnected packet commands.
	 *	The packet commands are stored in the circular array pc_stack.
	 *	pc_stack_index points to the last used entry, and warps around
	 *	to the start when we get to the last array entry.
	 *
	 *	pc points to the current processed packet command.
	 *
	 *	failed_pc points to the last failed packet command, or contains
	 *	NULL if we do not need to retry any packet command. This is
	 *	required since an additional packet command is needed before the
	 *	retry, to get detailed information on what went wrong.
	 */
	/* Current packet command */
244
	struct ide_atapi_pc *pc;
L
Linus Torvalds 已提交
245
	/* Last failed packet command */
246
	struct ide_atapi_pc *failed_pc;
L
Linus Torvalds 已提交
247
	/* Packet command stack */
248
	struct ide_atapi_pc pc_stack[IDETAPE_PC_STACK];
L
Linus Torvalds 已提交
249 250 251 252 253 254 255
	/* Next free packet command storage space */
	int pc_stack_index;
	struct request rq_stack[IDETAPE_PC_STACK];
	/* We implement a circular array */
	int rq_stack_index;

	/*
256
	 * DSC polling variables.
L
Linus Torvalds 已提交
257
	 *
258 259 260
	 * 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
261
	 * data transfer) request in the device request queue.
L
Linus Torvalds 已提交
262 263 264 265 266 267 268
	 */
	struct request *postponed_rq;
	/* 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 */
269 270
	unsigned long best_dsc_rw_freq;
	unsigned long dsc_poll_freq;
L
Linus Torvalds 已提交
271 272
	unsigned long dsc_timeout;

273
	/* Read position information */
L
Linus Torvalds 已提交
274 275
	u8 partition;
	/* Current block */
276
	unsigned int first_frame;
L
Linus Torvalds 已提交
277

278
	/* Last error information */
L
Linus Torvalds 已提交
279 280
	u8 sense_key, asc, ascq;

281
	/* Character device operation */
L
Linus Torvalds 已提交
282 283 284 285
	unsigned int minor;
	/* device name */
	char name[4];
	/* Current character device data transfer direction */
286
	u8 chrdev_dir;
L
Linus Torvalds 已提交
287

288 289
	/* tape block size, usually 512 or 1024 bytes */
	unsigned short blk_size;
L
Linus Torvalds 已提交
290
	int user_bs_factor;
291

L
Linus Torvalds 已提交
292
	/* Copy of the tape's Capabilities and Mechanical Page */
293
	u8 caps[20];
L
Linus Torvalds 已提交
294 295

	/*
296
	 * Active data transfer request parameters.
L
Linus Torvalds 已提交
297
	 *
298 299 300
	 * 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.
L
Linus Torvalds 已提交
301
	 */
302

303
	/* Data buffer size chosen based on the tape's recommendation */
304
	int buffer_size;
305 306
	/* merge buffer */
	struct idetape_bh *merge_bh;
307 308
	/* size of the merge buffer */
	int merge_bh_size;
309
	/* pointer to current buffer head within the merge buffer */
L
Linus Torvalds 已提交
310 311 312
	struct idetape_bh *bh;
	char *b_data;
	int b_count;
313

314
	int pages_per_buffer;
L
Linus Torvalds 已提交
315 316 317 318 319 320
	/* Wasted space in each stage */
	int excess_bh_size;

	/* Status/Action flags: long for set_bit */
	unsigned long flags;
	/* protects the ide-tape queue */
321
	spinlock_t lock;
L
Linus Torvalds 已提交
322

323
	/* Measures average tape speed */
L
Linus Torvalds 已提交
324 325 326 327 328 329 330 331 332 333 334
	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;

335
	u32 debug_mask;
L
Linus Torvalds 已提交
336 337
} idetape_tape_t;

338
static DEFINE_MUTEX(idetape_ref_mutex);
L
Linus Torvalds 已提交
339

340 341
static struct class *idetape_sysfs_class;

L
Linus Torvalds 已提交
342 343 344 345 346 347 348 349 350
#define to_ide_tape(obj) container_of(obj, struct ide_tape_obj, kref)

#define ide_tape_g(disk) \
	container_of((disk)->private_data, struct ide_tape_obj, driver)

static struct ide_tape_obj *ide_tape_get(struct gendisk *disk)
{
	struct ide_tape_obj *tape = NULL;

351
	mutex_lock(&idetape_ref_mutex);
L
Linus Torvalds 已提交
352 353 354
	tape = ide_tape_g(disk);
	if (tape)
		kref_get(&tape->kref);
355
	mutex_unlock(&idetape_ref_mutex);
L
Linus Torvalds 已提交
356 357 358 359 360 361 362
	return tape;
}

static void ide_tape_release(struct kref *);

static void ide_tape_put(struct ide_tape_obj *tape)
{
363
	mutex_lock(&idetape_ref_mutex);
L
Linus Torvalds 已提交
364
	kref_put(&tape->kref, ide_tape_release);
365
	mutex_unlock(&idetape_ref_mutex);
L
Linus Torvalds 已提交
366 367 368
}

/*
369 370
 * The variables below are used for the character device interface. Additional
 * state variables are defined in our ide_drive_t structure.
L
Linus Torvalds 已提交
371
 */
372
static struct ide_tape_obj *idetape_devs[MAX_HWIFS * MAX_DRIVES];
L
Linus Torvalds 已提交
373 374 375 376 377 378 379

#define ide_tape_f(file) ((file)->private_data)

static struct ide_tape_obj *ide_tape_chrdev_get(unsigned int i)
{
	struct ide_tape_obj *tape = NULL;

380
	mutex_lock(&idetape_ref_mutex);
L
Linus Torvalds 已提交
381 382 383
	tape = idetape_devs[i];
	if (tape)
		kref_get(&tape->kref);
384
	mutex_unlock(&idetape_ref_mutex);
L
Linus Torvalds 已提交
385 386 387
	return tape;
}

388
static void idetape_input_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
389
				  unsigned int bcount)
L
Linus Torvalds 已提交
390 391 392 393 394 395 396 397
{
	struct idetape_bh *bh = pc->bh;
	int count;

	while (bcount) {
		if (bh == NULL) {
			printk(KERN_ERR "ide-tape: bh == NULL in "
				"idetape_input_buffers\n");
398
			ide_pad_transfer(drive, 0, bcount);
L
Linus Torvalds 已提交
399 400
			return;
		}
401 402 403
		count = min(
			(unsigned int)(bh->b_size - atomic_read(&bh->b_count)),
			bcount);
404
		drive->hwif->input_data(drive, NULL, bh->b_data +
405
					atomic_read(&bh->b_count), count);
L
Linus Torvalds 已提交
406 407 408 409 410 411 412 413 414 415 416
		bcount -= count;
		atomic_add(count, &bh->b_count);
		if (atomic_read(&bh->b_count) == bh->b_size) {
			bh = bh->b_reqnext;
			if (bh)
				atomic_set(&bh->b_count, 0);
		}
	}
	pc->bh = bh;
}

417
static void idetape_output_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
418
				   unsigned int bcount)
L
Linus Torvalds 已提交
419 420 421 422 423 424
{
	struct idetape_bh *bh = pc->bh;
	int count;

	while (bcount) {
		if (bh == NULL) {
425 426
			printk(KERN_ERR "ide-tape: bh == NULL in %s\n",
					__func__);
L
Linus Torvalds 已提交
427 428 429
			return;
		}
		count = min((unsigned int)pc->b_count, (unsigned int)bcount);
430
		drive->hwif->output_data(drive, NULL, pc->b_data, count);
L
Linus Torvalds 已提交
431 432 433 434
		bcount -= count;
		pc->b_data += count;
		pc->b_count -= count;
		if (!pc->b_count) {
435 436
			bh = bh->b_reqnext;
			pc->bh = bh;
L
Linus Torvalds 已提交
437 438 439 440 441 442 443 444
			if (bh) {
				pc->b_data = bh->b_data;
				pc->b_count = atomic_read(&bh->b_count);
			}
		}
	}
}

445
static void idetape_update_buffers(struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
446 447 448
{
	struct idetape_bh *bh = pc->bh;
	int count;
449
	unsigned int bcount = pc->xferred;
L
Linus Torvalds 已提交
450

451
	if (pc->flags & PC_FLAG_WRITING)
L
Linus Torvalds 已提交
452 453 454
		return;
	while (bcount) {
		if (bh == NULL) {
455 456
			printk(KERN_ERR "ide-tape: bh == NULL in %s\n",
					__func__);
L
Linus Torvalds 已提交
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
			return;
		}
		count = min((unsigned int)bh->b_size, (unsigned int)bcount);
		atomic_set(&bh->b_count, count);
		if (atomic_read(&bh->b_count) == bh->b_size)
			bh = bh->b_reqnext;
		bcount -= count;
	}
	pc->bh = bh;
}

/*
 *	idetape_next_pc_storage returns a pointer to a place in which we can
 *	safely store a packet command, even though we intend to leave the
 *	driver. A storage space for a maximum of IDETAPE_PC_STACK packet
 *	commands is allocated at initialization time.
 */
474
static struct ide_atapi_pc *idetape_next_pc_storage(ide_drive_t *drive)
L
Linus Torvalds 已提交
475 476 477
{
	idetape_tape_t *tape = drive->driver_data;

478 479
	debug_log(DBG_PCRQ_STACK, "pc_stack_index=%d\n", tape->pc_stack_index);

L
Linus Torvalds 已提交
480
	if (tape->pc_stack_index == IDETAPE_PC_STACK)
481
		tape->pc_stack_index = 0;
L
Linus Torvalds 已提交
482 483 484 485 486 487 488 489
	return (&tape->pc_stack[tape->pc_stack_index++]);
}

/*
 *	idetape_next_rq_storage is used along with idetape_next_pc_storage.
 *	Since we queue packet commands in the request queue, we need to
 *	allocate a request, along with the allocation of a packet command.
 */
490

L
Linus Torvalds 已提交
491 492 493 494 495 496
/**************************************************************
 *                                                            *
 *  This should get fixed to use kmalloc(.., GFP_ATOMIC)      *
 *  followed later on by kfree().   -ml                       *
 *                                                            *
 **************************************************************/
497 498

static struct request *idetape_next_rq_storage(ide_drive_t *drive)
L
Linus Torvalds 已提交
499 500 501
{
	idetape_tape_t *tape = drive->driver_data;

502 503
	debug_log(DBG_PCRQ_STACK, "rq_stack_index=%d\n", tape->rq_stack_index);

L
Linus Torvalds 已提交
504
	if (tape->rq_stack_index == IDETAPE_PC_STACK)
505
		tape->rq_stack_index = 0;
L
Linus Torvalds 已提交
506 507 508
	return (&tape->rq_stack[tape->rq_stack_index++]);
}

509
static void idetape_init_pc(struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
510 511 512 513
{
	memset(pc->c, 0, 12);
	pc->retries = 0;
	pc->flags = 0;
514 515 516
	pc->req_xfer = 0;
	pc->buf = pc->pc_buf;
	pc->buf_size = IDETAPE_PC_BUFFER_SIZE;
L
Linus Torvalds 已提交
517 518 519 520 521
	pc->bh = NULL;
	pc->b_data = NULL;
}

/*
522 523
 * called on each failed packet command retry to analyze the request sense. We
 * currently do not utilize this information.
L
Linus Torvalds 已提交
524
 */
525
static void idetape_analyze_error(ide_drive_t *drive, u8 *sense)
L
Linus Torvalds 已提交
526 527
{
	idetape_tape_t *tape = drive->driver_data;
528
	struct ide_atapi_pc *pc = tape->failed_pc;
L
Linus Torvalds 已提交
529

530 531 532
	tape->sense_key = sense[2] & 0xF;
	tape->asc       = sense[12];
	tape->ascq      = sense[13];
533 534 535

	debug_log(DBG_ERR, "pc = %x, sense key = %x, asc = %x, ascq = %x\n",
		 pc->c[0], tape->sense_key, tape->asc, tape->ascq);
L
Linus Torvalds 已提交
536

537
	/* Correct pc->xferred by asking the tape.	 */
538
	if (pc->flags & PC_FLAG_DMA_ERROR) {
539
		pc->xferred = pc->req_xfer -
540
			tape->blk_size *
541
			be32_to_cpu(get_unaligned((u32 *)&sense[3]));
L
Linus Torvalds 已提交
542 543 544 545 546 547 548 549
		idetape_update_buffers(pc);
	}

	/*
	 * 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.
	 */
550
	if ((pc->c[0] == READ_6 || pc->c[0] == WRITE_6)
551 552 553
	    /* length == 0 */
	    && pc->c[4] == 0 && pc->c[3] == 0 && pc->c[2] == 0) {
		if (tape->sense_key == 5) {
L
Linus Torvalds 已提交
554 555 556
			/* don't report an error, everything's ok */
			pc->error = 0;
			/* don't retry read/write */
557
			pc->flags |= PC_FLAG_ABORT;
L
Linus Torvalds 已提交
558 559
		}
	}
560
	if (pc->c[0] == READ_6 && (sense[2] & 0x80)) {
L
Linus Torvalds 已提交
561
		pc->error = IDETAPE_ERROR_FILEMARK;
562
		pc->flags |= PC_FLAG_ABORT;
L
Linus Torvalds 已提交
563
	}
564
	if (pc->c[0] == WRITE_6) {
565 566
		if ((sense[2] & 0x40) || (tape->sense_key == 0xd
		     && tape->asc == 0x0 && tape->ascq == 0x2)) {
L
Linus Torvalds 已提交
567
			pc->error = IDETAPE_ERROR_EOD;
568
			pc->flags |= PC_FLAG_ABORT;
L
Linus Torvalds 已提交
569 570
		}
	}
571
	if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) {
572
		if (tape->sense_key == 8) {
L
Linus Torvalds 已提交
573
			pc->error = IDETAPE_ERROR_EOD;
574
			pc->flags |= PC_FLAG_ABORT;
L
Linus Torvalds 已提交
575
		}
576
		if (!(pc->flags & PC_FLAG_ABORT) &&
577
		    pc->xferred)
L
Linus Torvalds 已提交
578 579 580 581
			pc->retries = IDETAPE_MAX_PC_RETRIES + 1;
	}
}

582
/* Free data buffers completely. */
583
static void ide_tape_kfree_buffer(idetape_tape_t *tape)
L
Linus Torvalds 已提交
584
{
585
	struct idetape_bh *prev_bh, *bh = tape->merge_bh;
586 587 588 589 590 591 592 593 594 595 596 597

	while (bh) {
		u32 size = bh->b_size;

		while (size) {
			unsigned int order = fls(size >> PAGE_SHIFT)-1;

			if (bh->b_data)
				free_pages((unsigned long)bh->b_data, order);

			size &= (order-1);
			bh->b_data += (1 << order) * PAGE_SIZE;
L
Linus Torvalds 已提交
598 599 600 601 602
		}
		prev_bh = bh;
		bh = bh->b_reqnext;
		kfree(prev_bh);
	}
603
	kfree(tape->merge_bh);
L
Linus Torvalds 已提交
604 605 606 607 608 609 610 611 612
}

static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects)
{
	struct request *rq = HWGROUP(drive)->rq;
	idetape_tape_t *tape = drive->driver_data;
	unsigned long flags;
	int error;

613
	debug_log(DBG_PROCS, "Enter %s\n", __func__);
L
Linus Torvalds 已提交
614 615

	switch (uptodate) {
616 617 618
	case 0:	error = IDETAPE_ERROR_GENERAL; break;
	case 1: error = 0; break;
	default: error = uptodate;
L
Linus Torvalds 已提交
619 620 621 622 623
	}
	rq->errors = error;
	if (error)
		tape->failed_pc = NULL;

624 625 626 627 628
	if (!blk_special_request(rq)) {
		ide_end_request(drive, uptodate, nr_sects);
		return 0;
	}

629
	spin_lock_irqsave(&tape->lock, flags);
L
Linus Torvalds 已提交
630 631 632

	ide_end_drive_cmd(drive, 0, 0);

633
	spin_unlock_irqrestore(&tape->lock, flags);
L
Linus Torvalds 已提交
634 635 636
	return 0;
}

637
static ide_startstop_t idetape_request_sense_callback(ide_drive_t *drive)
L
Linus Torvalds 已提交
638 639 640
{
	idetape_tape_t *tape = drive->driver_data;

641 642
	debug_log(DBG_PROCS, "Enter %s\n", __func__);

L
Linus Torvalds 已提交
643
	if (!tape->pc->error) {
644
		idetape_analyze_error(drive, tape->pc->buf);
L
Linus Torvalds 已提交
645 646
		idetape_end_request(drive, 1, 0);
	} else {
647 648
		printk(KERN_ERR "ide-tape: Error in REQUEST SENSE itself - "
				"Aborting request!\n");
L
Linus Torvalds 已提交
649 650 651 652 653
		idetape_end_request(drive, 0, 0);
	}
	return ide_stopped;
}

654
static void idetape_create_request_sense_cmd(struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
655
{
656
	idetape_init_pc(pc);
657
	pc->c[0] = REQUEST_SENSE;
L
Linus Torvalds 已提交
658
	pc->c[4] = 20;
659 660
	pc->req_xfer = 20;
	pc->idetape_callback = &idetape_request_sense_callback;
L
Linus Torvalds 已提交
661 662 663 664
}

static void idetape_init_rq(struct request *rq, u8 cmd)
{
665
	blk_rq_init(NULL, rq);
666
	rq->cmd_type = REQ_TYPE_SPECIAL;
L
Linus Torvalds 已提交
667 668 669 670
	rq->cmd[0] = cmd;
}

/*
671 672 673 674 675
 * Generate a new packet command request in front of the request queue, before
 * the current request, so that it will be processed immediately, on the next
 * pass through the driver. The function below is called from the request
 * handling part of the driver (the "bottom" part). Safe storage for the request
 * should be allocated with ide_tape_next_{pc,rq}_storage() prior to that.
L
Linus Torvalds 已提交
676
 *
677 678 679
 * Memory for those requests is pre-allocated at initialization time, and is
 * limited to IDETAPE_PC_STACK requests. We assume that we have enough space for
 * the maximum possible number of inter-dependent packet commands.
L
Linus Torvalds 已提交
680
 *
681 682 683
 * The higher level of the driver - The ioctl handler and the character device
 * handling functions should queue request to the lower level part and wait for
 * their completion using idetape_queue_pc_tail or idetape_queue_rw_tail.
L
Linus Torvalds 已提交
684
 */
685
static void idetape_queue_pc_head(ide_drive_t *drive, struct ide_atapi_pc *pc,
686
				  struct request *rq)
L
Linus Torvalds 已提交
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
{
	struct ide_tape_obj *tape = drive->driver_data;

	idetape_init_rq(rq, REQ_IDETAPE_PC1);
	rq->buffer = (char *) pc;
	rq->rq_disk = tape->disk;
	(void) ide_do_drive_cmd(drive, rq, ide_preempt);
}

/*
 *	idetape_retry_pc is called when an error was detected during the
 *	last packet command. We queue a request sense packet command in
 *	the head of the request list.
 */
static ide_startstop_t idetape_retry_pc (ide_drive_t *drive)
{
	idetape_tape_t *tape = drive->driver_data;
704
	struct ide_atapi_pc *pc;
L
Linus Torvalds 已提交
705 706
	struct request *rq;

707
	(void)ide_read_error(drive);
L
Linus Torvalds 已提交
708 709 710
	pc = idetape_next_pc_storage(drive);
	rq = idetape_next_rq_storage(drive);
	idetape_create_request_sense_cmd(pc);
711
	set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags);
L
Linus Torvalds 已提交
712 713 714 715 716
	idetape_queue_pc_head(drive, pc, rq);
	return ide_stopped;
}

/*
717 718
 * Postpone the current request so that ide.c will be able to service requests
 * from another device on the same hwgroup while we are polling for DSC.
L
Linus Torvalds 已提交
719
 */
720
static void idetape_postpone_request(ide_drive_t *drive)
L
Linus Torvalds 已提交
721 722 723
{
	idetape_tape_t *tape = drive->driver_data;

724 725
	debug_log(DBG_PROCS, "Enter %s\n", __func__);

L
Linus Torvalds 已提交
726
	tape->postponed_rq = HWGROUP(drive)->rq;
727
	ide_stall_queue(drive, tape->dsc_poll_freq);
L
Linus Torvalds 已提交
728 729
}

730
typedef void idetape_io_buf(ide_drive_t *, struct ide_atapi_pc *, unsigned int);
731

L
Linus Torvalds 已提交
732
/*
733 734 735 736
 * This is the usual interrupt handler which will be called during a packet
 * command. We will transfer some of the data (as requested by the drive) and
 * will re-point interrupt handler to us. When data transfer is finished, we
 * will act according to the algorithm described before
737
 * idetape_issue_pc.
L
Linus Torvalds 已提交
738
 */
739
static ide_startstop_t idetape_pc_intr(ide_drive_t *drive)
L
Linus Torvalds 已提交
740 741 742
{
	ide_hwif_t *hwif = drive->hwif;
	idetape_tape_t *tape = drive->driver_data;
743
	struct ide_atapi_pc *pc = tape->pc;
744 745
	xfer_func_t *xferfunc;
	idetape_io_buf *iobuf;
L
Linus Torvalds 已提交
746 747
	unsigned int temp;
#if SIMULATE_ERRORS
748
	static int error_sim_count;
L
Linus Torvalds 已提交
749
#endif
750
	u16 bcount;
751
	u8 stat, ireason;
L
Linus Torvalds 已提交
752

753
	debug_log(DBG_PROCS, "Enter %s - interrupt handler\n", __func__);
L
Linus Torvalds 已提交
754 755

	/* Clear the interrupt */
756
	stat = ide_read_status(drive);
L
Linus Torvalds 已提交
757

758
	if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
759
		if (hwif->dma_ops->dma_end(drive) || (stat & ERR_STAT)) {
L
Linus Torvalds 已提交
760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
			/*
			 * A DMA error is sometimes expected. For example,
			 * if the tape is crossing a filemark during a
			 * READ command, it will issue an irq and position
			 * itself before the filemark, so that only a partial
			 * data transfer will occur (which causes the DMA
			 * error). In that case, we will later ask the tape
			 * how much bytes of the original request were
			 * actually transferred (we can't receive that
			 * information from the DMA engine on most chipsets).
			 */

			/*
			 * On the contrary, a DMA error is never expected;
			 * it usually indicates a hardware error or abort.
			 * If the tape crosses a filemark during a READ
			 * command, it will issue an irq and position itself
			 * after the filemark (not before). Only a partial
			 * data transfer will occur, but no DMA error.
			 * (AS, 19 Apr 2001)
			 */
781
			pc->flags |= PC_FLAG_DMA_ERROR;
L
Linus Torvalds 已提交
782
		} else {
783
			pc->xferred = pc->req_xfer;
L
Linus Torvalds 已提交
784 785
			idetape_update_buffers(pc);
		}
786 787
		debug_log(DBG_PROCS, "DMA finished\n");

L
Linus Torvalds 已提交
788 789 790
	}

	/* No more interrupts */
791
	if ((stat & DRQ_STAT) == 0) {
792
		debug_log(DBG_SENSE, "Packet command completed, %d bytes"
793
				" transferred\n", pc->xferred);
L
Linus Torvalds 已提交
794

795
		pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
L
Linus Torvalds 已提交
796 797 798
		local_irq_enable();

#if SIMULATE_ERRORS
799
		if ((pc->c[0] == WRITE_6 || pc->c[0] == READ_6) &&
L
Linus Torvalds 已提交
800 801 802
		    (++error_sim_count % 100) == 0) {
			printk(KERN_INFO "ide-tape: %s: simulating error\n",
				tape->name);
803
			stat |= ERR_STAT;
L
Linus Torvalds 已提交
804 805
		}
#endif
806
		if ((stat & ERR_STAT) && pc->c[0] == REQUEST_SENSE)
807
			stat &= ~ERR_STAT;
808
		if ((stat & ERR_STAT) || (pc->flags & PC_FLAG_DMA_ERROR)) {
809
			/* Error detected */
810 811
			debug_log(DBG_ERR, "%s: I/O error\n", tape->name);

812
			if (pc->c[0] == REQUEST_SENSE) {
813 814
				printk(KERN_ERR "ide-tape: I/O error in request"
						" sense command\n");
L
Linus Torvalds 已提交
815 816
				return ide_do_reset(drive);
			}
817 818 819
			debug_log(DBG_ERR, "[cmd %x]: check condition\n",
					pc->c[0]);

L
Linus Torvalds 已提交
820 821 822 823
			/* Retry operation */
			return idetape_retry_pc(drive);
		}
		pc->error = 0;
824
		if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) &&
825
		    (stat & SEEK_STAT) == 0) {
L
Linus Torvalds 已提交
826 827
			/* Media access command */
			tape->dsc_polling_start = jiffies;
828
			tape->dsc_poll_freq = IDETAPE_DSC_MA_FAST;
L
Linus Torvalds 已提交
829 830 831 832 833 834 835 836
			tape->dsc_timeout = jiffies + IDETAPE_DSC_MA_TIMEOUT;
			/* Allow ide.c to handle other requests */
			idetape_postpone_request(drive);
			return ide_stopped;
		}
		if (tape->failed_pc == pc)
			tape->failed_pc = NULL;
		/* Command finished - Call the callback function */
837
		return pc->idetape_callback(drive);
L
Linus Torvalds 已提交
838
	}
839 840 841

	if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
		pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
L
Linus Torvalds 已提交
842 843 844
		printk(KERN_ERR "ide-tape: The tape wants to issue more "
				"interrupts in DMA mode\n");
		printk(KERN_ERR "ide-tape: DMA disabled, reverting to PIO\n");
845
		ide_dma_off(drive);
L
Linus Torvalds 已提交
846 847 848
		return ide_do_reset(drive);
	}
	/* Get the number of bytes to transfer on this interrupt. */
849 850
	bcount = (hwif->INB(hwif->io_ports.lbah_addr) << 8) |
		  hwif->INB(hwif->io_ports.lbam_addr);
L
Linus Torvalds 已提交
851

852
	ireason = hwif->INB(hwif->io_ports.nsect_addr);
L
Linus Torvalds 已提交
853

854
	if (ireason & CD) {
855
		printk(KERN_ERR "ide-tape: CoD != 0 in %s\n", __func__);
L
Linus Torvalds 已提交
856 857
		return ide_do_reset(drive);
	}
858
	if (((ireason & IO) == IO) == !!(pc->flags & PC_FLAG_WRITING)) {
L
Linus Torvalds 已提交
859 860
		/* Hopefully, we will never get here */
		printk(KERN_ERR "ide-tape: We wanted to %s, ",
861
				(ireason & IO) ? "Write" : "Read");
L
Linus Torvalds 已提交
862
		printk(KERN_ERR "ide-tape: but the tape wants us to %s !\n",
863
				(ireason & IO) ? "Read" : "Write");
L
Linus Torvalds 已提交
864 865
		return ide_do_reset(drive);
	}
866
	if (!(pc->flags & PC_FLAG_WRITING)) {
L
Linus Torvalds 已提交
867
		/* Reading - Check that we have enough space */
868 869 870
		temp = pc->xferred + bcount;
		if (temp > pc->req_xfer) {
			if (temp > pc->buf_size) {
871 872 873
				printk(KERN_ERR "ide-tape: The tape wants to "
					"send us more data than expected "
					"- discarding data\n");
874
				ide_pad_transfer(drive, 0, bcount);
875 876
				ide_set_handler(drive, &idetape_pc_intr,
						IDETAPE_WAIT_CMD, NULL);
L
Linus Torvalds 已提交
877 878
				return ide_started;
			}
879 880
			debug_log(DBG_SENSE, "The tape wants to send us more "
				"data than expected - allowing transfer\n");
L
Linus Torvalds 已提交
881
		}
882
		iobuf = &idetape_input_buffers;
883
		xferfunc = hwif->input_data;
L
Linus Torvalds 已提交
884
	} else {
885
		iobuf = &idetape_output_buffers;
886
		xferfunc = hwif->output_data;
L
Linus Torvalds 已提交
887
	}
888 889 890 891

	if (pc->bh)
		iobuf(drive, pc, bcount);
	else
892
		xferfunc(drive, NULL, pc->cur_pos, bcount);
893

L
Linus Torvalds 已提交
894
	/* Update the current position */
895 896
	pc->xferred += bcount;
	pc->cur_pos += bcount;
897 898 899 900

	debug_log(DBG_SENSE, "[cmd %x] transferred %d bytes on that intr.\n",
			pc->c[0], bcount);

L
Linus Torvalds 已提交
901 902 903 904 905 906
	/* And set the interrupt handler again */
	ide_set_handler(drive, &idetape_pc_intr, IDETAPE_WAIT_CMD, NULL);
	return ide_started;
}

/*
907
 * Packet Command Interface
L
Linus Torvalds 已提交
908
 *
909 910 911
 * The current Packet Command is available in tape->pc, and will not change
 * until we finish handling it. Each packet command is associated with a
 * callback function that will be called when the command is finished.
L
Linus Torvalds 已提交
912
 *
913
 * The handling will be done in three stages:
L
Linus Torvalds 已提交
914
 *
915 916
 * 1. idetape_issue_pc will send the packet command to the drive, and will set
 * the interrupt handler to idetape_pc_intr.
L
Linus Torvalds 已提交
917
 *
918 919
 * 2. On each interrupt, idetape_pc_intr will be called. This step will be
 * repeated until the device signals us that no more interrupts will be issued.
L
Linus Torvalds 已提交
920
 *
921 922 923 924 925 926 927
 * 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.
L
Linus Torvalds 已提交
928
 *
929 930
 * ide.c will then give higher priority to requests which originate from the
 * other device, until will change rq_status to RQ_ACTIVE.
L
Linus Torvalds 已提交
931
 *
932
 * 4. When the packet command is finished, it will be checked for errors.
L
Linus Torvalds 已提交
933
 *
934 935 936
 * 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.
L
Linus Torvalds 已提交
937
 *
938 939 940
 * 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.
L
Linus Torvalds 已提交
941 942 943 944 945
 */
static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive)
{
	ide_hwif_t *hwif = drive->hwif;
	idetape_tape_t *tape = drive->driver_data;
946
	struct ide_atapi_pc *pc = tape->pc;
L
Linus Torvalds 已提交
947 948
	int retries = 100;
	ide_startstop_t startstop;
949
	u8 ireason;
L
Linus Torvalds 已提交
950

951 952 953
	if (ide_wait_stat(&startstop, drive, DRQ_STAT, BUSY_STAT, WAIT_READY)) {
		printk(KERN_ERR "ide-tape: Strange, packet command initiated "
				"yet DRQ isn't asserted\n");
L
Linus Torvalds 已提交
954 955
		return startstop;
	}
956
	ireason = hwif->INB(hwif->io_ports.nsect_addr);
957
	while (retries-- && ((ireason & CD) == 0 || (ireason & IO))) {
L
Linus Torvalds 已提交
958 959 960
		printk(KERN_ERR "ide-tape: (IO,CoD != (0,1) while issuing "
				"a packet command, retrying\n");
		udelay(100);
961
		ireason = hwif->INB(hwif->io_ports.nsect_addr);
L
Linus Torvalds 已提交
962 963 964
		if (retries == 0) {
			printk(KERN_ERR "ide-tape: (IO,CoD != (0,1) while "
					"issuing a packet command, ignoring\n");
965 966
			ireason |= CD;
			ireason &= ~IO;
L
Linus Torvalds 已提交
967 968
		}
	}
969
	if ((ireason & CD) == 0 || (ireason & IO)) {
L
Linus Torvalds 已提交
970 971 972 973 974 975 976 977
		printk(KERN_ERR "ide-tape: (IO,CoD) != (0,1) while issuing "
				"a packet command\n");
		return ide_do_reset(drive);
	}
	/* Set the interrupt routine */
	ide_set_handler(drive, &idetape_pc_intr, IDETAPE_WAIT_CMD, NULL);
#ifdef CONFIG_BLK_DEV_IDEDMA
	/* Begin DMA, if necessary */
978
	if (pc->flags & PC_FLAG_DMA_IN_PROGRESS)
979
		hwif->dma_ops->dma_start(drive);
L
Linus Torvalds 已提交
980 981
#endif
	/* Send the actual packet */
982 983
	hwif->output_data(drive, NULL, pc->c, 12);

L
Linus Torvalds 已提交
984 985 986
	return ide_started;
}

987 988
static ide_startstop_t idetape_issue_pc(ide_drive_t *drive,
		struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
989 990 991 992
{
	ide_hwif_t *hwif = drive->hwif;
	idetape_tape_t *tape = drive->driver_data;
	int dma_ok = 0;
993
	u16 bcount;
L
Linus Torvalds 已提交
994

995 996
	if (tape->pc->c[0] == REQUEST_SENSE &&
	    pc->c[0] == REQUEST_SENSE) {
L
Linus Torvalds 已提交
997 998 999 1000
		printk(KERN_ERR "ide-tape: possible ide-tape.c bug - "
			"Two request sense in serial were issued\n");
	}

1001
	if (tape->failed_pc == NULL && pc->c[0] != REQUEST_SENSE)
L
Linus Torvalds 已提交
1002 1003 1004 1005 1006
		tape->failed_pc = pc;
	/* Set the current packet command */
	tape->pc = pc;

	if (pc->retries > IDETAPE_MAX_PC_RETRIES ||
1007
		(pc->flags & PC_FLAG_ABORT)) {
L
Linus Torvalds 已提交
1008
		/*
1009 1010 1011
		 * We will "abort" retrying a packet command in case legitimate
		 * error code was received (crossing a filemark, or end of the
		 * media, for example).
L
Linus Torvalds 已提交
1012
		 */
1013
		if (!(pc->flags & PC_FLAG_ABORT)) {
1014
			if (!(pc->c[0] == TEST_UNIT_READY &&
L
Linus Torvalds 已提交
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
			      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 */
			pc->error = IDETAPE_ERROR_GENERAL;
		}
		tape->failed_pc = NULL;
1028
		return pc->idetape_callback(drive);
L
Linus Torvalds 已提交
1029
	}
1030
	debug_log(DBG_SENSE, "Retry #%d, cmd = %02X\n", pc->retries, pc->c[0]);
L
Linus Torvalds 已提交
1031 1032 1033

	pc->retries++;
	/* We haven't transferred any data yet */
1034 1035
	pc->xferred = 0;
	pc->cur_pos = pc->buf;
L
Linus Torvalds 已提交
1036
	/* Request to transfer the entire buffer at once */
1037
	bcount = pc->req_xfer;
L
Linus Torvalds 已提交
1038

1039 1040
	if (pc->flags & PC_FLAG_DMA_ERROR) {
		pc->flags &= ~PC_FLAG_DMA_ERROR;
L
Linus Torvalds 已提交
1041 1042
		printk(KERN_WARNING "ide-tape: DMA disabled, "
				"reverting to PIO\n");
1043
		ide_dma_off(drive);
L
Linus Torvalds 已提交
1044
	}
1045
	if ((pc->flags & PC_FLAG_DMA_RECOMMENDED) && drive->using_dma)
1046
		dma_ok = !hwif->dma_ops->dma_setup(drive);
L
Linus Torvalds 已提交
1047

1048 1049 1050
	ide_pktcmd_tf_load(drive, IDE_TFLAG_NO_SELECT_MASK |
			   IDE_TFLAG_OUT_DEVICE, bcount, dma_ok);

1051 1052 1053 1054
	if (dma_ok)
		/* Will begin DMA later */
		pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
	if (test_bit(IDETAPE_FLAG_DRQ_INTERRUPT, &tape->flags)) {
1055 1056
		ide_execute_command(drive, WIN_PACKETCMD, &idetape_transfer_pc,
				    IDETAPE_WAIT_CMD, NULL);
L
Linus Torvalds 已提交
1057 1058
		return ide_started;
	} else {
1059
		ide_execute_pkt_cmd(drive);
L
Linus Torvalds 已提交
1060 1061 1062 1063
		return idetape_transfer_pc(drive);
	}
}

1064
static ide_startstop_t idetape_pc_callback(ide_drive_t *drive)
L
Linus Torvalds 已提交
1065 1066
{
	idetape_tape_t *tape = drive->driver_data;
1067 1068

	debug_log(DBG_PROCS, "Enter %s\n", __func__);
L
Linus Torvalds 已提交
1069 1070 1071 1072 1073

	idetape_end_request(drive, tape->pc->error ? 0 : 1, 0);
	return ide_stopped;
}

1074
/* A mode sense command is used to "sense" tape parameters. */
1075
static void idetape_create_mode_sense_cmd(struct ide_atapi_pc *pc, u8 page_code)
L
Linus Torvalds 已提交
1076 1077
{
	idetape_init_pc(pc);
1078
	pc->c[0] = MODE_SENSE;
L
Linus Torvalds 已提交
1079
	if (page_code != IDETAPE_BLOCK_DESCRIPTOR)
1080 1081
		/* DBD = 1 - Don't return block descriptors */
		pc->c[1] = 8;
L
Linus Torvalds 已提交
1082 1083 1084 1085 1086 1087 1088 1089 1090
	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;
1091 1092
	/* We will just discard data in that case */
	pc->c[4] = 255;
L
Linus Torvalds 已提交
1093
	if (page_code == IDETAPE_BLOCK_DESCRIPTOR)
1094
		pc->req_xfer = 12;
L
Linus Torvalds 已提交
1095
	else if (page_code == IDETAPE_CAPABILITIES_PAGE)
1096
		pc->req_xfer = 24;
L
Linus Torvalds 已提交
1097
	else
1098 1099
		pc->req_xfer = 50;
	pc->idetape_callback = &idetape_pc_callback;
L
Linus Torvalds 已提交
1100 1101
}

1102
static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive)
L
Linus Torvalds 已提交
1103 1104
{
	idetape_tape_t *tape = drive->driver_data;
1105
	struct ide_atapi_pc *pc = tape->pc;
1106
	u8 stat;
L
Linus Torvalds 已提交
1107

1108 1109
	stat = ide_read_status(drive);

1110 1111
	if (stat & SEEK_STAT) {
		if (stat & ERR_STAT) {
L
Linus Torvalds 已提交
1112
			/* Error detected */
1113
			if (pc->c[0] != TEST_UNIT_READY)
L
Linus Torvalds 已提交
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
				printk(KERN_ERR "ide-tape: %s: I/O error, ",
						tape->name);
			/* Retry operation */
			return idetape_retry_pc(drive);
		}
		pc->error = 0;
		if (tape->failed_pc == pc)
			tape->failed_pc = NULL;
	} else {
		pc->error = IDETAPE_ERROR_GENERAL;
		tape->failed_pc = NULL;
	}
1126
	return pc->idetape_callback(drive);
L
Linus Torvalds 已提交
1127 1128
}

1129
static ide_startstop_t idetape_rw_callback(ide_drive_t *drive)
L
Linus Torvalds 已提交
1130 1131 1132
{
	idetape_tape_t *tape = drive->driver_data;
	struct request *rq = HWGROUP(drive)->rq;
1133
	int blocks = tape->pc->xferred / tape->blk_size;
L
Linus Torvalds 已提交
1134

1135
	tape->avg_size += blocks * tape->blk_size;
1136

1137
	if (time_after_eq(jiffies, tape->avg_time + HZ)) {
1138 1139
		tape->avg_speed = tape->avg_size * HZ /
				(jiffies - tape->avg_time) / 1024;
L
Linus Torvalds 已提交
1140 1141 1142
		tape->avg_size = 0;
		tape->avg_time = jiffies;
	}
1143
	debug_log(DBG_PROCS, "Enter %s\n", __func__);
L
Linus Torvalds 已提交
1144

1145
	tape->first_frame += blocks;
L
Linus Torvalds 已提交
1146 1147 1148 1149 1150 1151 1152 1153 1154
	rq->current_nr_sectors -= blocks;

	if (!tape->pc->error)
		idetape_end_request(drive, 1, 0);
	else
		idetape_end_request(drive, tape->pc->error, 0);
	return ide_stopped;
}

1155 1156
static void idetape_create_read_cmd(idetape_tape_t *tape,
		struct ide_atapi_pc *pc,
1157
		unsigned int length, struct idetape_bh *bh)
L
Linus Torvalds 已提交
1158 1159
{
	idetape_init_pc(pc);
1160
	pc->c[0] = READ_6;
1161
	put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]);
L
Linus Torvalds 已提交
1162
	pc->c[1] = 1;
1163
	pc->idetape_callback = &idetape_rw_callback;
L
Linus Torvalds 已提交
1164 1165
	pc->bh = bh;
	atomic_set(&bh->b_count, 0);
1166 1167 1168
	pc->buf = NULL;
	pc->buf_size = length * tape->blk_size;
	pc->req_xfer = pc->buf_size;
1169
	if (pc->req_xfer == tape->buffer_size)
1170
		pc->flags |= PC_FLAG_DMA_RECOMMENDED;
L
Linus Torvalds 已提交
1171 1172
}

1173 1174
static void idetape_create_write_cmd(idetape_tape_t *tape,
		struct ide_atapi_pc *pc,
1175
		unsigned int length, struct idetape_bh *bh)
L
Linus Torvalds 已提交
1176 1177
{
	idetape_init_pc(pc);
1178
	pc->c[0] = WRITE_6;
1179
	put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]);
L
Linus Torvalds 已提交
1180
	pc->c[1] = 1;
1181
	pc->idetape_callback = &idetape_rw_callback;
1182
	pc->flags |= PC_FLAG_WRITING;
L
Linus Torvalds 已提交
1183 1184 1185
	pc->bh = bh;
	pc->b_data = bh->b_data;
	pc->b_count = atomic_read(&bh->b_count);
1186 1187 1188
	pc->buf = NULL;
	pc->buf_size = length * tape->blk_size;
	pc->req_xfer = pc->buf_size;
1189
	if (pc->req_xfer == tape->buffer_size)
1190
		pc->flags |= PC_FLAG_DMA_RECOMMENDED;
L
Linus Torvalds 已提交
1191 1192 1193 1194 1195 1196
}

static ide_startstop_t idetape_do_request(ide_drive_t *drive,
					  struct request *rq, sector_t block)
{
	idetape_tape_t *tape = drive->driver_data;
1197
	struct ide_atapi_pc *pc = NULL;
L
Linus Torvalds 已提交
1198
	struct request *postponed_rq = tape->postponed_rq;
1199
	u8 stat;
L
Linus Torvalds 已提交
1200

1201 1202
	debug_log(DBG_SENSE, "sector: %ld, nr_sectors: %ld,"
			" current_nr_sectors: %d\n",
L
Linus Torvalds 已提交
1203 1204
			rq->sector, rq->nr_sectors, rq->current_nr_sectors);

1205
	if (!blk_special_request(rq)) {
1206
		/* We do not support buffer cache originated requests. */
L
Linus Torvalds 已提交
1207
		printk(KERN_NOTICE "ide-tape: %s: Unsupported request in "
1208
			"request queue (%d)\n", drive->name, rq->cmd_type);
L
Linus Torvalds 已提交
1209 1210 1211 1212
		ide_end_request(drive, 0, 0);
		return ide_stopped;
	}

1213
	/* Retry a failed packet command */
1214
	if (tape->failed_pc && tape->pc->c[0] == REQUEST_SENSE)
1215
		return idetape_issue_pc(drive, tape->failed_pc);
1216

L
Linus Torvalds 已提交
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
	if (postponed_rq != NULL)
		if (rq != postponed_rq) {
			printk(KERN_ERR "ide-tape: ide-tape.c bug - "
					"Two DSC requests were queued\n");
			idetape_end_request(drive, 0, 0);
			return ide_stopped;
		}

	tape->postponed_rq = NULL;

	/*
	 * If the tape is still busy, postpone our request and service
	 * the other device meanwhile.
	 */
1231
	stat = ide_read_status(drive);
L
Linus Torvalds 已提交
1232 1233

	if (!drive->dsc_overlap && !(rq->cmd[0] & REQ_IDETAPE_PC2))
1234
		set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags);
L
Linus Torvalds 已提交
1235 1236

	if (drive->post_reset == 1) {
1237
		set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags);
L
Linus Torvalds 已提交
1238 1239 1240
		drive->post_reset = 0;
	}

1241
	if (!test_and_clear_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags) &&
1242
	    (stat & SEEK_STAT) == 0) {
L
Linus Torvalds 已提交
1243 1244
		if (postponed_rq == NULL) {
			tape->dsc_polling_start = jiffies;
1245
			tape->dsc_poll_freq = tape->best_dsc_rw_freq;
L
Linus Torvalds 已提交
1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
			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);
			if (rq->cmd[0] & REQ_IDETAPE_PC2) {
				idetape_media_access_finished(drive);
				return ide_stopped;
			} else {
				return ide_do_reset(drive);
			}
1256 1257 1258
		} else if (time_after(jiffies,
					tape->dsc_polling_start +
					IDETAPE_DSC_MA_THRESHOLD))
1259
			tape->dsc_poll_freq = IDETAPE_DSC_MA_SLOW;
L
Linus Torvalds 已提交
1260 1261 1262 1263 1264
		idetape_postpone_request(drive);
		return ide_stopped;
	}
	if (rq->cmd[0] & REQ_IDETAPE_READ) {
		pc = idetape_next_pc_storage(drive);
1265 1266
		idetape_create_read_cmd(tape, pc, rq->current_nr_sectors,
					(struct idetape_bh *)rq->special);
L
Linus Torvalds 已提交
1267 1268 1269 1270
		goto out;
	}
	if (rq->cmd[0] & REQ_IDETAPE_WRITE) {
		pc = idetape_next_pc_storage(drive);
1271 1272
		idetape_create_write_cmd(tape, pc, rq->current_nr_sectors,
					 (struct idetape_bh *)rq->special);
L
Linus Torvalds 已提交
1273 1274 1275
		goto out;
	}
	if (rq->cmd[0] & REQ_IDETAPE_PC1) {
1276
		pc = (struct ide_atapi_pc *) rq->buffer;
L
Linus Torvalds 已提交
1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
		rq->cmd[0] &= ~(REQ_IDETAPE_PC1);
		rq->cmd[0] |= REQ_IDETAPE_PC2;
		goto out;
	}
	if (rq->cmd[0] & REQ_IDETAPE_PC2) {
		idetape_media_access_finished(drive);
		return ide_stopped;
	}
	BUG();
out:
1287
	return idetape_issue_pc(drive, pc);
L
Linus Torvalds 已提交
1288 1289 1290
}

/*
1291
 * The function below uses __get_free_pages to allocate a data buffer of size
1292
 * tape->buffer_size (or a bit more). We attempt to combine sequential pages as
1293
 * much as possible.
L
Linus Torvalds 已提交
1294
 *
1295 1296
 * It returns a pointer to the newly allocated buffer, or NULL in case of
 * failure.
L
Linus Torvalds 已提交
1297
 */
1298 1299
static struct idetape_bh *ide_tape_kmalloc_buffer(idetape_tape_t *tape,
						  int full, int clear)
L
Linus Torvalds 已提交
1300
{
1301
	struct idetape_bh *prev_bh, *bh, *merge_bh;
1302
	int pages = tape->pages_per_buffer;
1303
	unsigned int order, b_allocd;
L
Linus Torvalds 已提交
1304 1305
	char *b_data = NULL;

1306 1307
	merge_bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL);
	bh = merge_bh;
L
Linus Torvalds 已提交
1308 1309
	if (bh == NULL)
		goto abort;
1310 1311 1312

	order = fls(pages) - 1;
	bh->b_data = (char *) __get_free_pages(GFP_KERNEL, order);
1313
	if (!bh->b_data)
L
Linus Torvalds 已提交
1314
		goto abort;
1315 1316 1317
	b_allocd = (1 << order) * PAGE_SIZE;
	pages &= (order-1);

L
Linus Torvalds 已提交
1318
	if (clear)
1319 1320 1321
		memset(bh->b_data, 0, b_allocd);
	bh->b_reqnext = NULL;
	bh->b_size = b_allocd;
L
Linus Torvalds 已提交
1322 1323
	atomic_set(&bh->b_count, full ? bh->b_size : 0);

1324 1325 1326
	while (pages) {
		order = fls(pages) - 1;
		b_data = (char *) __get_free_pages(GFP_KERNEL, order);
1327
		if (!b_data)
L
Linus Torvalds 已提交
1328
			goto abort;
1329 1330
		b_allocd = (1 << order) * PAGE_SIZE;

L
Linus Torvalds 已提交
1331
		if (clear)
1332 1333 1334 1335 1336 1337
			memset(b_data, 0, b_allocd);

		/* newly allocated page frames below buffer header or ...*/
		if (bh->b_data == b_data + b_allocd) {
			bh->b_size += b_allocd;
			bh->b_data -= b_allocd;
L
Linus Torvalds 已提交
1338
			if (full)
1339
				atomic_add(b_allocd, &bh->b_count);
L
Linus Torvalds 已提交
1340 1341
			continue;
		}
1342
		/* they are above the header */
L
Linus Torvalds 已提交
1343
		if (b_data == bh->b_data + bh->b_size) {
1344
			bh->b_size += b_allocd;
L
Linus Torvalds 已提交
1345
			if (full)
1346
				atomic_add(b_allocd, &bh->b_count);
L
Linus Torvalds 已提交
1347 1348 1349
			continue;
		}
		prev_bh = bh;
1350 1351
		bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL);
		if (!bh) {
1352
			free_pages((unsigned long) b_data, order);
L
Linus Torvalds 已提交
1353 1354 1355 1356
			goto abort;
		}
		bh->b_reqnext = NULL;
		bh->b_data = b_data;
1357
		bh->b_size = b_allocd;
L
Linus Torvalds 已提交
1358 1359
		atomic_set(&bh->b_count, full ? bh->b_size : 0);
		prev_bh->b_reqnext = bh;
1360 1361

		pages &= (order-1);
L
Linus Torvalds 已提交
1362
	}
1363

L
Linus Torvalds 已提交
1364 1365 1366
	bh->b_size -= tape->excess_bh_size;
	if (full)
		atomic_sub(tape->excess_bh_size, &bh->b_count);
1367
	return merge_bh;
L
Linus Torvalds 已提交
1368
abort:
1369
	ide_tape_kfree_buffer(tape);
L
Linus Torvalds 已提交
1370 1371 1372
	return NULL;
}

1373
static int idetape_copy_stage_from_user(idetape_tape_t *tape,
1374
					const char __user *buf, int n)
L
Linus Torvalds 已提交
1375 1376 1377
{
	struct idetape_bh *bh = tape->bh;
	int count;
1378
	int ret = 0;
L
Linus Torvalds 已提交
1379 1380 1381

	while (n) {
		if (bh == NULL) {
1382 1383
			printk(KERN_ERR "ide-tape: bh == NULL in %s\n",
					__func__);
1384
			return 1;
L
Linus Torvalds 已提交
1385
		}
1386 1387 1388 1389 1390
		count = min((unsigned int)
				(bh->b_size - atomic_read(&bh->b_count)),
				(unsigned int)n);
		if (copy_from_user(bh->b_data + atomic_read(&bh->b_count), buf,
				count))
1391
			ret = 1;
L
Linus Torvalds 已提交
1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
		n -= count;
		atomic_add(count, &bh->b_count);
		buf += count;
		if (atomic_read(&bh->b_count) == bh->b_size) {
			bh = bh->b_reqnext;
			if (bh)
				atomic_set(&bh->b_count, 0);
		}
	}
	tape->bh = bh;
1402
	return ret;
L
Linus Torvalds 已提交
1403 1404
}

1405
static int idetape_copy_stage_to_user(idetape_tape_t *tape, char __user *buf,
1406
				      int n)
L
Linus Torvalds 已提交
1407 1408 1409
{
	struct idetape_bh *bh = tape->bh;
	int count;
1410
	int ret = 0;
L
Linus Torvalds 已提交
1411 1412 1413

	while (n) {
		if (bh == NULL) {
1414 1415
			printk(KERN_ERR "ide-tape: bh == NULL in %s\n",
					__func__);
1416
			return 1;
L
Linus Torvalds 已提交
1417 1418
		}
		count = min(tape->b_count, n);
1419 1420
		if  (copy_to_user(buf, tape->b_data, count))
			ret = 1;
L
Linus Torvalds 已提交
1421 1422 1423 1424 1425
		n -= count;
		tape->b_data += count;
		tape->b_count -= count;
		buf += count;
		if (!tape->b_count) {
1426 1427
			bh = bh->b_reqnext;
			tape->bh = bh;
L
Linus Torvalds 已提交
1428 1429 1430 1431 1432 1433
			if (bh) {
				tape->b_data = bh->b_data;
				tape->b_count = atomic_read(&bh->b_count);
			}
		}
	}
1434
	return ret;
L
Linus Torvalds 已提交
1435 1436
}

1437
static void idetape_init_merge_buffer(idetape_tape_t *tape)
L
Linus Torvalds 已提交
1438
{
1439 1440
	struct idetape_bh *bh = tape->merge_bh;
	tape->bh = tape->merge_bh;
1441

1442
	if (tape->chrdev_dir == IDETAPE_DIR_WRITE)
L
Linus Torvalds 已提交
1443 1444 1445 1446 1447 1448 1449
		atomic_set(&bh->b_count, 0);
	else {
		tape->b_data = bh->b_data;
		tape->b_count = atomic_read(&bh->b_count);
	}
}

1450
static ide_startstop_t idetape_read_position_callback(ide_drive_t *drive)
L
Linus Torvalds 已提交
1451 1452
{
	idetape_tape_t *tape = drive->driver_data;
1453
	u8 *readpos = tape->pc->buf;
1454 1455

	debug_log(DBG_PROCS, "Enter %s\n", __func__);
L
Linus Torvalds 已提交
1456 1457

	if (!tape->pc->error) {
1458 1459 1460 1461 1462 1463 1464 1465
		debug_log(DBG_SENSE, "BOP - %s\n",
				(readpos[0] & 0x80) ? "Yes" : "No");
		debug_log(DBG_SENSE, "EOP - %s\n",
				(readpos[0] & 0x40) ? "Yes" : "No");

		if (readpos[0] & 0x4) {
			printk(KERN_INFO "ide-tape: Block location is unknown"
					 "to the tape\n");
1466
			clear_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags);
L
Linus Torvalds 已提交
1467 1468
			idetape_end_request(drive, 0, 0);
		} else {
1469
			debug_log(DBG_SENSE, "Block Location - %u\n",
1470 1471 1472
					be32_to_cpu(*(u32 *)&readpos[4]));

			tape->partition = readpos[1];
1473
			tape->first_frame =
1474
				be32_to_cpu(*(u32 *)&readpos[4]);
1475
			set_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags);
L
Linus Torvalds 已提交
1476 1477 1478 1479 1480 1481 1482 1483 1484
			idetape_end_request(drive, 1, 0);
		}
	} else {
		idetape_end_request(drive, 0, 0);
	}
	return ide_stopped;
}

/*
1485 1486
 * Write a filemark if write_filemark=1. Flush the device buffers without
 * writing a filemark otherwise.
L
Linus Torvalds 已提交
1487
 */
1488
static void idetape_create_write_filemark_cmd(ide_drive_t *drive,
1489
		struct ide_atapi_pc *pc, int write_filemark)
L
Linus Torvalds 已提交
1490 1491
{
	idetape_init_pc(pc);
1492
	pc->c[0] = WRITE_FILEMARKS;
L
Linus Torvalds 已提交
1493
	pc->c[4] = write_filemark;
1494
	pc->flags |= PC_FLAG_WAIT_FOR_DSC;
1495
	pc->idetape_callback = &idetape_pc_callback;
L
Linus Torvalds 已提交
1496 1497
}

1498
static void idetape_create_test_unit_ready_cmd(struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
1499 1500
{
	idetape_init_pc(pc);
1501
	pc->c[0] = TEST_UNIT_READY;
1502
	pc->idetape_callback = &idetape_pc_callback;
L
Linus Torvalds 已提交
1503 1504 1505
}

/*
1506 1507 1508 1509 1510 1511
 * We add a special packet command request to the tail of the request queue, and
 * wait for it to be serviced. This is not to be called from within the request
 * handling part of the driver! We allocate here data on the stack and it is
 * valid until the request is finished. This is not the case for the bottom part
 * of the driver, where we are always leaving the functions to wait for an
 * interrupt or a timer event.
L
Linus Torvalds 已提交
1512
 *
1513 1514 1515 1516
 * From the bottom part of the driver, we should allocate safe memory using
 * idetape_next_pc_storage() and ide_tape_next_rq_storage(), and add the request
 * to the request list without waiting for it to be serviced! In that case, we
 * usually use idetape_queue_pc_head().
L
Linus Torvalds 已提交
1517
 */
1518
static int idetape_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
{
	struct ide_tape_obj *tape = drive->driver_data;
	struct request rq;

	idetape_init_rq(&rq, REQ_IDETAPE_PC1);
	rq.buffer = (char *) pc;
	rq.rq_disk = tape->disk;
	return ide_do_drive_cmd(drive, &rq, ide_wait);
}

1529 1530
static void idetape_create_load_unload_cmd(ide_drive_t *drive,
		struct ide_atapi_pc *pc, int cmd)
L
Linus Torvalds 已提交
1531 1532
{
	idetape_init_pc(pc);
1533
	pc->c[0] = START_STOP;
L
Linus Torvalds 已提交
1534
	pc->c[4] = cmd;
1535
	pc->flags |= PC_FLAG_WAIT_FOR_DSC;
1536
	pc->idetape_callback = &idetape_pc_callback;
L
Linus Torvalds 已提交
1537 1538 1539 1540 1541
}

static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
{
	idetape_tape_t *tape = drive->driver_data;
1542
	struct ide_atapi_pc pc;
L
Linus Torvalds 已提交
1543 1544
	int load_attempted = 0;

1545
	/* Wait for the tape to become ready */
1546
	set_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags);
L
Linus Torvalds 已提交
1547 1548 1549
	timeout += jiffies;
	while (time_before(jiffies, timeout)) {
		idetape_create_test_unit_ready_cmd(&pc);
1550
		if (!idetape_queue_pc_tail(drive, &pc))
L
Linus Torvalds 已提交
1551 1552
			return 0;
		if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2)
1553 1554
		    || (tape->asc == 0x3A)) {
			/* no media */
L
Linus Torvalds 已提交
1555 1556
			if (load_attempted)
				return -ENOMEDIUM;
1557 1558
			idetape_create_load_unload_cmd(drive, &pc,
							IDETAPE_LU_LOAD_MASK);
1559
			idetape_queue_pc_tail(drive, &pc);
L
Linus Torvalds 已提交
1560 1561 1562 1563 1564
			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;
1565
		msleep(100);
L
Linus Torvalds 已提交
1566 1567 1568 1569
	}
	return -EIO;
}

1570
static int idetape_flush_tape_buffers(ide_drive_t *drive)
L
Linus Torvalds 已提交
1571
{
1572
	struct ide_atapi_pc pc;
L
Linus Torvalds 已提交
1573 1574 1575
	int rc;

	idetape_create_write_filemark_cmd(drive, &pc, 0);
1576 1577
	rc = idetape_queue_pc_tail(drive, &pc);
	if (rc)
L
Linus Torvalds 已提交
1578 1579 1580 1581 1582
		return rc;
	idetape_wait_ready(drive, 60 * 5 * HZ);
	return 0;
}

1583
static void idetape_create_read_position_cmd(struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
1584 1585
{
	idetape_init_pc(pc);
1586
	pc->c[0] = READ_POSITION;
1587 1588
	pc->req_xfer = 20;
	pc->idetape_callback = &idetape_read_position_callback;
L
Linus Torvalds 已提交
1589 1590
}

1591
static int idetape_read_position(ide_drive_t *drive)
L
Linus Torvalds 已提交
1592 1593
{
	idetape_tape_t *tape = drive->driver_data;
1594
	struct ide_atapi_pc pc;
L
Linus Torvalds 已提交
1595 1596
	int position;

1597
	debug_log(DBG_PROCS, "Enter %s\n", __func__);
L
Linus Torvalds 已提交
1598 1599 1600 1601

	idetape_create_read_position_cmd(&pc);
	if (idetape_queue_pc_tail(drive, &pc))
		return -1;
1602
	position = tape->first_frame;
L
Linus Torvalds 已提交
1603 1604 1605
	return position;
}

1606 1607
static void idetape_create_locate_cmd(ide_drive_t *drive,
		struct ide_atapi_pc *pc,
1608
		unsigned int block, u8 partition, int skip)
L
Linus Torvalds 已提交
1609 1610
{
	idetape_init_pc(pc);
1611
	pc->c[0] = POSITION_TO_ELEMENT;
L
Linus Torvalds 已提交
1612
	pc->c[1] = 2;
1613
	put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[3]);
L
Linus Torvalds 已提交
1614
	pc->c[8] = partition;
1615
	pc->flags |= PC_FLAG_WAIT_FOR_DSC;
1616
	pc->idetape_callback = &idetape_pc_callback;
L
Linus Torvalds 已提交
1617 1618
}

1619 1620
static int idetape_create_prevent_cmd(ide_drive_t *drive,
		struct ide_atapi_pc *pc, int prevent)
L
Linus Torvalds 已提交
1621 1622 1623
{
	idetape_tape_t *tape = drive->driver_data;

1624 1625
	/* device supports locking according to capabilities page */
	if (!(tape->caps[6] & 0x01))
L
Linus Torvalds 已提交
1626 1627 1628
		return 0;

	idetape_init_pc(pc);
1629
	pc->c[0] = ALLOW_MEDIUM_REMOVAL;
L
Linus Torvalds 已提交
1630
	pc->c[4] = prevent;
1631
	pc->idetape_callback = &idetape_pc_callback;
L
Linus Torvalds 已提交
1632 1633 1634
	return 1;
}

1635
static void __ide_tape_discard_merge_buffer(ide_drive_t *drive)
L
Linus Torvalds 已提交
1636 1637 1638
{
	idetape_tape_t *tape = drive->driver_data;

1639
	if (tape->chrdev_dir != IDETAPE_DIR_READ)
1640
		return;
L
Linus Torvalds 已提交
1641

1642
	clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags);
1643
	tape->merge_bh_size = 0;
1644 1645 1646
	if (tape->merge_bh != NULL) {
		ide_tape_kfree_buffer(tape);
		tape->merge_bh = NULL;
L
Linus Torvalds 已提交
1647 1648
	}

1649
	tape->chrdev_dir = IDETAPE_DIR_NONE;
L
Linus Torvalds 已提交
1650 1651 1652
}

/*
1653 1654 1655 1656
 * 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.
L
Linus Torvalds 已提交
1657
 */
1658 1659
static int idetape_position_tape(ide_drive_t *drive, unsigned int block,
		u8 partition, int skip)
L
Linus Torvalds 已提交
1660 1661 1662
{
	idetape_tape_t *tape = drive->driver_data;
	int retval;
1663
	struct ide_atapi_pc pc;
L
Linus Torvalds 已提交
1664

1665
	if (tape->chrdev_dir == IDETAPE_DIR_READ)
1666
		__ide_tape_discard_merge_buffer(drive);
L
Linus Torvalds 已提交
1667 1668 1669 1670 1671 1672 1673 1674 1675 1676
	idetape_wait_ready(drive, 60 * 5 * HZ);
	idetape_create_locate_cmd(drive, &pc, block, partition, skip);
	retval = idetape_queue_pc_tail(drive, &pc);
	if (retval)
		return (retval);

	idetape_create_read_position_cmd(&pc);
	return (idetape_queue_pc_tail(drive, &pc));
}

1677
static void ide_tape_discard_merge_buffer(ide_drive_t *drive,
1678
					  int restore_position)
L
Linus Torvalds 已提交
1679 1680 1681 1682
{
	idetape_tape_t *tape = drive->driver_data;
	int seek, position;

1683
	__ide_tape_discard_merge_buffer(drive);
L
Linus Torvalds 已提交
1684 1685
	if (restore_position) {
		position = idetape_read_position(drive);
1686
		seek = position > 0 ? position : 0;
L
Linus Torvalds 已提交
1687
		if (idetape_position_tape(drive, seek, 0, 0)) {
1688
			printk(KERN_INFO "ide-tape: %s: position_tape failed in"
1689
					 " %s\n", tape->name, __func__);
L
Linus Torvalds 已提交
1690 1691 1692 1693 1694 1695
			return;
		}
	}
}

/*
1696 1697
 * Generate a read/write request for the block device interface and wait for it
 * to be serviced.
L
Linus Torvalds 已提交
1698
 */
1699 1700
static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int blocks,
				 struct idetape_bh *bh)
L
Linus Torvalds 已提交
1701 1702 1703 1704
{
	idetape_tape_t *tape = drive->driver_data;
	struct request rq;

1705 1706
	debug_log(DBG_SENSE, "%s: cmd=%d\n", __func__, cmd);

L
Linus Torvalds 已提交
1707 1708 1709
	idetape_init_rq(&rq, cmd);
	rq.rq_disk = tape->disk;
	rq.special = (void *)bh;
1710
	rq.sector = tape->first_frame;
1711 1712
	rq.nr_sectors		= blocks;
	rq.current_nr_sectors	= blocks;
L
Linus Torvalds 已提交
1713 1714 1715 1716 1717
	(void) ide_do_drive_cmd(drive, &rq, ide_wait);

	if ((cmd & (REQ_IDETAPE_READ | REQ_IDETAPE_WRITE)) == 0)
		return 0;

1718 1719
	if (tape->merge_bh)
		idetape_init_merge_buffer(tape);
L
Linus Torvalds 已提交
1720 1721
	if (rq.errors == IDETAPE_ERROR_GENERAL)
		return -EIO;
1722
	return (tape->blk_size * (blocks-rq.current_nr_sectors));
L
Linus Torvalds 已提交
1723 1724
}

1725
static void idetape_create_inquiry_cmd(struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
1726 1727
{
	idetape_init_pc(pc);
1728
	pc->c[0] = INQUIRY;
1729
	pc->c[4] = 254;
1730 1731
	pc->req_xfer = 254;
	pc->idetape_callback = &idetape_pc_callback;
L
Linus Torvalds 已提交
1732 1733
}

1734 1735
static void idetape_create_rewind_cmd(ide_drive_t *drive,
		struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
1736 1737
{
	idetape_init_pc(pc);
1738
	pc->c[0] = REZERO_UNIT;
1739
	pc->flags |= PC_FLAG_WAIT_FOR_DSC;
1740
	pc->idetape_callback = &idetape_pc_callback;
L
Linus Torvalds 已提交
1741 1742
}

1743
static void idetape_create_erase_cmd(struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
1744 1745
{
	idetape_init_pc(pc);
1746
	pc->c[0] = ERASE;
L
Linus Torvalds 已提交
1747
	pc->c[1] = 1;
1748
	pc->flags |= PC_FLAG_WAIT_FOR_DSC;
1749
	pc->idetape_callback = &idetape_pc_callback;
L
Linus Torvalds 已提交
1750 1751
}

1752
static void idetape_create_space_cmd(struct ide_atapi_pc *pc, int count, u8 cmd)
L
Linus Torvalds 已提交
1753 1754
{
	idetape_init_pc(pc);
1755
	pc->c[0] = SPACE;
1756
	put_unaligned(cpu_to_be32(count), (unsigned int *) &pc->c[1]);
L
Linus Torvalds 已提交
1757
	pc->c[1] = cmd;
1758
	pc->flags |= PC_FLAG_WAIT_FOR_DSC;
1759
	pc->idetape_callback = &idetape_pc_callback;
L
Linus Torvalds 已提交
1760 1761
}

1762
/* Queue up a character device originated write request. */
1763
static int idetape_add_chrdev_write_request(ide_drive_t *drive, int blocks)
L
Linus Torvalds 已提交
1764 1765 1766
{
	idetape_tape_t *tape = drive->driver_data;

1767
	debug_log(DBG_CHRDEV, "Enter %s\n", __func__);
L
Linus Torvalds 已提交
1768

1769
	return idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE,
1770
				     blocks, tape->merge_bh);
L
Linus Torvalds 已提交
1771 1772
}

1773
static void ide_tape_flush_merge_buffer(ide_drive_t *drive)
L
Linus Torvalds 已提交
1774 1775 1776 1777
{
	idetape_tape_t *tape = drive->driver_data;
	int blocks, min;
	struct idetape_bh *bh;
1778

1779
	if (tape->chrdev_dir != IDETAPE_DIR_WRITE) {
1780
		printk(KERN_ERR "ide-tape: bug: Trying to empty merge buffer"
1781
				" but we are not writing.\n");
L
Linus Torvalds 已提交
1782 1783
		return;
	}
1784
	if (tape->merge_bh_size > tape->buffer_size) {
L
Linus Torvalds 已提交
1785
		printk(KERN_ERR "ide-tape: bug: merge_buffer too big\n");
1786
		tape->merge_bh_size = tape->buffer_size;
L
Linus Torvalds 已提交
1787
	}
1788 1789 1790
	if (tape->merge_bh_size) {
		blocks = tape->merge_bh_size / tape->blk_size;
		if (tape->merge_bh_size % tape->blk_size) {
L
Linus Torvalds 已提交
1791 1792 1793
			unsigned int i;

			blocks++;
1794
			i = tape->blk_size - tape->merge_bh_size %
1795
				tape->blk_size;
L
Linus Torvalds 已提交
1796 1797 1798 1799 1800 1801 1802 1803
			bh = tape->bh->b_reqnext;
			while (bh) {
				atomic_set(&bh->b_count, 0);
				bh = bh->b_reqnext;
			}
			bh = tape->bh;
			while (i) {
				if (bh == NULL) {
1804 1805
					printk(KERN_INFO "ide-tape: bug,"
							 " bh NULL\n");
L
Linus Torvalds 已提交
1806 1807
					break;
				}
1808 1809 1810 1811
				min = min(i, (unsigned int)(bh->b_size -
						atomic_read(&bh->b_count)));
				memset(bh->b_data + atomic_read(&bh->b_count),
						0, min);
L
Linus Torvalds 已提交
1812 1813 1814 1815 1816 1817
				atomic_add(min, &bh->b_count);
				i -= min;
				bh = bh->b_reqnext;
			}
		}
		(void) idetape_add_chrdev_write_request(drive, blocks);
1818
		tape->merge_bh_size = 0;
L
Linus Torvalds 已提交
1819
	}
1820 1821 1822
	if (tape->merge_bh != NULL) {
		ide_tape_kfree_buffer(tape);
		tape->merge_bh = NULL;
L
Linus Torvalds 已提交
1823
	}
1824
	tape->chrdev_dir = IDETAPE_DIR_NONE;
L
Linus Torvalds 已提交
1825 1826
}

1827
static int idetape_init_read(ide_drive_t *drive)
L
Linus Torvalds 已提交
1828 1829 1830 1831 1832
{
	idetape_tape_t *tape = drive->driver_data;
	int bytes_read;

	/* Initialize read operation */
1833 1834
	if (tape->chrdev_dir != IDETAPE_DIR_READ) {
		if (tape->chrdev_dir == IDETAPE_DIR_WRITE) {
1835
			ide_tape_flush_merge_buffer(drive);
L
Linus Torvalds 已提交
1836 1837
			idetape_flush_tape_buffers(drive);
		}
1838
		if (tape->merge_bh || tape->merge_bh_size) {
1839
			printk(KERN_ERR "ide-tape: merge_bh_size should be"
1840
					 " 0 now\n");
1841
			tape->merge_bh_size = 0;
L
Linus Torvalds 已提交
1842
		}
1843 1844
		tape->merge_bh = ide_tape_kmalloc_buffer(tape, 0, 0);
		if (!tape->merge_bh)
L
Linus Torvalds 已提交
1845
			return -ENOMEM;
1846
		tape->chrdev_dir = IDETAPE_DIR_READ;
L
Linus Torvalds 已提交
1847 1848

		/*
1849 1850 1851 1852
		 * Issue a read 0 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.
L
Linus Torvalds 已提交
1853 1854
		 */
		if (drive->dsc_overlap) {
1855 1856
			bytes_read = idetape_queue_rw_tail(drive,
							REQ_IDETAPE_READ, 0,
1857
							tape->merge_bh);
L
Linus Torvalds 已提交
1858
			if (bytes_read < 0) {
1859 1860
				ide_tape_kfree_buffer(tape);
				tape->merge_bh = NULL;
1861
				tape->chrdev_dir = IDETAPE_DIR_NONE;
L
Linus Torvalds 已提交
1862 1863 1864 1865
				return bytes_read;
			}
		}
	}
1866

L
Linus Torvalds 已提交
1867 1868 1869
	return 0;
}

1870
/* called from idetape_chrdev_read() to service a chrdev read request. */
1871
static int idetape_add_chrdev_read_request(ide_drive_t *drive, int blocks)
L
Linus Torvalds 已提交
1872 1873 1874
{
	idetape_tape_t *tape = drive->driver_data;

1875
	debug_log(DBG_PROCS, "Enter %s, %d blocks\n", __func__, blocks);
L
Linus Torvalds 已提交
1876

1877
	/* If we are at a filemark, return a read length of 0 */
1878
	if (test_bit(IDETAPE_FLAG_FILEMARK, &tape->flags))
L
Linus Torvalds 已提交
1879 1880
		return 0;

1881
	idetape_init_read(drive);
1882 1883

	return idetape_queue_rw_tail(drive, REQ_IDETAPE_READ, blocks,
1884
				     tape->merge_bh);
L
Linus Torvalds 已提交
1885 1886
}

1887
static void idetape_pad_zeros(ide_drive_t *drive, int bcount)
L
Linus Torvalds 已提交
1888 1889 1890 1891
{
	idetape_tape_t *tape = drive->driver_data;
	struct idetape_bh *bh;
	int blocks;
1892

L
Linus Torvalds 已提交
1893 1894 1895
	while (bcount) {
		unsigned int count;

1896
		bh = tape->merge_bh;
1897
		count = min(tape->buffer_size, bcount);
L
Linus Torvalds 已提交
1898
		bcount -= count;
1899
		blocks = count / tape->blk_size;
L
Linus Torvalds 已提交
1900
		while (count) {
1901 1902
			atomic_set(&bh->b_count,
				   min(count, (unsigned int)bh->b_size));
L
Linus Torvalds 已提交
1903 1904 1905 1906
			memset(bh->b_data, 0, atomic_read(&bh->b_count));
			count -= atomic_read(&bh->b_count);
			bh = bh->b_reqnext;
		}
1907
		idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, blocks,
1908
				      tape->merge_bh);
L
Linus Torvalds 已提交
1909 1910 1911 1912
	}
}

/*
1913 1914 1915
 * Rewinds the tape to the Beginning Of the current Partition (BOP). We
 * currently support only one partition.
 */
1916
static int idetape_rewind_tape(ide_drive_t *drive)
L
Linus Torvalds 已提交
1917 1918
{
	int retval;
1919
	struct ide_atapi_pc pc;
1920 1921 1922 1923 1924
	idetape_tape_t *tape;
	tape = drive->driver_data;

	debug_log(DBG_SENSE, "Enter %s\n", __func__);

L
Linus Torvalds 已提交
1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936
	idetape_create_rewind_cmd(drive, &pc);
	retval = idetape_queue_pc_tail(drive, &pc);
	if (retval)
		return retval;

	idetape_create_read_position_cmd(&pc);
	retval = idetape_queue_pc_tail(drive, &pc);
	if (retval)
		return retval;
	return 0;
}

1937
/* mtio.h compatible commands should be issued to the chrdev interface. */
1938 1939
static int idetape_blkdev_ioctl(ide_drive_t *drive, unsigned int cmd,
				unsigned long arg)
L
Linus Torvalds 已提交
1940 1941 1942 1943
{
	idetape_tape_t *tape = drive->driver_data;
	void __user *argp = (void __user *)arg;

1944 1945 1946 1947 1948 1949
	struct idetape_config {
		int dsc_rw_frequency;
		int dsc_media_access_frequency;
		int nr_stages;
	} config;

1950 1951
	debug_log(DBG_PROCS, "Enter %s\n", __func__);

L
Linus Torvalds 已提交
1952
	switch (cmd) {
1953 1954 1955 1956 1957 1958 1959
	case 0x0340:
		if (copy_from_user(&config, argp, sizeof(config)))
			return -EFAULT;
		tape->best_dsc_rw_freq = config.dsc_rw_frequency;
		break;
	case 0x0350:
		config.dsc_rw_frequency = (int) tape->best_dsc_rw_freq;
1960
		config.nr_stages = 1;
1961 1962 1963 1964 1965
		if (copy_to_user(argp, &config, sizeof(config)))
			return -EFAULT;
		break;
	default:
		return -EIO;
L
Linus Torvalds 已提交
1966 1967 1968 1969
	}
	return 0;
}

1970 1971
static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op,
					int mt_count)
L
Linus Torvalds 已提交
1972 1973
{
	idetape_tape_t *tape = drive->driver_data;
1974
	struct ide_atapi_pc pc;
1975
	int retval, count = 0;
1976
	int sprev = !!(tape->caps[4] & 0x20);
L
Linus Torvalds 已提交
1977 1978 1979 1980

	if (mt_count == 0)
		return 0;
	if (MTBSF == mt_op || MTBSFM == mt_op) {
1981
		if (!sprev)
L
Linus Torvalds 已提交
1982
			return -EIO;
1983
		mt_count = -mt_count;
L
Linus Torvalds 已提交
1984 1985
	}

1986
	if (tape->chrdev_dir == IDETAPE_DIR_READ) {
1987
		tape->merge_bh_size = 0;
1988
		if (test_and_clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags))
L
Linus Torvalds 已提交
1989
			++count;
1990
		ide_tape_discard_merge_buffer(drive, 0);
L
Linus Torvalds 已提交
1991 1992 1993
	}

	switch (mt_op) {
1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012
	case MTFSF:
	case MTBSF:
		idetape_create_space_cmd(&pc, mt_count - count,
					 IDETAPE_SPACE_OVER_FILEMARK);
		return idetape_queue_pc_tail(drive, &pc);
	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;
L
Linus Torvalds 已提交
2013 2014 2015 2016
	}
}

/*
2017
 * Our character device read / write functions.
L
Linus Torvalds 已提交
2018
 *
2019 2020 2021
 * 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).
L
Linus Torvalds 已提交
2022
 *
2023 2024 2025 2026 2027 2028 2029
 * 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.
L
Linus Torvalds 已提交
2030
 */
2031 2032
static ssize_t idetape_chrdev_read(struct file *file, char __user *buf,
				   size_t count, loff_t *ppos)
L
Linus Torvalds 已提交
2033 2034 2035
{
	struct ide_tape_obj *tape = ide_tape_f(file);
	ide_drive_t *drive = tape->drive;
2036
	ssize_t bytes_read, temp, actually_read = 0, rc;
2037
	ssize_t ret = 0;
2038
	u16 ctl = *(u16 *)&tape->caps[12];
L
Linus Torvalds 已提交
2039

2040
	debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count);
L
Linus Torvalds 已提交
2041

2042
	if (tape->chrdev_dir != IDETAPE_DIR_READ) {
2043
		if (test_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags))
2044 2045 2046
			if (count > tape->blk_size &&
			    (count % tape->blk_size) == 0)
				tape->user_bs_factor = count / tape->blk_size;
L
Linus Torvalds 已提交
2047
	}
2048
	rc = idetape_init_read(drive);
2049
	if (rc < 0)
L
Linus Torvalds 已提交
2050 2051 2052
		return rc;
	if (count == 0)
		return (0);
2053 2054
	if (tape->merge_bh_size) {
		actually_read = min((unsigned int)(tape->merge_bh_size),
2055
				    (unsigned int)count);
2056
		if (idetape_copy_stage_to_user(tape, buf, actually_read))
2057
			ret = -EFAULT;
L
Linus Torvalds 已提交
2058
		buf += actually_read;
2059
		tape->merge_bh_size -= actually_read;
L
Linus Torvalds 已提交
2060 2061
		count -= actually_read;
	}
2062
	while (count >= tape->buffer_size) {
2063
		bytes_read = idetape_add_chrdev_read_request(drive, ctl);
L
Linus Torvalds 已提交
2064 2065
		if (bytes_read <= 0)
			goto finish;
2066
		if (idetape_copy_stage_to_user(tape, buf, bytes_read))
2067
			ret = -EFAULT;
L
Linus Torvalds 已提交
2068 2069 2070 2071 2072
		buf += bytes_read;
		count -= bytes_read;
		actually_read += bytes_read;
	}
	if (count) {
2073
		bytes_read = idetape_add_chrdev_read_request(drive, ctl);
L
Linus Torvalds 已提交
2074 2075 2076
		if (bytes_read <= 0)
			goto finish;
		temp = min((unsigned long)count, (unsigned long)bytes_read);
2077
		if (idetape_copy_stage_to_user(tape, buf, temp))
2078
			ret = -EFAULT;
L
Linus Torvalds 已提交
2079
		actually_read += temp;
2080
		tape->merge_bh_size = bytes_read-temp;
L
Linus Torvalds 已提交
2081 2082
	}
finish:
2083
	if (!actually_read && test_bit(IDETAPE_FLAG_FILEMARK, &tape->flags)) {
2084 2085
		debug_log(DBG_SENSE, "%s: spacing over filemark\n", tape->name);

L
Linus Torvalds 已提交
2086 2087 2088
		idetape_space_over_filemarks(drive, MTFSF, 1);
		return 0;
	}
2089

2090
	return ret ? ret : actually_read;
L
Linus Torvalds 已提交
2091 2092
}

2093
static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf,
L
Linus Torvalds 已提交
2094 2095 2096 2097
				     size_t count, loff_t *ppos)
{
	struct ide_tape_obj *tape = ide_tape_f(file);
	ide_drive_t *drive = tape->drive;
2098 2099
	ssize_t actually_written = 0;
	ssize_t ret = 0;
2100
	u16 ctl = *(u16 *)&tape->caps[12];
L
Linus Torvalds 已提交
2101 2102 2103 2104 2105

	/* The drive is write protected. */
	if (tape->write_prot)
		return -EACCES;

2106
	debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count);
L
Linus Torvalds 已提交
2107 2108

	/* Initialize write operation */
2109 2110
	if (tape->chrdev_dir != IDETAPE_DIR_WRITE) {
		if (tape->chrdev_dir == IDETAPE_DIR_READ)
2111
			ide_tape_discard_merge_buffer(drive, 1);
2112
		if (tape->merge_bh || tape->merge_bh_size) {
2113
			printk(KERN_ERR "ide-tape: merge_bh_size "
L
Linus Torvalds 已提交
2114
				"should be 0 now\n");
2115
			tape->merge_bh_size = 0;
L
Linus Torvalds 已提交
2116
		}
2117 2118
		tape->merge_bh = ide_tape_kmalloc_buffer(tape, 0, 0);
		if (!tape->merge_bh)
L
Linus Torvalds 已提交
2119
			return -ENOMEM;
2120
		tape->chrdev_dir = IDETAPE_DIR_WRITE;
2121
		idetape_init_merge_buffer(tape);
L
Linus Torvalds 已提交
2122 2123

		/*
2124 2125 2126 2127
		 * Issue a write 0 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.
L
Linus Torvalds 已提交
2128 2129
		 */
		if (drive->dsc_overlap) {
2130 2131
			ssize_t retval = idetape_queue_rw_tail(drive,
							REQ_IDETAPE_WRITE, 0,
2132
							tape->merge_bh);
L
Linus Torvalds 已提交
2133
			if (retval < 0) {
2134 2135
				ide_tape_kfree_buffer(tape);
				tape->merge_bh = NULL;
2136
				tape->chrdev_dir = IDETAPE_DIR_NONE;
L
Linus Torvalds 已提交
2137 2138 2139 2140 2141 2142
				return retval;
			}
		}
	}
	if (count == 0)
		return (0);
2143 2144
	if (tape->merge_bh_size) {
		if (tape->merge_bh_size >= tape->buffer_size) {
2145
			printk(KERN_ERR "ide-tape: bug: merge buf too big\n");
2146
			tape->merge_bh_size = 0;
L
Linus Torvalds 已提交
2147
		}
2148
		actually_written = min((unsigned int)
2149
				(tape->buffer_size - tape->merge_bh_size),
2150
				(unsigned int)count);
2151
		if (idetape_copy_stage_from_user(tape, buf, actually_written))
2152
				ret = -EFAULT;
L
Linus Torvalds 已提交
2153
		buf += actually_written;
2154
		tape->merge_bh_size += actually_written;
L
Linus Torvalds 已提交
2155 2156
		count -= actually_written;

2157
		if (tape->merge_bh_size == tape->buffer_size) {
2158
			ssize_t retval;
2159
			tape->merge_bh_size = 0;
2160
			retval = idetape_add_chrdev_write_request(drive, ctl);
L
Linus Torvalds 已提交
2161 2162 2163 2164
			if (retval <= 0)
				return (retval);
		}
	}
2165
	while (count >= tape->buffer_size) {
2166
		ssize_t retval;
2167
		if (idetape_copy_stage_from_user(tape, buf, tape->buffer_size))
2168
			ret = -EFAULT;
2169 2170
		buf += tape->buffer_size;
		count -= tape->buffer_size;
2171
		retval = idetape_add_chrdev_write_request(drive, ctl);
2172
		actually_written += tape->buffer_size;
L
Linus Torvalds 已提交
2173 2174 2175 2176 2177
		if (retval <= 0)
			return (retval);
	}
	if (count) {
		actually_written += count;
2178
		if (idetape_copy_stage_from_user(tape, buf, count))
2179
			ret = -EFAULT;
2180
		tape->merge_bh_size += count;
L
Linus Torvalds 已提交
2181
	}
2182
	return ret ? ret : actually_written;
L
Linus Torvalds 已提交
2183 2184
}

2185
static int idetape_write_filemark(ide_drive_t *drive)
L
Linus Torvalds 已提交
2186
{
2187
	struct ide_atapi_pc pc;
L
Linus Torvalds 已提交
2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198

	/* Write a filemark */
	idetape_create_write_filemark_cmd(drive, &pc, 1);
	if (idetape_queue_pc_tail(drive, &pc)) {
		printk(KERN_ERR "ide-tape: Couldn't write a filemark\n");
		return -EIO;
	}
	return 0;
}

/*
2199 2200
 * Called from idetape_chrdev_ioctl when the general mtio MTIOCTOP ioctl is
 * requested.
L
Linus Torvalds 已提交
2201
 *
2202 2203
 * 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
2204
 * usually not supported.
L
Linus Torvalds 已提交
2205
 *
2206
 * The following commands are currently not supported:
L
Linus Torvalds 已提交
2207
 *
2208 2209
 * MTFSS, MTBSS, MTWSM, MTSETDENSITY, MTSETDRVBUFFER, MT_ST_BOOLEANS,
 * MT_ST_WRITE_THRESHOLD.
L
Linus Torvalds 已提交
2210
 */
2211
static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
L
Linus Torvalds 已提交
2212 2213
{
	idetape_tape_t *tape = drive->driver_data;
2214
	struct ide_atapi_pc pc;
2215
	int i, retval;
L
Linus Torvalds 已提交
2216

2217 2218
	debug_log(DBG_ERR, "Handling MTIOCTOP ioctl: mt_op=%d, mt_count=%d\n",
			mt_op, mt_count);
2219

L
Linus Torvalds 已提交
2220
	switch (mt_op) {
2221 2222 2223 2224 2225 2226 2227 2228 2229
	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;
L
Linus Torvalds 已提交
2230
	}
2231

L
Linus Torvalds 已提交
2232
	switch (mt_op) {
2233 2234 2235
	case MTWEOF:
		if (tape->write_prot)
			return -EACCES;
2236
		ide_tape_discard_merge_buffer(drive, 1);
2237 2238 2239 2240 2241 2242 2243
		for (i = 0; i < mt_count; i++) {
			retval = idetape_write_filemark(drive);
			if (retval)
				return retval;
		}
		return 0;
	case MTREW:
2244
		ide_tape_discard_merge_buffer(drive, 0);
2245 2246 2247 2248
		if (idetape_rewind_tape(drive))
			return -EIO;
		return 0;
	case MTLOAD:
2249
		ide_tape_discard_merge_buffer(drive, 0);
2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263
		idetape_create_load_unload_cmd(drive, &pc,
					       IDETAPE_LU_LOAD_MASK);
		return idetape_queue_pc_tail(drive, &pc);
	case MTUNLOAD:
	case MTOFFL:
		/*
		 * If door is locked, attempt to unlock before
		 * attempting to eject.
		 */
		if (tape->door_locked) {
			if (idetape_create_prevent_cmd(drive, &pc, 0))
				if (!idetape_queue_pc_tail(drive, &pc))
					tape->door_locked = DOOR_UNLOCKED;
		}
2264
		ide_tape_discard_merge_buffer(drive, 0);
2265 2266 2267 2268
		idetape_create_load_unload_cmd(drive, &pc,
					      !IDETAPE_LU_LOAD_MASK);
		retval = idetape_queue_pc_tail(drive, &pc);
		if (!retval)
2269
			clear_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags);
2270 2271
		return retval;
	case MTNOP:
2272
		ide_tape_discard_merge_buffer(drive, 0);
2273 2274
		return idetape_flush_tape_buffers(drive);
	case MTRETEN:
2275
		ide_tape_discard_merge_buffer(drive, 0);
2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289
		idetape_create_load_unload_cmd(drive, &pc,
			IDETAPE_LU_RETENSION_MASK | IDETAPE_LU_LOAD_MASK);
		return idetape_queue_pc_tail(drive, &pc);
	case MTEOM:
		idetape_create_space_cmd(&pc, 0, IDETAPE_SPACE_TO_EOD);
		return idetape_queue_pc_tail(drive, &pc);
	case MTERASE:
		(void)idetape_rewind_tape(drive);
		idetape_create_erase_cmd(&pc);
		return idetape_queue_pc_tail(drive, &pc);
	case MTSETBLK:
		if (mt_count) {
			if (mt_count < tape->blk_size ||
			    mt_count % tape->blk_size)
L
Linus Torvalds 已提交
2290
				return -EIO;
2291
			tape->user_bs_factor = mt_count / tape->blk_size;
2292
			clear_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags);
2293
		} else
2294
			set_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags);
2295 2296
		return 0;
	case MTSEEK:
2297
		ide_tape_discard_merge_buffer(drive, 0);
2298 2299 2300
		return idetape_position_tape(drive,
			mt_count * tape->user_bs_factor, tape->partition, 0);
	case MTSETPART:
2301
		ide_tape_discard_merge_buffer(drive, 0);
2302 2303 2304 2305 2306
		return idetape_position_tape(drive, 0, mt_count, 0);
	case MTFSR:
	case MTBSR:
	case MTLOCK:
		if (!idetape_create_prevent_cmd(drive, &pc, 1))
L
Linus Torvalds 已提交
2307
			return 0;
2308 2309
		retval = idetape_queue_pc_tail(drive, &pc);
		if (retval)
L
Linus Torvalds 已提交
2310
			return retval;
2311 2312 2313 2314
		tape->door_locked = DOOR_EXPLICITLY_LOCKED;
		return 0;
	case MTUNLOCK:
		if (!idetape_create_prevent_cmd(drive, &pc, 0))
L
Linus Torvalds 已提交
2315
			return 0;
2316 2317 2318 2319 2320 2321 2322 2323 2324
		retval = idetape_queue_pc_tail(drive, &pc);
		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;
L
Linus Torvalds 已提交
2325 2326 2327 2328
	}
}

/*
2329 2330 2331
 * 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.
L
Linus Torvalds 已提交
2332
 */
2333 2334
static int idetape_chrdev_ioctl(struct inode *inode, struct file *file,
				unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
2335 2336 2337 2338 2339 2340
{
	struct ide_tape_obj *tape = ide_tape_f(file);
	ide_drive_t *drive = tape->drive;
	struct mtop mtop;
	struct mtget mtget;
	struct mtpos mtpos;
2341
	int block_offset = 0, position = tape->first_frame;
L
Linus Torvalds 已提交
2342 2343
	void __user *argp = (void __user *)arg;

2344
	debug_log(DBG_CHRDEV, "Enter %s, cmd=%u\n", __func__, cmd);
L
Linus Torvalds 已提交
2345

2346
	if (tape->chrdev_dir == IDETAPE_DIR_WRITE) {
2347
		ide_tape_flush_merge_buffer(drive);
L
Linus Torvalds 已提交
2348 2349 2350
		idetape_flush_tape_buffers(drive);
	}
	if (cmd == MTIOCGET || cmd == MTIOCPOS) {
2351
		block_offset = tape->merge_bh_size /
2352
			(tape->blk_size * tape->user_bs_factor);
2353 2354
		position = idetape_read_position(drive);
		if (position < 0)
L
Linus Torvalds 已提交
2355 2356 2357
			return -EIO;
	}
	switch (cmd) {
2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
	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);

		if (copy_to_user(argp, &mtget, sizeof(struct mtget)))
			return -EFAULT;
		return 0;
	case MTIOCPOS:
		mtpos.mt_blkno = position / tape->user_bs_factor - block_offset;
		if (copy_to_user(argp, &mtpos, sizeof(struct mtpos)))
			return -EFAULT;
		return 0;
	default:
		if (tape->chrdev_dir == IDETAPE_DIR_READ)
2383
			ide_tape_discard_merge_buffer(drive, 1);
2384
		return idetape_blkdev_ioctl(drive, cmd, arg);
L
Linus Torvalds 已提交
2385 2386 2387
	}
}

2388 2389 2390 2391 2392 2393 2394
/*
 * 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;
2395
	struct ide_atapi_pc pc;
2396 2397 2398 2399

	idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR);
	if (idetape_queue_pc_tail(drive, &pc)) {
		printk(KERN_ERR "ide-tape: Can't get block descriptor\n");
2400
		if (tape->blk_size == 0) {
2401 2402
			printk(KERN_WARNING "ide-tape: Cannot deal with zero "
					    "block size, assuming 32k\n");
2403
			tape->blk_size = 32768;
2404 2405 2406
		}
		return;
	}
2407 2408 2409 2410
	tape->blk_size = (pc.buf[4 + 5] << 16) +
				(pc.buf[4 + 6] << 8)  +
				 pc.buf[4 + 7];
	tape->drv_write_prot = (pc.buf[2] & 0x80) >> 7;
2411
}
L
Linus Torvalds 已提交
2412

2413
static int idetape_chrdev_open(struct inode *inode, struct file *filp)
L
Linus Torvalds 已提交
2414 2415 2416 2417
{
	unsigned int minor = iminor(inode), i = minor & ~0xc0;
	ide_drive_t *drive;
	idetape_tape_t *tape;
2418
	struct ide_atapi_pc pc;
L
Linus Torvalds 已提交
2419 2420
	int retval;

2421 2422 2423 2424 2425 2426 2427 2428 2429
	if (i >= MAX_HWIFS * MAX_DRIVES)
		return -ENXIO;

	tape = ide_tape_chrdev_get(i);
	if (!tape)
		return -ENXIO;

	debug_log(DBG_CHRDEV, "Enter %s\n", __func__);

L
Linus Torvalds 已提交
2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440
	/*
	 * 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);

	drive = tape->drive;

	filp->private_data = tape;

2441
	if (test_and_set_bit(IDETAPE_FLAG_BUSY, &tape->flags)) {
L
Linus Torvalds 已提交
2442 2443 2444 2445 2446 2447
		retval = -EBUSY;
		goto out_put_tape;
	}

	retval = idetape_wait_ready(drive, 60 * HZ);
	if (retval) {
2448
		clear_bit(IDETAPE_FLAG_BUSY, &tape->flags);
L
Linus Torvalds 已提交
2449 2450 2451 2452 2453
		printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name);
		goto out_put_tape;
	}

	idetape_read_position(drive);
2454
	if (!test_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags))
L
Linus Torvalds 已提交
2455 2456 2457
		(void)idetape_rewind_tape(drive);

	/* Read block size and write protect status from drive. */
2458
	ide_tape_get_bsize_from_bdesc(drive);
L
Linus Torvalds 已提交
2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469

	/* 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) {
2470
			clear_bit(IDETAPE_FLAG_BUSY, &tape->flags);
L
Linus Torvalds 已提交
2471 2472 2473 2474 2475
			retval = -EROFS;
			goto out_put_tape;
		}
	}

2476
	/* Lock the tape drive door so user can't eject. */
2477
	if (tape->chrdev_dir == IDETAPE_DIR_NONE) {
L
Linus Torvalds 已提交
2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491
		if (idetape_create_prevent_cmd(drive, &pc, 1)) {
			if (!idetape_queue_pc_tail(drive, &pc)) {
				if (tape->door_locked != DOOR_EXPLICITLY_LOCKED)
					tape->door_locked = DOOR_LOCKED;
			}
		}
	}
	return 0;

out_put_tape:
	ide_tape_put(tape);
	return retval;
}

2492
static void idetape_write_release(ide_drive_t *drive, unsigned int minor)
L
Linus Torvalds 已提交
2493 2494 2495
{
	idetape_tape_t *tape = drive->driver_data;

2496
	ide_tape_flush_merge_buffer(drive);
2497 2498
	tape->merge_bh = ide_tape_kmalloc_buffer(tape, 1, 0);
	if (tape->merge_bh != NULL) {
2499 2500
		idetape_pad_zeros(drive, tape->blk_size *
				(tape->user_bs_factor - 1));
2501 2502
		ide_tape_kfree_buffer(tape);
		tape->merge_bh = NULL;
L
Linus Torvalds 已提交
2503 2504 2505 2506 2507 2508
	}
	idetape_write_filemark(drive);
	idetape_flush_tape_buffers(drive);
	idetape_flush_tape_buffers(drive);
}

2509
static int idetape_chrdev_release(struct inode *inode, struct file *filp)
L
Linus Torvalds 已提交
2510 2511 2512
{
	struct ide_tape_obj *tape = ide_tape_f(filp);
	ide_drive_t *drive = tape->drive;
2513
	struct ide_atapi_pc pc;
L
Linus Torvalds 已提交
2514 2515 2516 2517
	unsigned int minor = iminor(inode);

	lock_kernel();
	tape = drive->driver_data;
2518 2519

	debug_log(DBG_CHRDEV, "Enter %s\n", __func__);
L
Linus Torvalds 已提交
2520

2521
	if (tape->chrdev_dir == IDETAPE_DIR_WRITE)
L
Linus Torvalds 已提交
2522
		idetape_write_release(drive, minor);
2523
	if (tape->chrdev_dir == IDETAPE_DIR_READ) {
L
Linus Torvalds 已提交
2524
		if (minor < 128)
2525
			ide_tape_discard_merge_buffer(drive, 1);
L
Linus Torvalds 已提交
2526
	}
2527

2528
	if (minor < 128 && test_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags))
L
Linus Torvalds 已提交
2529
		(void) idetape_rewind_tape(drive);
2530
	if (tape->chrdev_dir == IDETAPE_DIR_NONE) {
L
Linus Torvalds 已提交
2531 2532 2533 2534 2535 2536 2537
		if (tape->door_locked == DOOR_LOCKED) {
			if (idetape_create_prevent_cmd(drive, &pc, 0)) {
				if (!idetape_queue_pc_tail(drive, &pc))
					tape->door_locked = DOOR_UNLOCKED;
			}
		}
	}
2538
	clear_bit(IDETAPE_FLAG_BUSY, &tape->flags);
L
Linus Torvalds 已提交
2539 2540 2541 2542 2543 2544
	ide_tape_put(tape);
	unlock_kernel();
	return 0;
}

/*
2545
 * check the contents of the ATAPI IDENTIFY command results. We return:
L
Linus Torvalds 已提交
2546
 *
2547 2548
 * 1 - If the tape can be supported by us, based on the information we have so
 * far.
L
Linus Torvalds 已提交
2549
 *
2550
 * 0 - If this tape driver is not currently supported by us.
L
Linus Torvalds 已提交
2551
 */
2552
static int idetape_identify_device(ide_drive_t *drive)
L
Linus Torvalds 已提交
2553
{
2554
	u8 gcw[2], protocol, device_type, removable, packet_size;
L
Linus Torvalds 已提交
2555 2556 2557 2558

	if (drive->id_read == 0)
		return 1;

2559
	*((unsigned short *) &gcw) = drive->id->config;
L
Linus Torvalds 已提交
2560

2561 2562 2563 2564
	protocol	=   (gcw[1] & 0xC0) >> 6;
	device_type	=    gcw[1] & 0x1F;
	removable	= !!(gcw[0] & 0x80);
	packet_size	=    gcw[0] & 0x3;
L
Linus Torvalds 已提交
2565

2566 2567
	/* Check that we can support this device */
	if (protocol != 2)
2568
		printk(KERN_ERR "ide-tape: Protocol (0x%02x) is not ATAPI\n",
2569 2570
				protocol);
	else if (device_type != 1)
2571
		printk(KERN_ERR "ide-tape: Device type (0x%02x) is not set "
2572 2573
				"to tape\n", device_type);
	else if (!removable)
L
Linus Torvalds 已提交
2574
		printk(KERN_ERR "ide-tape: The removable flag is not set\n");
2575
	else if (packet_size != 0) {
2576 2577
		printk(KERN_ERR "ide-tape: Packet size (0x%02x) is not 12"
				" bytes\n", packet_size);
L
Linus Torvalds 已提交
2578 2579 2580 2581 2582
	} else
		return 1;
	return 0;
}

2583
static void idetape_get_inquiry_results(ide_drive_t *drive)
L
Linus Torvalds 已提交
2584 2585
{
	idetape_tape_t *tape = drive->driver_data;
2586
	struct ide_atapi_pc pc;
2587
	char fw_rev[6], vendor_id[10], product_id[18];
2588

L
Linus Torvalds 已提交
2589 2590
	idetape_create_inquiry_cmd(&pc);
	if (idetape_queue_pc_tail(drive, &pc)) {
2591 2592
		printk(KERN_ERR "ide-tape: %s: can't get INQUIRY results\n",
				tape->name);
L
Linus Torvalds 已提交
2593 2594
		return;
	}
2595 2596 2597
	memcpy(vendor_id, &pc.buf[8], 8);
	memcpy(product_id, &pc.buf[16], 16);
	memcpy(fw_rev, &pc.buf[32], 4);
2598 2599 2600 2601 2602

	ide_fixstring(vendor_id, 10, 0);
	ide_fixstring(product_id, 18, 0);
	ide_fixstring(fw_rev, 6, 0);

2603
	printk(KERN_INFO "ide-tape: %s <-> %s: %s %s rev %s\n",
2604
			drive->name, tape->name, vendor_id, product_id, fw_rev);
L
Linus Torvalds 已提交
2605 2606 2607
}

/*
2608 2609
 * 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.
L
Linus Torvalds 已提交
2610
 */
2611
static void idetape_get_mode_sense_results(ide_drive_t *drive)
L
Linus Torvalds 已提交
2612 2613
{
	idetape_tape_t *tape = drive->driver_data;
2614
	struct ide_atapi_pc pc;
2615 2616
	u8 *caps;
	u8 speed, max_speed;
2617

L
Linus Torvalds 已提交
2618 2619
	idetape_create_mode_sense_cmd(&pc, IDETAPE_CAPABILITIES_PAGE);
	if (idetape_queue_pc_tail(drive, &pc)) {
2620 2621
		printk(KERN_ERR "ide-tape: Can't get tape parameters - assuming"
				" some default values\n");
2622
		tape->blk_size = 512;
2623 2624 2625
		put_unaligned(52,   (u16 *)&tape->caps[12]);
		put_unaligned(540,  (u16 *)&tape->caps[14]);
		put_unaligned(6*52, (u16 *)&tape->caps[16]);
L
Linus Torvalds 已提交
2626 2627
		return;
	}
2628
	caps = pc.buf + 4 + pc.buf[3];
2629 2630 2631 2632

	/* convert to host order and save for later use */
	speed = be16_to_cpu(*(u16 *)&caps[14]);
	max_speed = be16_to_cpu(*(u16 *)&caps[8]);
L
Linus Torvalds 已提交
2633

2634 2635 2636 2637
	put_unaligned(max_speed, (u16 *)&caps[8]);
	put_unaligned(be16_to_cpu(*(u16 *)&caps[12]), (u16 *)&caps[12]);
	put_unaligned(speed, (u16 *)&caps[14]);
	put_unaligned(be16_to_cpu(*(u16 *)&caps[16]), (u16 *)&caps[16]);
L
Linus Torvalds 已提交
2638

2639 2640 2641 2642
	if (!speed) {
		printk(KERN_INFO "ide-tape: %s: invalid tape speed "
				"(assuming 650KB/sec)\n", drive->name);
		put_unaligned(650, (u16 *)&caps[14]);
L
Linus Torvalds 已提交
2643
	}
2644 2645 2646 2647
	if (!max_speed) {
		printk(KERN_INFO "ide-tape: %s: invalid max_speed "
				"(assuming 650KB/sec)\n", drive->name);
		put_unaligned(650, (u16 *)&caps[8]);
L
Linus Torvalds 已提交
2648 2649
	}

2650 2651
	memcpy(&tape->caps, caps, 20);
	if (caps[7] & 0x02)
2652
		tape->blk_size = 512;
2653
	else if (caps[7] & 0x04)
2654
		tape->blk_size = 1024;
L
Linus Torvalds 已提交
2655 2656
}

2657
#ifdef CONFIG_IDE_PROC_FS
2658
static void idetape_add_settings(ide_drive_t *drive)
L
Linus Torvalds 已提交
2659 2660 2661
{
	idetape_tape_t *tape = drive->driver_data;

2662 2663 2664 2665
	ide_add_setting(drive, "buffer", SETTING_READ, TYPE_SHORT, 0, 0xffff,
			1, 2, (u16 *)&tape->caps[16], NULL);
	ide_add_setting(drive, "speed", SETTING_READ, TYPE_SHORT, 0, 0xffff,
			1, 1, (u16 *)&tape->caps[14], NULL);
2666 2667
	ide_add_setting(drive, "buffer_size", SETTING_READ, TYPE_INT, 0, 0xffff,
			1, 1024, &tape->buffer_size, NULL);
2668 2669 2670
	ide_add_setting(drive, "tdsc", SETTING_RW, TYPE_INT, IDETAPE_DSC_RW_MIN,
			IDETAPE_DSC_RW_MAX, 1000, HZ, &tape->best_dsc_rw_freq,
			NULL);
2671 2672 2673 2674
	ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1,
			1, &drive->dsc_overlap, NULL);
	ide_add_setting(drive, "avg_speed", SETTING_READ, TYPE_INT, 0, 0xffff,
			1, 1, &tape->avg_speed, NULL);
2675 2676
	ide_add_setting(drive, "debug_mask", SETTING_RW, TYPE_INT, 0, 0xffff, 1,
			1, &tape->debug_mask, NULL);
L
Linus Torvalds 已提交
2677
}
2678 2679 2680
#else
static inline void idetape_add_settings(ide_drive_t *drive) { ; }
#endif
L
Linus Torvalds 已提交
2681 2682

/*
2683
 * The function below is called to:
L
Linus Torvalds 已提交
2684
 *
2685 2686 2687 2688
 * 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.
L
Linus Torvalds 已提交
2689
 *
2690 2691
 * Note that at this point ide.c already assigned us an irq, so that we can
 * queue requests here and wait for their completion.
L
Linus Torvalds 已提交
2692
 */
2693
static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor)
L
Linus Torvalds 已提交
2694
{
2695
	unsigned long t;
L
Linus Torvalds 已提交
2696
	int speed;
2697
	int buffer_size;
2698
	u8 gcw[2];
2699
	u16 *ctl = (u16 *)&tape->caps[12];
L
Linus Torvalds 已提交
2700

2701
	spin_lock_init(&tape->lock);
L
Linus Torvalds 已提交
2702
	drive->dsc_overlap = 1;
2703 2704 2705 2706
	if (drive->hwif->host_flags & IDE_HFLAG_NO_DSC) {
		printk(KERN_INFO "ide-tape: %s: disabling DSC overlap\n",
				 tape->name);
		drive->dsc_overlap = 0;
L
Linus Torvalds 已提交
2707 2708 2709 2710 2711 2712 2713 2714
	}
	/* Seagate Travan drives do not support DSC overlap. */
	if (strstr(drive->id->model, "Seagate STT3401"))
		drive->dsc_overlap = 0;
	tape->minor = minor;
	tape->name[0] = 'h';
	tape->name[1] = 't';
	tape->name[2] = '0' + minor;
2715
	tape->chrdev_dir = IDETAPE_DIR_NONE;
L
Linus Torvalds 已提交
2716 2717
	tape->pc = tape->pc_stack;
	*((unsigned short *) &gcw) = drive->id->config;
2718 2719 2720

	/* Command packet DRQ type */
	if (((gcw[0] & 0x60) >> 5) == 1)
2721
		set_bit(IDETAPE_FLAG_DRQ_INTERRUPT, &tape->flags);
L
Linus Torvalds 已提交
2722 2723 2724

	idetape_get_inquiry_results(drive);
	idetape_get_mode_sense_results(drive);
2725
	ide_tape_get_bsize_from_bdesc(drive);
L
Linus Torvalds 已提交
2726
	tape->user_bs_factor = 1;
2727 2728
	tape->buffer_size = *ctl * tape->blk_size;
	while (tape->buffer_size > 0xffff) {
L
Linus Torvalds 已提交
2729
		printk(KERN_NOTICE "ide-tape: decreasing stage size\n");
2730
		*ctl /= 2;
2731
		tape->buffer_size = *ctl * tape->blk_size;
L
Linus Torvalds 已提交
2732
	}
2733
	buffer_size = tape->buffer_size;
2734
	tape->pages_per_buffer = buffer_size / PAGE_SIZE;
2735
	if (buffer_size % PAGE_SIZE) {
2736
		tape->pages_per_buffer++;
2737
		tape->excess_bh_size = PAGE_SIZE - buffer_size % PAGE_SIZE;
L
Linus Torvalds 已提交
2738 2739
	}

2740
	/* select the "best" DSC read/write polling freq */
2741
	speed = max(*(u16 *)&tape->caps[14], *(u16 *)&tape->caps[8]);
L
Linus Torvalds 已提交
2742

2743
	t = (IDETAPE_FIFO_THRESHOLD * tape->buffer_size * HZ) / (speed * 1000);
L
Linus Torvalds 已提交
2744 2745

	/*
2746 2747
	 * Ensure that the number we got makes sense; limit it within
	 * IDETAPE_DSC_RW_MIN and IDETAPE_DSC_RW_MAX.
L
Linus Torvalds 已提交
2748
	 */
2749 2750 2751
	tape->best_dsc_rw_freq = max_t(unsigned long,
				min_t(unsigned long, t, IDETAPE_DSC_RW_MAX),
				IDETAPE_DSC_RW_MIN);
L
Linus Torvalds 已提交
2752
	printk(KERN_INFO "ide-tape: %s <-> %s: %dKBps, %d*%dkB buffer, "
2753
		"%lums tDSC%s\n",
2754
		drive->name, tape->name, *(u16 *)&tape->caps[14],
2755 2756
		(*(u16 *)&tape->caps[16] * 512) / tape->buffer_size,
		tape->buffer_size / 1024,
2757
		tape->best_dsc_rw_freq * 1000 / HZ,
L
Linus Torvalds 已提交
2758 2759 2760 2761 2762
		drive->using_dma ? ", DMA":"");

	idetape_add_settings(drive);
}

2763
static void ide_tape_remove(ide_drive_t *drive)
L
Linus Torvalds 已提交
2764 2765 2766
{
	idetape_tape_t *tape = drive->driver_data;

2767
	ide_proc_unregister_driver(drive, tape->driver);
L
Linus Torvalds 已提交
2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779

	ide_unregister_region(tape->disk);

	ide_tape_put(tape);
}

static void ide_tape_release(struct kref *kref)
{
	struct ide_tape_obj *tape = to_ide_tape(kref);
	ide_drive_t *drive = tape->drive;
	struct gendisk *g = tape->disk;

2780
	BUG_ON(tape->merge_bh_size);
2781

L
Linus Torvalds 已提交
2782 2783
	drive->dsc_overlap = 0;
	drive->driver_data = NULL;
2784
	device_destroy(idetape_sysfs_class, MKDEV(IDETAPE_MAJOR, tape->minor));
2785 2786
	device_destroy(idetape_sysfs_class,
			MKDEV(IDETAPE_MAJOR, tape->minor + 128));
L
Linus Torvalds 已提交
2787 2788 2789 2790 2791 2792
	idetape_devs[tape->minor] = NULL;
	g->private_data = NULL;
	put_disk(g);
	kfree(tape);
}

2793
#ifdef CONFIG_IDE_PROC_FS
L
Linus Torvalds 已提交
2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812
static int proc_idetape_read_name
	(char *page, char **start, off_t off, int count, int *eof, void *data)
{
	ide_drive_t	*drive = (ide_drive_t *) data;
	idetape_tape_t	*tape = drive->driver_data;
	char		*out = page;
	int		len;

	len = sprintf(out, "%s\n", tape->name);
	PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
}

static ide_proc_entry_t idetape_proc[] = {
	{ "capacity",	S_IFREG|S_IRUGO,	proc_ide_read_capacity, NULL },
	{ "name",	S_IFREG|S_IRUGO,	proc_idetape_read_name,	NULL },
	{ NULL, 0, NULL, NULL }
};
#endif

2813
static int ide_tape_probe(ide_drive_t *);
L
Linus Torvalds 已提交
2814 2815

static ide_driver_t idetape_driver = {
2816
	.gen_driver = {
2817
		.owner		= THIS_MODULE,
2818 2819 2820
		.name		= "ide-tape",
		.bus		= &ide_bus_type,
	},
2821 2822
	.probe			= ide_tape_probe,
	.remove			= ide_tape_remove,
L
Linus Torvalds 已提交
2823 2824 2825 2826 2827 2828 2829
	.version		= IDETAPE_VERSION,
	.media			= ide_tape,
	.supports_dsc_overlap 	= 1,
	.do_request		= idetape_do_request,
	.end_request		= idetape_end_request,
	.error			= __ide_error,
	.abort			= __ide_abort,
2830
#ifdef CONFIG_IDE_PROC_FS
L
Linus Torvalds 已提交
2831
	.proc			= idetape_proc,
2832
#endif
L
Linus Torvalds 已提交
2833 2834
};

2835
/* Our character device supporting functions, passed to register_chrdev. */
2836
static const struct file_operations idetape_fops = {
L
Linus Torvalds 已提交
2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849
	.owner		= THIS_MODULE,
	.read		= idetape_chrdev_read,
	.write		= idetape_chrdev_write,
	.ioctl		= idetape_chrdev_ioctl,
	.open		= idetape_chrdev_open,
	.release	= idetape_chrdev_release,
};

static int idetape_open(struct inode *inode, struct file *filp)
{
	struct gendisk *disk = inode->i_bdev->bd_disk;
	struct ide_tape_obj *tape;

2850 2851
	tape = ide_tape_get(disk);
	if (!tape)
L
Linus Torvalds 已提交
2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885
		return -ENXIO;

	return 0;
}

static int idetape_release(struct inode *inode, struct file *filp)
{
	struct gendisk *disk = inode->i_bdev->bd_disk;
	struct ide_tape_obj *tape = ide_tape_g(disk);

	ide_tape_put(tape);

	return 0;
}

static int idetape_ioctl(struct inode *inode, struct file *file,
			unsigned int cmd, unsigned long arg)
{
	struct block_device *bdev = inode->i_bdev;
	struct ide_tape_obj *tape = ide_tape_g(bdev->bd_disk);
	ide_drive_t *drive = tape->drive;
	int err = generic_ide_ioctl(drive, file, bdev, cmd, arg);
	if (err == -EINVAL)
		err = idetape_blkdev_ioctl(drive, cmd, arg);
	return err;
}

static struct block_device_operations idetape_block_ops = {
	.owner		= THIS_MODULE,
	.open		= idetape_open,
	.release	= idetape_release,
	.ioctl		= idetape_ioctl,
};

2886
static int ide_tape_probe(ide_drive_t *drive)
L
Linus Torvalds 已提交
2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897
{
	idetape_tape_t *tape;
	struct gendisk *g;
	int minor;

	if (!strstr("ide-tape", drive->driver_req))
		goto failed;
	if (!drive->present)
		goto failed;
	if (drive->media != ide_tape)
		goto failed;
2898 2899 2900
	if (!idetape_identify_device(drive)) {
		printk(KERN_ERR "ide-tape: %s: not supported by this version of"
				" the driver\n", drive->name);
L
Linus Torvalds 已提交
2901 2902 2903
		goto failed;
	}
	if (drive->scsi) {
2904 2905
		printk(KERN_INFO "ide-tape: passing drive %s to ide-scsi"
				 " emulation.\n", drive->name);
L
Linus Torvalds 已提交
2906 2907
		goto failed;
	}
2908
	tape = kzalloc(sizeof(idetape_tape_t), GFP_KERNEL);
L
Linus Torvalds 已提交
2909
	if (tape == NULL) {
2910 2911
		printk(KERN_ERR "ide-tape: %s: Can't allocate a tape struct\n",
				drive->name);
L
Linus Torvalds 已提交
2912 2913 2914 2915 2916 2917 2918 2919 2920
		goto failed;
	}

	g = alloc_disk(1 << PARTN_BITS);
	if (!g)
		goto out_free_tape;

	ide_init_disk(g, drive);

2921
	ide_proc_register_driver(drive, &idetape_driver);
L
Linus Torvalds 已提交
2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932

	kref_init(&tape->kref);

	tape->drive = drive;
	tape->driver = &idetape_driver;
	tape->disk = g;

	g->private_data = &tape->driver;

	drive->driver_data = tape;

2933
	mutex_lock(&idetape_ref_mutex);
L
Linus Torvalds 已提交
2934 2935 2936
	for (minor = 0; idetape_devs[minor]; minor++)
		;
	idetape_devs[minor] = tape;
2937
	mutex_unlock(&idetape_ref_mutex);
L
Linus Torvalds 已提交
2938 2939 2940

	idetape_setup(drive, tape, minor);

2941 2942 2943 2944
	device_create(idetape_sysfs_class, &drive->gendev,
		      MKDEV(IDETAPE_MAJOR, minor), "%s", tape->name);
	device_create(idetape_sysfs_class, &drive->gendev,
			MKDEV(IDETAPE_MAJOR, minor + 128), "n%s", tape->name);
2945

L
Linus Torvalds 已提交
2946 2947 2948 2949
	g->fops = &idetape_block_ops;
	ide_register_region(g);

	return 0;
2950

L
Linus Torvalds 已提交
2951 2952 2953
out_free_tape:
	kfree(tape);
failed:
2954
	return -ENODEV;
L
Linus Torvalds 已提交
2955 2956
}

2957
static void __exit idetape_exit(void)
L
Linus Torvalds 已提交
2958
{
2959
	driver_unregister(&idetape_driver.gen_driver);
2960
	class_destroy(idetape_sysfs_class);
L
Linus Torvalds 已提交
2961 2962 2963
	unregister_chrdev(IDETAPE_MAJOR, "ht");
}

2964
static int __init idetape_init(void)
L
Linus Torvalds 已提交
2965
{
2966 2967 2968 2969 2970 2971 2972 2973 2974
	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;
	}

L
Linus Torvalds 已提交
2975
	if (register_chrdev(IDETAPE_MAJOR, "ht", &idetape_fops)) {
2976 2977
		printk(KERN_ERR "ide-tape: Failed to register chrdev"
				" interface\n");
2978 2979
		error = -EBUSY;
		goto out_free_class;
L
Linus Torvalds 已提交
2980
	}
2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993

	error = driver_register(&idetape_driver.gen_driver);
	if (error)
		goto out_free_driver;

	return 0;

out_free_driver:
	driver_unregister(&idetape_driver.gen_driver);
out_free_class:
	class_destroy(idetape_sysfs_class);
out:
	return error;
L
Linus Torvalds 已提交
2994 2995
}

2996
MODULE_ALIAS("ide:*m-tape*");
L
Linus Torvalds 已提交
2997 2998 2999
module_init(idetape_init);
module_exit(idetape_exit);
MODULE_ALIAS_CHARDEV_MAJOR(IDETAPE_MAJOR);
3000 3001
MODULE_DESCRIPTION("ATAPI Streaming TAPE Driver");
MODULE_LICENSE("GPL");