ide-floppy.c 38.5 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
B
Borislav Petkov 已提交
2 3
 * IDE ATAPI floppy driver.
 *
4 5 6
 * Copyright (C) 1996-1999  Gadi Oxman <gadio@netvision.net.il>
 * Copyright (C) 2000-2002  Paul Bristow <paul@paulbristow.net>
 * Copyright (C) 2005       Bartlomiej Zolnierkiewicz
7
 *
L
Linus Torvalds 已提交
8 9 10 11 12 13
 * This driver supports the following IDE floppy drives:
 *
 * LS-120/240 SuperDisk
 * Iomega Zip 100/250
 * Iomega PC Card Clik!/PocketZip
 *
B
Borislav Petkov 已提交
14 15
 * For a historical changelog see
 * Documentation/ide/ChangeLog.ide-floppy.1996-2002
L
Linus Torvalds 已提交
16 17
 */

18
#define IDEFLOPPY_VERSION "1.00"
L
Linus Torvalds 已提交
19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

#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>
#include <linux/major.h>
#include <linux/errno.h>
#include <linux/genhd.h>
#include <linux/slab.h>
#include <linux/cdrom.h>
#include <linux/ide.h>
#include <linux/bitops.h>
35
#include <linux/mutex.h>
L
Linus Torvalds 已提交
36

37 38
#include <scsi/scsi_ioctl.h>

L
Linus Torvalds 已提交
39
#include <asm/byteorder.h>
40 41 42
#include <linux/irq.h>
#include <linux/uaccess.h>
#include <linux/io.h>
L
Linus Torvalds 已提交
43 44
#include <asm/unaligned.h>

45
/* define to see debug info */
L
Linus Torvalds 已提交
46 47 48
#define IDEFLOPPY_DEBUG_LOG		0

/* #define IDEFLOPPY_DEBUG(fmt, args...) printk(KERN_INFO fmt, ## args) */
49
#define IDEFLOPPY_DEBUG(fmt, args...)
L
Linus Torvalds 已提交
50 51

#if IDEFLOPPY_DEBUG_LOG
52 53
#define debug_log(fmt, args...) \
	printk(KERN_INFO "ide-floppy: " fmt, ## args)
L
Linus Torvalds 已提交
54
#else
55
#define debug_log(fmt, args...) do {} while (0)
L
Linus Torvalds 已提交
56 57 58
#endif


59
/* Some drives require a longer irq timeout. */
L
Linus Torvalds 已提交
60 61 62
#define IDEFLOPPY_WAIT_CMD		(5 * WAIT_CMD)

/*
63 64
 * After each failed packet command we issue a request sense command and retry
 * the packet command IDEFLOPPY_MAX_PC_RETRIES times.
L
Linus Torvalds 已提交
65 66 67 68
 */
#define IDEFLOPPY_MAX_PC_RETRIES	3

/*
69 70
 * With each packet command, we allocate a buffer of IDEFLOPPY_PC_BUFFER_SIZE
 * bytes.
L
Linus Torvalds 已提交
71 72 73 74
 */
#define IDEFLOPPY_PC_BUFFER_SIZE	256

/*
75 76 77
 * 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.
L
Linus Torvalds 已提交
78 79 80
 */
#define IDEFLOPPY_PC_STACK		(10 + IDEFLOPPY_MAX_PC_RETRIES)

81
/* format capacities descriptor codes */
L
Linus Torvalds 已提交
82 83 84 85 86 87
#define CAPACITY_INVALID	0x00
#define CAPACITY_UNFORMATTED	0x01
#define CAPACITY_CURRENT	0x02
#define CAPACITY_NO_CARTRIDGE	0x03

/*
88 89 90
 * 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 a variable of type
 * idefloppy_floppy_t, defined below.
L
Linus Torvalds 已提交
91 92 93 94 95 96
 */
typedef struct ide_floppy_obj {
	ide_drive_t	*drive;
	ide_driver_t	*driver;
	struct gendisk	*disk;
	struct kref	kref;
97
	unsigned int	openers;	/* protected by BKL for now */
L
Linus Torvalds 已提交
98 99

	/* Current packet command */
100
	struct ide_atapi_pc *pc;
L
Linus Torvalds 已提交
101
	/* Last failed packet command */
102
	struct ide_atapi_pc *failed_pc;
L
Linus Torvalds 已提交
103
	/* Packet command stack */
104
	struct ide_atapi_pc pc_stack[IDEFLOPPY_PC_STACK];
L
Linus Torvalds 已提交
105 106 107 108 109 110
	/* Next free packet command storage space */
	int pc_stack_index;
	struct request rq_stack[IDEFLOPPY_PC_STACK];
	/* We implement a circular array */
	int rq_stack_index;

111
	/* Last error information */
L
Linus Torvalds 已提交
112 113 114 115 116
	u8 sense_key, asc, ascq;
	/* delay this long before sending packet command */
	u8 ticks;
	int progress_indication;

117
	/* Device information */
L
Linus Torvalds 已提交
118 119
	/* Current format */
	int blocks, block_size, bs_factor;
120 121
	/* Last format capacity descriptor */
	u8 cap_desc[8];
L
Linus Torvalds 已提交
122
	/* Copy of the flexible disk page */
123
	u8 flexible_disk_page[32];
L
Linus Torvalds 已提交
124 125 126 127 128 129 130 131
	/* Write protect */
	int wp;
	/* Supports format progress report */
	int srfp;
	/* Status/Action flags */
	unsigned long flags;
} idefloppy_floppy_t;

132
#define IDEFLOPPY_TICKS_DELAY	HZ/20	/* default delay for ZIP 100 (50ms) */
L
Linus Torvalds 已提交
133

134 135 136 137 138 139 140 141 142 143 144 145 146
/* Floppy flag bits values. */
enum {
	/* DRQ interrupt device */
	IDEFLOPPY_FLAG_DRQ_INTERRUPT		= (1 <<	0),
	/* Media may have changed */
	IDEFLOPPY_FLAG_MEDIA_CHANGED		= (1 << 1),
	/* Format in progress */
	IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS	= (1 << 2),
	/* Avoid commands not supported in Clik drive */
	IDEFLOPPY_FLAG_CLIK_DRIVE		= (1 << 3),
	/* Requires BH algorithm for packets */
	IDEFLOPPY_FLAG_ZIP_DRIVE		= (1 << 4),
};
L
Linus Torvalds 已提交
147

148
/* Defines for the MODE SENSE command */
L
Linus Torvalds 已提交
149 150
#define MODE_SENSE_CURRENT		0x00
#define MODE_SENSE_CHANGEABLE		0x01
151
#define MODE_SENSE_DEFAULT		0x02
L
Linus Torvalds 已提交
152 153
#define MODE_SENSE_SAVED		0x03

154
/* IOCTLs used in low-level formatting. */
L
Linus Torvalds 已提交
155 156 157 158 159
#define	IDEFLOPPY_IOCTL_FORMAT_SUPPORTED	0x4600
#define	IDEFLOPPY_IOCTL_FORMAT_GET_CAPACITY	0x4601
#define	IDEFLOPPY_IOCTL_FORMAT_START		0x4602
#define IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS	0x4603

160
/* Error code returned in rq->errors to the higher part of the driver. */
L
Linus Torvalds 已提交
161 162 163
#define	IDEFLOPPY_ERROR_GENERAL		101

/*
164 165
 * Pages of the SELECT SENSE / MODE SENSE packet commands.
 * See SFF-8070i spec.
L
Linus Torvalds 已提交
166 167 168 169
 */
#define	IDEFLOPPY_CAPABILITIES_PAGE	0x1b
#define IDEFLOPPY_FLEXIBLE_DISK_PAGE	0x05

170
static DEFINE_MUTEX(idefloppy_ref_mutex);
L
Linus Torvalds 已提交
171 172 173 174 175 176 177 178 179 180

#define to_ide_floppy(obj) container_of(obj, struct ide_floppy_obj, kref)

#define ide_floppy_g(disk) \
	container_of((disk)->private_data, struct ide_floppy_obj, driver)

static struct ide_floppy_obj *ide_floppy_get(struct gendisk *disk)
{
	struct ide_floppy_obj *floppy = NULL;

181
	mutex_lock(&idefloppy_ref_mutex);
L
Linus Torvalds 已提交
182 183 184
	floppy = ide_floppy_g(disk);
	if (floppy)
		kref_get(&floppy->kref);
185
	mutex_unlock(&idefloppy_ref_mutex);
L
Linus Torvalds 已提交
186 187 188
	return floppy;
}

189
static void idefloppy_cleanup_obj(struct kref *);
L
Linus Torvalds 已提交
190 191 192

static void ide_floppy_put(struct ide_floppy_obj *floppy)
{
193
	mutex_lock(&idefloppy_ref_mutex);
194
	kref_put(&floppy->kref, idefloppy_cleanup_obj);
195
	mutex_unlock(&idefloppy_ref_mutex);
L
Linus Torvalds 已提交
196 197 198
}

/*
199 200
 * Used to finish servicing a request. For read/write requests, we will call
 * ide_end_request to pass to the next buffer.
L
Linus Torvalds 已提交
201
 */
202
static int idefloppy_end_request(ide_drive_t *drive, int uptodate, int nsecs)
L
Linus Torvalds 已提交
203 204 205 206 207
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	struct request *rq = HWGROUP(drive)->rq;
	int error;

208
	debug_log("Reached %s\n", __func__);
L
Linus Torvalds 已提交
209 210

	switch (uptodate) {
211 212 213
	case 0: error = IDEFLOPPY_ERROR_GENERAL; break;
	case 1: error = 0; break;
	default: error = uptodate;
L
Linus Torvalds 已提交
214 215 216 217 218 219
	}
	if (error)
		floppy->failed_pc = NULL;
	/* Why does this happen? */
	if (!rq)
		return 0;
220
	if (!blk_special_request(rq)) {
L
Linus Torvalds 已提交
221 222 223 224 225 226 227 228 229 230
		/* our real local end request function */
		ide_end_request(drive, uptodate, nsecs);
		return 0;
	}
	rq->errors = error;
	/* fixme: need to move this local also */
	ide_end_drive_cmd(drive, 0, 0);
	return 0;
}

231
static void ide_floppy_io_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
232
				  unsigned int bcount, int direction)
L
Linus Torvalds 已提交
233
{
234
	ide_hwif_t *hwif = drive->hwif;
L
Linus Torvalds 已提交
235
	struct request *rq = pc->rq;
236
	struct req_iterator iter;
L
Linus Torvalds 已提交
237 238
	struct bio_vec *bvec;
	unsigned long flags;
239
	int count, done = 0;
L
Linus Torvalds 已提交
240 241
	char *data;

242
	rq_for_each_segment(bvec, rq, iter) {
243 244
		if (!bcount)
			break;
L
Linus Torvalds 已提交
245

246
		count = min(bvec->bv_len, bcount);
L
Linus Torvalds 已提交
247

248
		data = bvec_kmap_irq(bvec, &flags);
249
		if (direction)
250
			hwif->tp_ops->output_data(drive, NULL, data, count);
251
		else
252
			hwif->tp_ops->input_data(drive, NULL, data, count);
253
		bvec_kunmap_irq(data, &flags);
L
Linus Torvalds 已提交
254

255 256 257
		bcount -= count;
		pc->b_count += count;
		done += count;
L
Linus Torvalds 已提交
258 259
	}

260
	idefloppy_end_request(drive, 1, done >> 9);
L
Linus Torvalds 已提交
261 262

	if (bcount) {
263 264
		printk(KERN_ERR "%s: leftover data in %s, bcount == %d\n",
				drive->name, __func__, bcount);
265
		ide_pad_transfer(drive, direction, bcount);
L
Linus Torvalds 已提交
266 267 268
	}
}

269 270
static void idefloppy_update_buffers(ide_drive_t *drive,
				struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
271 272 273 274 275
{
	struct request *rq = pc->rq;
	struct bio *bio = rq->bio;

	while ((bio = rq->bio) != NULL)
276
		idefloppy_end_request(drive, 1, 0);
L
Linus Torvalds 已提交
277 278 279
}

/*
280 281 282
 * 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.
L
Linus Torvalds 已提交
283
 */
284
static void idefloppy_queue_pc_head(ide_drive_t *drive, struct ide_atapi_pc *pc,
285
		struct request *rq)
L
Linus Torvalds 已提交
286 287 288
{
	struct ide_floppy_obj *floppy = drive->driver_data;

F
FUJITA Tomonori 已提交
289
	blk_rq_init(NULL, rq);
L
Linus Torvalds 已提交
290
	rq->buffer = (char *) pc;
291
	rq->cmd_type = REQ_TYPE_SPECIAL;
292
	rq->cmd_flags |= REQ_PREEMPT;
L
Linus Torvalds 已提交
293
	rq->rq_disk = floppy->disk;
294
	memcpy(rq->cmd, pc->c, 12);
295
	ide_do_drive_cmd(drive, rq);
L
Linus Torvalds 已提交
296 297
}

298
static struct ide_atapi_pc *idefloppy_next_pc_storage(ide_drive_t *drive)
L
Linus Torvalds 已提交
299 300 301 302
{
	idefloppy_floppy_t *floppy = drive->driver_data;

	if (floppy->pc_stack_index == IDEFLOPPY_PC_STACK)
303
		floppy->pc_stack_index = 0;
L
Linus Torvalds 已提交
304 305 306
	return (&floppy->pc_stack[floppy->pc_stack_index++]);
}

307
static struct request *idefloppy_next_rq_storage(ide_drive_t *drive)
L
Linus Torvalds 已提交
308 309 310 311 312 313 314 315
{
	idefloppy_floppy_t *floppy = drive->driver_data;

	if (floppy->rq_stack_index == IDEFLOPPY_PC_STACK)
		floppy->rq_stack_index = 0;
	return (&floppy->rq_stack[floppy->rq_stack_index++]);
}

B
Borislav Petkov 已提交
316
static void ide_floppy_callback(ide_drive_t *drive)
L
Linus Torvalds 已提交
317 318
{
	idefloppy_floppy_t *floppy = drive->driver_data;
B
Borislav Petkov 已提交
319 320
	struct ide_atapi_pc *pc = floppy->pc;
	int uptodate = pc->error ? 0 : 1;
L
Linus Torvalds 已提交
321

322 323
	debug_log("Reached %s\n", __func__);

324 325 326
	if (floppy->failed_pc == pc)
		floppy->failed_pc = NULL;

B
Borislav Petkov 已提交
327 328 329 330 331
	if (pc->c[0] == GPCMD_READ_10 || pc->c[0] == GPCMD_WRITE_10 ||
	    (pc->rq && blk_pc_request(pc->rq)))
		uptodate = 1; /* FIXME */
	else if (pc->c[0] == GPCMD_REQUEST_SENSE) {
		u8 *buf = floppy->pc->buf;
332

B
Borislav Petkov 已提交
333 334 335 336 337 338
		if (!pc->error) {
			floppy->sense_key = buf[2] & 0x0F;
			floppy->asc = buf[12];
			floppy->ascq = buf[13];
			floppy->progress_indication = buf[15] & 0x80 ?
				(u16)get_unaligned((u16 *)&buf[16]) : 0x10000;
339

B
Borislav Petkov 已提交
340 341
			if (floppy->failed_pc)
				debug_log("pc = %x, ", floppy->failed_pc->c[0]);
342

B
Borislav Petkov 已提交
343 344 345 346 347 348
			debug_log("sense key = %x, asc = %x, ascq = %x\n",
				  floppy->sense_key, floppy->asc, floppy->ascq);
		} else
			printk(KERN_ERR "Error in REQUEST SENSE itself - "
					"Aborting request!\n");
	}
L
Linus Torvalds 已提交
349

B
Borislav Petkov 已提交
350
	idefloppy_end_request(drive, uptodate, 0);
L
Linus Torvalds 已提交
351 352
}

353
static void idefloppy_init_pc(struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
354
{
355
	memset(pc, 0, sizeof(*pc));
356 357
	pc->buf = pc->pc_buf;
	pc->buf_size = IDEFLOPPY_PC_BUFFER_SIZE;
L
Linus Torvalds 已提交
358 359
}

360
static void idefloppy_create_request_sense_cmd(struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
361
{
362 363
	idefloppy_init_pc(pc);
	pc->c[0] = GPCMD_REQUEST_SENSE;
L
Linus Torvalds 已提交
364
	pc->c[4] = 255;
365
	pc->req_xfer = 18;
L
Linus Torvalds 已提交
366 367 368
}

/*
369 370
 * 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.
L
Linus Torvalds 已提交
371
 */
372
static void idefloppy_retry_pc(ide_drive_t *drive)
L
Linus Torvalds 已提交
373
{
374
	struct ide_atapi_pc *pc;
L
Linus Torvalds 已提交
375 376
	struct request *rq;

377
	(void)ide_read_error(drive);
L
Linus Torvalds 已提交
378 379 380 381 382 383
	pc = idefloppy_next_pc_storage(drive);
	rq = idefloppy_next_rq_storage(drive);
	idefloppy_create_request_sense_cmd(pc);
	idefloppy_queue_pc_head(drive, pc, rq);
}

384
/* The usual interrupt handler called during a packet command. */
385
static ide_startstop_t idefloppy_pc_intr(ide_drive_t *drive)
L
Linus Torvalds 已提交
386 387 388
{
	idefloppy_floppy_t *floppy = drive->driver_data;

389 390 391
	return ide_pc_intr(drive, floppy->pc, idefloppy_pc_intr,
			   IDEFLOPPY_WAIT_CMD, NULL, idefloppy_update_buffers,
			   idefloppy_retry_pc, NULL, ide_floppy_io_buffers);
L
Linus Torvalds 已提交
392 393 394
}

/*
395 396 397 398
 * What we have here is a classic case of a top half / bottom half interrupt
 * service routine. In interrupt mode, the device sends an interrupt to signal
 * that it is ready to receive a packet. However, we need to delay about 2-3
 * ticks before issuing the packet or we gets in trouble.
L
Linus Torvalds 已提交
399
 */
400
static int idefloppy_transfer_pc(ide_drive_t *drive)
L
Linus Torvalds 已提交
401 402 403 404
{
	idefloppy_floppy_t *floppy = drive->driver_data;

	/* Send the actual packet */
405
	drive->hwif->tp_ops->output_data(drive, NULL, floppy->pc->c, 12);
406

L
Linus Torvalds 已提交
407 408 409 410
	/* Timeout for the packet command */
	return IDEFLOPPY_WAIT_CMD;
}

411 412 413 414 415 416 417

/*
 * Called as an interrupt (or directly). When the device says it's ready for a
 * packet, we schedule the packet transfer to occur about 2-3 ticks later in
 * transfer_pc.
 */
static ide_startstop_t idefloppy_start_pc_transfer(ide_drive_t *drive)
L
Linus Torvalds 已提交
418 419
{
	idefloppy_floppy_t *floppy = drive->driver_data;
420
	struct ide_atapi_pc *pc = floppy->pc;
421 422
	ide_expiry_t *expiry;
	unsigned int timeout;
L
Linus Torvalds 已提交
423

424
	/*
L
Linus Torvalds 已提交
425 426 427 428 429 430 431
	 * The following delay solves a problem with ATAPI Zip 100 drives
	 * where the Busy flag was apparently being deasserted before the
	 * unit was ready to receive data. This was happening on a
	 * 1200 MHz Athlon system. 10/26/01 25msec is too short,
	 * 40 and 50msec work well. idefloppy_pc_intr will not be actually
	 * used until after the packet is moved in about 50 msec.
	 */
432
	if (pc->flags & PC_FLAG_ZIP_DRIVE) {
433
		timeout = floppy->ticks;
434
		expiry = &idefloppy_transfer_pc;
435 436 437 438 439
	} else {
		timeout = IDEFLOPPY_WAIT_CMD;
		expiry = NULL;
	}

440
	return ide_transfer_pc(drive, pc, idefloppy_pc_intr, timeout, expiry);
L
Linus Torvalds 已提交
441 442
}

443
static void ide_floppy_report_error(idefloppy_floppy_t *floppy,
444
				    struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
445
{
446
	/* supress error messages resulting from Medium not present */
L
Linus Torvalds 已提交
447 448 449
	if (floppy->sense_key == 0x02 &&
	    floppy->asc       == 0x3a &&
	    floppy->ascq      == 0x00)
450 451 452 453 454 455 456
		return;

	printk(KERN_ERR "ide-floppy: %s: I/O error, pc = %2x, key = %2x, "
			"asc = %2x, ascq = %2x\n",
			floppy->drive->name, pc->c[0], floppy->sense_key,
			floppy->asc, floppy->ascq);

L
Linus Torvalds 已提交
457 458
}

459
static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
460
		struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
461 462 463 464
{
	idefloppy_floppy_t *floppy = drive->driver_data;

	if (floppy->failed_pc == NULL &&
465
	    pc->c[0] != GPCMD_REQUEST_SENSE)
L
Linus Torvalds 已提交
466 467 468 469
		floppy->failed_pc = pc;
	/* Set the current packet command */
	floppy->pc = pc;

470
	if (pc->retries > IDEFLOPPY_MAX_PC_RETRIES) {
471
		if (!(pc->flags & PC_FLAG_SUPPRESS_ERROR))
472 473 474 475
			ide_floppy_report_error(floppy, pc);
		/* Giving up */
		pc->error = IDEFLOPPY_ERROR_GENERAL;

L
Linus Torvalds 已提交
476
		floppy->failed_pc = NULL;
477
		drive->pc_callback(drive);
L
Linus Torvalds 已提交
478 479 480
		return ide_stopped;
	}

481
	debug_log("Retry number - %d\n", pc->retries);
L
Linus Torvalds 已提交
482 483 484

	pc->retries++;

485
	return ide_issue_pc(drive, pc, idefloppy_start_pc_transfer,
486
			    IDEFLOPPY_WAIT_CMD, NULL);
L
Linus Torvalds 已提交
487 488
}

489
static void idefloppy_create_prevent_cmd(struct ide_atapi_pc *pc, int prevent)
L
Linus Torvalds 已提交
490
{
491
	debug_log("creating prevent removal command, prevent = %d\n", prevent);
L
Linus Torvalds 已提交
492 493

	idefloppy_init_pc(pc);
494
	pc->c[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
L
Linus Torvalds 已提交
495 496 497
	pc->c[4] = prevent;
}

498
static void idefloppy_create_read_capacity_cmd(struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
499 500
{
	idefloppy_init_pc(pc);
501
	pc->c[0] = GPCMD_READ_FORMAT_CAPACITIES;
L
Linus Torvalds 已提交
502 503
	pc->c[7] = 255;
	pc->c[8] = 255;
504
	pc->req_xfer = 255;
L
Linus Torvalds 已提交
505 506
}

507 508
static void idefloppy_create_format_unit_cmd(struct ide_atapi_pc *pc, int b,
		int l, int flags)
L
Linus Torvalds 已提交
509 510
{
	idefloppy_init_pc(pc);
511
	pc->c[0] = GPCMD_FORMAT_UNIT;
L
Linus Torvalds 已提交
512 513
	pc->c[1] = 0x17;

514 515
	memset(pc->buf, 0, 12);
	pc->buf[1] = 0xA2;
L
Linus Torvalds 已提交
516 517 518
	/* Default format list header, u8 1: FOV/DCRT/IMM bits set */

	if (flags & 1)				/* Verify bit on... */
519 520
		pc->buf[1] ^= 0x20;		/* ... turn off DCRT bit */
	pc->buf[3] = 8;
L
Linus Torvalds 已提交
521

522 523 524
	put_unaligned(cpu_to_be32(b), (unsigned int *)(&pc->buf[4]));
	put_unaligned(cpu_to_be32(l), (unsigned int *)(&pc->buf[8]));
	pc->buf_size = 12;
525
	pc->flags |= PC_FLAG_WRITING;
L
Linus Torvalds 已提交
526 527
}

528
/* A mode sense command is used to "sense" floppy parameters. */
529 530
static void idefloppy_create_mode_sense_cmd(struct ide_atapi_pc *pc,
		u8 page_code, u8 type)
L
Linus Torvalds 已提交
531
{
532
	u16 length = 8; /* sizeof(Mode Parameter Header) = 8 Bytes */
533

L
Linus Torvalds 已提交
534
	idefloppy_init_pc(pc);
535
	pc->c[0] = GPCMD_MODE_SENSE_10;
L
Linus Torvalds 已提交
536 537 538 539
	pc->c[1] = 0;
	pc->c[2] = page_code + (type << 6);

	switch (page_code) {
540 541 542 543 544 545 546 547
	case IDEFLOPPY_CAPABILITIES_PAGE:
		length += 12;
		break;
	case IDEFLOPPY_FLEXIBLE_DISK_PAGE:
		length += 32;
		break;
	default:
		printk(KERN_ERR "ide-floppy: unsupported page code "
L
Linus Torvalds 已提交
548 549
				"in create_mode_sense_cmd\n");
	}
550
	put_unaligned(cpu_to_be16(length), (u16 *) &pc->c[7]);
551
	pc->req_xfer = length;
L
Linus Torvalds 已提交
552 553
}

554
static void idefloppy_create_start_stop_cmd(struct ide_atapi_pc *pc, int start)
L
Linus Torvalds 已提交
555 556
{
	idefloppy_init_pc(pc);
557
	pc->c[0] = GPCMD_START_STOP_UNIT;
L
Linus Torvalds 已提交
558 559 560
	pc->c[4] = start;
}

561
static void idefloppy_create_rw_cmd(idefloppy_floppy_t *floppy,
562
				    struct ide_atapi_pc *pc, struct request *rq,
563
				    unsigned long sector)
L
Linus Torvalds 已提交
564 565 566 567 568
{
	int block = sector / floppy->bs_factor;
	int blocks = rq->nr_sectors / floppy->bs_factor;
	int cmd = rq_data_dir(rq);

569
	debug_log("create_rw10_cmd: block == %d, blocks == %d\n",
L
Linus Torvalds 已提交
570 571 572
		block, blocks);

	idefloppy_init_pc(pc);
573 574
	pc->c[0] = cmd == READ ? GPCMD_READ_10 : GPCMD_WRITE_10;
	put_unaligned(cpu_to_be16(blocks), (unsigned short *)&pc->c[7]);
575
	put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[2]);
576

577 578
	memcpy(rq->cmd, pc->c, 12);

L
Linus Torvalds 已提交
579 580
	pc->rq = rq;
	pc->b_count = cmd == READ ? 0 : rq->bio->bi_size;
581
	if (rq->cmd_flags & REQ_RW)
582
		pc->flags |= PC_FLAG_WRITING;
583 584
	pc->buf = NULL;
	pc->req_xfer = pc->buf_size = blocks * floppy->block_size;
585
	pc->flags |= PC_FLAG_DMA_OK;
L
Linus Torvalds 已提交
586 587
}

588
static void idefloppy_blockpc_cmd(idefloppy_floppy_t *floppy,
589
		struct ide_atapi_pc *pc, struct request *rq)
L
Linus Torvalds 已提交
590 591 592
{
	idefloppy_init_pc(pc);
	memcpy(pc->c, rq->cmd, sizeof(pc->c));
593 594 595
	pc->rq = rq;
	pc->b_count = rq->data_len;
	if (rq->data_len && rq_data_dir(rq) == WRITE)
596
		pc->flags |= PC_FLAG_WRITING;
597
	pc->buf = rq->data;
598
	if (rq->bio)
599
		pc->flags |= PC_FLAG_DMA_OK;
600 601 602 603
	/*
	 * possibly problematic, doesn't look like ide-floppy correctly
	 * handled scattered requests if dma fails...
	 */
604
	pc->req_xfer = pc->buf_size = rq->data_len;
L
Linus Torvalds 已提交
605 606
}

607 608
static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
		struct request *rq, sector_t block_s)
L
Linus Torvalds 已提交
609 610
{
	idefloppy_floppy_t *floppy = drive->driver_data;
611
	struct ide_atapi_pc *pc;
L
Linus Torvalds 已提交
612 613
	unsigned long block = (unsigned long)block_s;

614
	debug_log("dev: %s, cmd_type: %x, errors: %d\n",
615
			rq->rq_disk ? rq->rq_disk->disk_name : "?",
616 617
			rq->cmd_type, rq->errors);
	debug_log("sector: %ld, nr_sectors: %ld, "
L
Linus Torvalds 已提交
618 619 620 621
			"current_nr_sectors: %d\n", (long)rq->sector,
			rq->nr_sectors, rq->current_nr_sectors);

	if (rq->errors >= ERROR_MAX) {
622 623
		if (floppy->failed_pc)
			ide_floppy_report_error(floppy, floppy->failed_pc);
L
Linus Torvalds 已提交
624 625 626
		else
			printk(KERN_ERR "ide-floppy: %s: I/O error\n",
				drive->name);
627
		idefloppy_end_request(drive, 0, 0);
L
Linus Torvalds 已提交
628 629
		return ide_stopped;
	}
630
	if (blk_fs_request(rq)) {
L
Linus Torvalds 已提交
631 632
		if (((long)rq->sector % floppy->bs_factor) ||
		    (rq->nr_sectors % floppy->bs_factor)) {
633 634
			printk(KERN_ERR "%s: unsupported r/w request size\n",
					drive->name);
635
			idefloppy_end_request(drive, 0, 0);
L
Linus Torvalds 已提交
636 637 638 639
			return ide_stopped;
		}
		pc = idefloppy_next_pc_storage(drive);
		idefloppy_create_rw_cmd(floppy, pc, rq, block);
640
	} else if (blk_special_request(rq)) {
641
		pc = (struct ide_atapi_pc *) rq->buffer;
642
	} else if (blk_pc_request(rq)) {
L
Linus Torvalds 已提交
643
		pc = idefloppy_next_pc_storage(drive);
644
		idefloppy_blockpc_cmd(floppy, pc, rq);
L
Linus Torvalds 已提交
645 646 647
	} else {
		blk_dump_rq_flags(rq,
			"ide-floppy: unsupported command in queue");
648
		idefloppy_end_request(drive, 0, 0);
L
Linus Torvalds 已提交
649 650 651
		return ide_stopped;
	}

652 653 654
	if (floppy->flags & IDEFLOPPY_FLAG_DRQ_INTERRUPT)
		pc->flags |= PC_FLAG_DRQ_INTERRUPT;

655 656 657
	if (floppy->flags & IDEFLOPPY_FLAG_ZIP_DRIVE)
		pc->flags |= PC_FLAG_ZIP_DRIVE;

L
Linus Torvalds 已提交
658
	pc->rq = rq;
659

L
Linus Torvalds 已提交
660 661 662 663
	return idefloppy_issue_pc(drive, pc);
}

/*
664 665
 * Add a special packet command request to the tail of the request queue,
 * and wait for it to be serviced.
L
Linus Torvalds 已提交
666
 */
667
static int idefloppy_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc)
L
Linus Torvalds 已提交
668 669
{
	struct ide_floppy_obj *floppy = drive->driver_data;
670 671
	struct request *rq;
	int error;
L
Linus Torvalds 已提交
672

673 674 675
	rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
	rq->buffer = (char *) pc;
	rq->cmd_type = REQ_TYPE_SPECIAL;
676
	memcpy(rq->cmd, pc->c, 12);
677 678
	error = blk_execute_rq(drive->queue, floppy->disk, rq, 0);
	blk_put_request(rq);
L
Linus Torvalds 已提交
679

680
	return error;
L
Linus Torvalds 已提交
681 682 683
}

/*
684 685
 * Look at the flexible disk page parameters. We ignore the CHS capacity
 * parameters and use the LBA parameters instead.
L
Linus Torvalds 已提交
686
 */
687
static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
L
Linus Torvalds 已提交
688 689
{
	idefloppy_floppy_t *floppy = drive->driver_data;
690
	struct ide_atapi_pc pc;
691
	u8 *page;
L
Linus Torvalds 已提交
692
	int capacity, lba_capacity;
693 694
	u16 transfer_rate, sector_size, cyls, rpm;
	u8 heads, sectors;
L
Linus Torvalds 已提交
695

696 697 698 699 700 701
	idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE,
					MODE_SENSE_CURRENT);

	if (idefloppy_queue_pc_tail(drive, &pc)) {
		printk(KERN_ERR "ide-floppy: Can't get flexible disk page"
				" parameters\n");
L
Linus Torvalds 已提交
702 703
		return 1;
	}
704
	floppy->wp = !!(pc.buf[3] & 0x80);
L
Linus Torvalds 已提交
705
	set_disk_ro(floppy->disk, floppy->wp);
706
	page = &pc.buf[8];
707

708 709 710 711
	transfer_rate = be16_to_cpup((__be16 *)&pc.buf[8 + 2]);
	sector_size   = be16_to_cpup((__be16 *)&pc.buf[8 + 6]);
	cyls          = be16_to_cpup((__be16 *)&pc.buf[8 + 8]);
	rpm           = be16_to_cpup((__be16 *)&pc.buf[8 + 28]);
712 713
	heads         = pc.buf[8 + 4];
	sectors       = pc.buf[8 + 5];
714 715 716 717

	capacity = cyls * heads * sectors * sector_size;

	if (memcmp(page, &floppy->flexible_disk_page, 32))
L
Linus Torvalds 已提交
718 719
		printk(KERN_INFO "%s: %dkB, %d/%d/%d CHS, %d kBps, "
				"%d sector size, %d rpm\n",
720 721 722 723 724 725 726
				drive->name, capacity / 1024, cyls, heads,
				sectors, transfer_rate / 8, sector_size, rpm);

	memcpy(&floppy->flexible_disk_page, page, 32);
	drive->bios_cyl = cyls;
	drive->bios_head = heads;
	drive->bios_sect = sectors;
L
Linus Torvalds 已提交
727
	lba_capacity = floppy->blocks * floppy->block_size;
728

L
Linus Torvalds 已提交
729 730 731 732
	if (capacity < lba_capacity) {
		printk(KERN_NOTICE "%s: The disk reports a capacity of %d "
			"bytes, but the drive only handles %d\n",
			drive->name, lba_capacity, capacity);
733 734
		floppy->blocks = floppy->block_size ?
			capacity / floppy->block_size : 0;
L
Linus Torvalds 已提交
735 736 737 738
	}
	return 0;
}

739
static int idefloppy_get_sfrp_bit(ide_drive_t *drive)
L
Linus Torvalds 已提交
740 741
{
	idefloppy_floppy_t *floppy = drive->driver_data;
742
	struct ide_atapi_pc pc;
L
Linus Torvalds 已提交
743 744 745 746 747

	floppy->srfp = 0;
	idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_CAPABILITIES_PAGE,
						 MODE_SENSE_CURRENT);

748
	pc.flags |= PC_FLAG_SUPPRESS_ERROR;
749
	if (idefloppy_queue_pc_tail(drive, &pc))
L
Linus Torvalds 已提交
750 751
		return 1;

752
	floppy->srfp = pc.buf[8 + 2] & 0x40;
L
Linus Torvalds 已提交
753 754 755 756
	return (0);
}

/*
757 758
 * Determine if a media is present in the floppy drive, and if so, its LBA
 * capacity.
L
Linus Torvalds 已提交
759
 */
760
static int ide_floppy_get_capacity(ide_drive_t *drive)
L
Linus Torvalds 已提交
761 762
{
	idefloppy_floppy_t *floppy = drive->driver_data;
763
	struct ide_atapi_pc pc;
764 765 766 767
	u8 *cap_desc;
	u8 header_len, desc_cnt;
	int i, rc = 1, blocks, length;

L
Linus Torvalds 已提交
768 769
	drive->bios_cyl = 0;
	drive->bios_head = drive->bios_sect = 0;
770 771
	floppy->blocks = 0;
	floppy->bs_factor = 1;
L
Linus Torvalds 已提交
772 773 774 775 776 777 778
	set_capacity(floppy->disk, 0);

	idefloppy_create_read_capacity_cmd(&pc);
	if (idefloppy_queue_pc_tail(drive, &pc)) {
		printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");
		return 1;
	}
779 780
	header_len = pc.buf[3];
	cap_desc = &pc.buf[4];
781 782 783 784 785
	desc_cnt = header_len / 8; /* capacity descriptor of 8 bytes */

	for (i = 0; i < desc_cnt; i++) {
		unsigned int desc_start = 4 + i*8;

786 787
		blocks = be32_to_cpup((__be32 *)&pc.buf[desc_start]);
		length = be16_to_cpup((__be16 *)&pc.buf[desc_start + 6]);
788 789 790

		debug_log("Descriptor %d: %dkB, %d blocks, %d sector size\n",
				i, blocks * length / 1024, blocks, length);
L
Linus Torvalds 已提交
791

792 793 794 795 796
		if (i)
			continue;
		/*
		 * the code below is valid only for the 1st descriptor, ie i=0
		 */
L
Linus Torvalds 已提交
797

798
		switch (pc.buf[desc_start + 4] & 0x03) {
L
Linus Torvalds 已提交
799 800
		/* Clik! drive returns this instead of CAPACITY_CURRENT */
		case CAPACITY_UNFORMATTED:
801
			if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE))
802
				/*
L
Linus Torvalds 已提交
803 804 805 806 807 808
				 * If it is not a clik drive, break out
				 * (maintains previous driver behaviour)
				 */
				break;
		case CAPACITY_CURRENT:
			/* Normal Zip/LS-120 disks */
809
			if (memcmp(cap_desc, &floppy->cap_desc, 8))
L
Linus Torvalds 已提交
810 811 812
				printk(KERN_INFO "%s: %dkB, %d blocks, %d "
					"sector size\n", drive->name,
					blocks * length / 1024, blocks, length);
813 814
			memcpy(&floppy->cap_desc, cap_desc, 8);

L
Linus Torvalds 已提交
815 816 817 818
			if (!length || length % 512) {
				printk(KERN_NOTICE "%s: %d bytes block size "
					"not supported\n", drive->name, length);
			} else {
819 820 821 822 823
				floppy->blocks = blocks;
				floppy->block_size = length;
				floppy->bs_factor = length / 512;
				if (floppy->bs_factor != 1)
					printk(KERN_NOTICE "%s: warning: non "
L
Linus Torvalds 已提交
824 825 826
						"512 bytes block size not "
						"fully supported\n",
						drive->name);
827
				rc = 0;
L
Linus Torvalds 已提交
828 829 830 831 832 833 834 835 836 837 838 839 840 841
			}
			break;
		case CAPACITY_NO_CARTRIDGE:
			/*
			 * This is a KERN_ERR so it appears on screen
			 * for the user to see
			 */
			printk(KERN_ERR "%s: No disk in drive\n", drive->name);
			break;
		case CAPACITY_INVALID:
			printk(KERN_ERR "%s: Invalid capacity for disk "
				"in drive\n", drive->name);
			break;
		}
842
		debug_log("Descriptor 0 Code: %d\n",
843
			  pc.buf[desc_start + 4] & 0x03);
L
Linus Torvalds 已提交
844 845 846
	}

	/* Clik! disk does not support get_flexible_disk_page */
847
	if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE))
848
		(void) ide_floppy_get_flexible_disk_page(drive);
L
Linus Torvalds 已提交
849 850 851 852 853 854

	set_capacity(floppy->disk, floppy->blocks * floppy->bs_factor);
	return rc;
}

/*
855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
 * Obtain the list of formattable capacities.
 * Very similar to ide_floppy_get_capacity, except that we push the capacity
 * descriptors to userland, instead of our own structures.
 *
 * Userland gives us the following structure:
 *
 * struct idefloppy_format_capacities {
 *	int nformats;
 *	struct {
 *		int nblocks;
 *		int blocksize;
 *	} formats[];
 * };
 *
 * userland initializes nformats to the number of allocated formats[] records.
 * On exit we set nformats to the number of records we've actually initialized.
 */
L
Linus Torvalds 已提交
872

873
static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)
L
Linus Torvalds 已提交
874
{
875
	struct ide_atapi_pc pc;
876 877
	u8 header_len, desc_cnt;
	int i, blocks, length, u_array_size, u_index;
L
Linus Torvalds 已提交
878 879 880 881 882 883 884 885 886 887 888
	int __user *argp;

	if (get_user(u_array_size, arg))
		return (-EFAULT);

	if (u_array_size <= 0)
		return (-EINVAL);

	idefloppy_create_read_capacity_cmd(&pc);
	if (idefloppy_queue_pc_tail(drive, &pc)) {
		printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");
889 890
		return (-EIO);
	}
891
	header_len = pc.buf[3];
892
	desc_cnt = header_len / 8; /* capacity descriptor of 8 bytes */
L
Linus Torvalds 已提交
893 894 895 896 897

	u_index = 0;
	argp = arg + 1;

	/*
898 899 900 901 902 903
	 * We always skip the first capacity descriptor.  That's the current
	 * capacity.  We are interested in the remaining descriptors, the
	 * formattable capacities.
	 */
	for (i = 1; i < desc_cnt; i++) {
		unsigned int desc_start = 4 + i*8;
L
Linus Torvalds 已提交
904 905 906 907

		if (u_index >= u_array_size)
			break;	/* User-supplied buffer too small */

908 909
		blocks = be32_to_cpup((__be32 *)&pc.buf[desc_start]);
		length = be16_to_cpup((__be16 *)&pc.buf[desc_start + 6]);
L
Linus Torvalds 已提交
910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927

		if (put_user(blocks, argp))
			return(-EFAULT);
		++argp;

		if (put_user(length, argp))
			return (-EFAULT);
		++argp;

		++u_index;
	}

	if (put_user(u_index, arg))
		return (-EFAULT);
	return (0);
}

/*
928 929 930 931 932 933 934 935
 * Get ATAPI_FORMAT_UNIT progress indication.
 *
 * Userland gives a pointer to an int.  The int is set to a progress
 * indicator 0-65536, with 65536=100%.
 *
 * If the drive does not support format progress indication, we just check
 * the dsc bit, and return either 0 or 65536.
 */
L
Linus Torvalds 已提交
936 937 938 939

static int idefloppy_get_format_progress(ide_drive_t *drive, int __user *arg)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
940
	struct ide_atapi_pc pc;
L
Linus Torvalds 已提交
941 942 943 944
	int progress_indication = 0x10000;

	if (floppy->srfp) {
		idefloppy_create_request_sense_cmd(&pc);
945
		if (idefloppy_queue_pc_tail(drive, &pc))
L
Linus Torvalds 已提交
946 947 948 949
			return (-EIO);

		if (floppy->sense_key == 2 &&
		    floppy->asc == 4 &&
950
		    floppy->ascq == 4)
L
Linus Torvalds 已提交
951
			progress_indication = floppy->progress_indication;
952 953

		/* Else assume format_unit has finished, and we're at 0x10000 */
L
Linus Torvalds 已提交
954
	} else {
955
		ide_hwif_t *hwif = drive->hwif;
L
Linus Torvalds 已提交
956
		unsigned long flags;
957
		u8 stat;
L
Linus Torvalds 已提交
958 959

		local_irq_save(flags);
960
		stat = hwif->tp_ops->read_status(hwif);
L
Linus Torvalds 已提交
961 962
		local_irq_restore(flags);

963
		progress_indication = ((stat & SEEK_STAT) == 0) ? 0 : 0x10000;
L
Linus Torvalds 已提交
964 965 966 967 968 969 970
	}
	if (put_user(progress_indication, arg))
		return (-EFAULT);

	return (0);
}

971
static sector_t idefloppy_capacity(ide_drive_t *drive)
L
Linus Torvalds 已提交
972 973 974 975 976 977 978 979
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	unsigned long capacity = floppy->blocks * floppy->bs_factor;

	return capacity;
}

/*
980 981
 * Check whether we can support a drive, based on the ATAPI IDENTIFY command
 * results.
L
Linus Torvalds 已提交
982
 */
983
static int idefloppy_identify_device(ide_drive_t *drive, struct hd_driveid *id)
L
Linus Torvalds 已提交
984
{
985 986
	u8 gcw[2];
	u8 device_type, protocol, removable, drq_type, packet_size;
L
Linus Torvalds 已提交
987 988 989

	*((u16 *) &gcw) = id->config;

990 991 992 993 994 995
	device_type =  gcw[1] & 0x1F;
	removable   = (gcw[0] & 0x80) >> 7;
	protocol    = (gcw[1] & 0xC0) >> 6;
	drq_type    = (gcw[0] & 0x60) >> 5;
	packet_size =  gcw[0] & 0x03;

L
Linus Torvalds 已提交
996 997
#ifdef CONFIG_PPC
	/* kludge for Apple PowerBook internal zip */
998 999 1000
	if (device_type == 5 &&
	    !strstr(id->model, "CD-ROM") && strstr(id->model, "ZIP"))
		device_type = 0;
L
Linus Torvalds 已提交
1001 1002
#endif

1003
	if (protocol != 2)
1004
		printk(KERN_ERR "ide-floppy: Protocol (0x%02x) is not ATAPI\n",
1005 1006
			protocol);
	else if (device_type != 0)
1007
		printk(KERN_ERR "ide-floppy: Device type (0x%02x) is not set "
1008 1009
				"to floppy\n", device_type);
	else if (!removable)
L
Linus Torvalds 已提交
1010
		printk(KERN_ERR "ide-floppy: The removable flag is not set\n");
1011
	else if (drq_type == 3)
1012
		printk(KERN_ERR "ide-floppy: Sorry, DRQ type (0x%02x) not "
1013 1014
				"supported\n", drq_type);
	else if (packet_size != 0)
1015
		printk(KERN_ERR "ide-floppy: Packet size (0x%02x) is not 12 "
1016 1017
				"bytes\n", packet_size);
	else
L
Linus Torvalds 已提交
1018 1019 1020 1021
		return 1;
	return 0;
}

1022
#ifdef CONFIG_IDE_PROC_FS
L
Linus Torvalds 已提交
1023 1024 1025 1026
static void idefloppy_add_settings(ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;

1027 1028 1029 1030 1031 1032 1033 1034
	ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 1023, 1, 1,
			&drive->bios_cyl, NULL);
	ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1,
			&drive->bios_head, NULL);
	ide_add_setting(drive, "bios_sect", SETTING_RW,	TYPE_BYTE, 0,  63, 1, 1,
			&drive->bios_sect, NULL);
	ide_add_setting(drive, "ticks",	   SETTING_RW, TYPE_BYTE, 0, 255, 1, 1,
			&floppy->ticks,	 NULL);
L
Linus Torvalds 已提交
1035
}
1036 1037 1038
#else
static inline void idefloppy_add_settings(ide_drive_t *drive) { ; }
#endif
L
Linus Torvalds 已提交
1039

1040
static void idefloppy_setup(ide_drive_t *drive, idefloppy_floppy_t *floppy)
L
Linus Torvalds 已提交
1041
{
1042
	u8 gcw[2];
L
Linus Torvalds 已提交
1043 1044 1045

	*((u16 *) &gcw) = drive->id->config;
	floppy->pc = floppy->pc_stack;
1046
	drive->pc_callback = ide_floppy_callback;
1047 1048

	if (((gcw[0] & 0x60) >> 5) == 1)
1049
		floppy->flags |= IDEFLOPPY_FLAG_DRQ_INTERRUPT;
L
Linus Torvalds 已提交
1050
	/*
1051 1052
	 * We used to check revisions here. At this point however I'm giving up.
	 * Just assume they are all broken, its easier.
L
Linus Torvalds 已提交
1053
	 *
1054 1055 1056 1057
	 * The actual reason for the workarounds was likely a driver bug after
	 * all rather than a firmware bug, and the workaround below used to hide
	 * it. It should be fixed as of version 1.9, but to be on the safe side
	 * we'll leave the limitation below for the 2.2.x tree.
L
Linus Torvalds 已提交
1058 1059
	 */
	if (!strncmp(drive->id->model, "IOMEGA ZIP 100 ATAPI", 20)) {
1060
		floppy->flags |= IDEFLOPPY_FLAG_ZIP_DRIVE;
L
Linus Torvalds 已提交
1061 1062 1063 1064 1065 1066
		/* This value will be visible in the /proc/ide/hdx/settings */
		floppy->ticks = IDEFLOPPY_TICKS_DELAY;
		blk_queue_max_sectors(drive->queue, 64);
	}

	/*
1067 1068 1069
	 * Guess what? The IOMEGA Clik! drive also needs the above fix. It makes
	 * nasty clicking noises without it, so please don't remove this.
	 */
L
Linus Torvalds 已提交
1070 1071
	if (strncmp(drive->id->model, "IOMEGA Clik!", 11) == 0) {
		blk_queue_max_sectors(drive->queue, 64);
1072
		floppy->flags |= IDEFLOPPY_FLAG_CLIK_DRIVE;
L
Linus Torvalds 已提交
1073 1074
	}

1075
	(void) ide_floppy_get_capacity(drive);
L
Linus Torvalds 已提交
1076 1077 1078
	idefloppy_add_settings(drive);
}

1079
static void ide_floppy_remove(ide_drive_t *drive)
L
Linus Torvalds 已提交
1080 1081 1082 1083
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	struct gendisk *g = floppy->disk;

1084
	ide_proc_unregister_driver(drive, floppy->driver);
L
Linus Torvalds 已提交
1085 1086 1087 1088 1089 1090

	del_gendisk(g);

	ide_floppy_put(floppy);
}

1091
static void idefloppy_cleanup_obj(struct kref *kref)
L
Linus Torvalds 已提交
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
{
	struct ide_floppy_obj *floppy = to_ide_floppy(kref);
	ide_drive_t *drive = floppy->drive;
	struct gendisk *g = floppy->disk;

	drive->driver_data = NULL;
	g->private_data = NULL;
	put_disk(g);
	kfree(floppy);
}

1103
#ifdef CONFIG_IDE_PROC_FS
1104 1105
static int proc_idefloppy_read_capacity(char *page, char **start, off_t off,
		int count, int *eof, void *data)
L
Linus Torvalds 已提交
1106 1107 1108 1109
{
	ide_drive_t*drive = (ide_drive_t *)data;
	int len;

1110 1111
	len = sprintf(page, "%llu\n", (long long)idefloppy_capacity(drive));
	PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
L
Linus Torvalds 已提交
1112 1113 1114
}

static ide_proc_entry_t idefloppy_proc[] = {
1115 1116
	{ "capacity",	S_IFREG|S_IRUGO, proc_idefloppy_read_capacity,	NULL },
	{ "geometry",	S_IFREG|S_IRUGO, proc_ide_read_geometry,	NULL },
L
Linus Torvalds 已提交
1117 1118
	{ NULL, 0, NULL, NULL }
};
1119
#endif	/* CONFIG_IDE_PROC_FS */
L
Linus Torvalds 已提交
1120

1121
static int ide_floppy_probe(ide_drive_t *);
L
Linus Torvalds 已提交
1122 1123

static ide_driver_t idefloppy_driver = {
1124
	.gen_driver = {
1125
		.owner		= THIS_MODULE,
1126 1127 1128
		.name		= "ide-floppy",
		.bus		= &ide_bus_type,
	},
1129 1130
	.probe			= ide_floppy_probe,
	.remove			= ide_floppy_remove,
L
Linus Torvalds 已提交
1131 1132 1133 1134
	.version		= IDEFLOPPY_VERSION,
	.media			= ide_floppy,
	.supports_dsc_overlap	= 0,
	.do_request		= idefloppy_do_request,
1135
	.end_request		= idefloppy_end_request,
L
Linus Torvalds 已提交
1136
	.error			= __ide_error,
1137
#ifdef CONFIG_IDE_PROC_FS
L
Linus Torvalds 已提交
1138
	.proc			= idefloppy_proc,
1139
#endif
L
Linus Torvalds 已提交
1140 1141 1142 1143 1144 1145 1146
};

static int idefloppy_open(struct inode *inode, struct file *filp)
{
	struct gendisk *disk = inode->i_bdev->bd_disk;
	struct ide_floppy_obj *floppy;
	ide_drive_t *drive;
1147
	struct ide_atapi_pc pc;
L
Linus Torvalds 已提交
1148 1149
	int ret = 0;

1150
	debug_log("Reached %s\n", __func__);
L
Linus Torvalds 已提交
1151

1152 1153
	floppy = ide_floppy_get(disk);
	if (!floppy)
L
Linus Torvalds 已提交
1154 1155 1156 1157
		return -ENXIO;

	drive = floppy->drive;

1158
	floppy->openers++;
L
Linus Torvalds 已提交
1159

1160
	if (floppy->openers == 1) {
1161
		floppy->flags &= ~IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS;
L
Linus Torvalds 已提交
1162 1163
		/* Just in case */

1164 1165 1166
		idefloppy_init_pc(&pc);
		pc.c[0] = GPCMD_TEST_UNIT_READY;

L
Linus Torvalds 已提交
1167 1168 1169 1170 1171
		if (idefloppy_queue_pc_tail(drive, &pc)) {
			idefloppy_create_start_stop_cmd(&pc, 1);
			(void) idefloppy_queue_pc_tail(drive, &pc);
		}

1172
		if (ide_floppy_get_capacity(drive)
L
Linus Torvalds 已提交
1173 1174
		   && (filp->f_flags & O_NDELAY) == 0
		    /*
1175 1176 1177 1178
		     * Allow O_NDELAY to open a drive without a disk, or with an
		     * unreadable disk, so that we can get the format capacity
		     * of the drive or begin the format - Sam
		     */
L
Linus Torvalds 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187
		    ) {
			ret = -EIO;
			goto out_put_floppy;
		}

		if (floppy->wp && (filp->f_mode & 2)) {
			ret = -EROFS;
			goto out_put_floppy;
		}
1188
		floppy->flags |= IDEFLOPPY_FLAG_MEDIA_CHANGED;
L
Linus Torvalds 已提交
1189
		/* IOMEGA Clik! drives do not support lock/unlock commands */
1190
		if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE)) {
L
Linus Torvalds 已提交
1191 1192 1193 1194
			idefloppy_create_prevent_cmd(&pc, 1);
			(void) idefloppy_queue_pc_tail(drive, &pc);
		}
		check_disk_change(inode->i_bdev);
1195
	} else if (floppy->flags & IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS) {
L
Linus Torvalds 已提交
1196 1197 1198 1199 1200 1201
		ret = -EBUSY;
		goto out_put_floppy;
	}
	return 0;

out_put_floppy:
1202
	floppy->openers--;
L
Linus Torvalds 已提交
1203 1204 1205 1206 1207 1208 1209 1210 1211
	ide_floppy_put(floppy);
	return ret;
}

static int idefloppy_release(struct inode *inode, struct file *filp)
{
	struct gendisk *disk = inode->i_bdev->bd_disk;
	struct ide_floppy_obj *floppy = ide_floppy_g(disk);
	ide_drive_t *drive = floppy->drive;
1212
	struct ide_atapi_pc pc;
1213 1214

	debug_log("Reached %s\n", __func__);
L
Linus Torvalds 已提交
1215

1216
	if (floppy->openers == 1) {
L
Linus Torvalds 已提交
1217
		/* IOMEGA Clik! drives do not support lock/unlock commands */
1218
		if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE)) {
L
Linus Torvalds 已提交
1219 1220 1221 1222
			idefloppy_create_prevent_cmd(&pc, 0);
			(void) idefloppy_queue_pc_tail(drive, &pc);
		}

1223
		floppy->flags &= ~IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS;
L
Linus Torvalds 已提交
1224
	}
1225 1226

	floppy->openers--;
L
Linus Torvalds 已提交
1227 1228 1229 1230 1231 1232

	ide_floppy_put(floppy);

	return 0;
}

1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
static int idefloppy_getgeo(struct block_device *bdev, struct hd_geometry *geo)
{
	struct ide_floppy_obj *floppy = ide_floppy_g(bdev->bd_disk);
	ide_drive_t *drive = floppy->drive;

	geo->heads = drive->bios_head;
	geo->sectors = drive->bios_sect;
	geo->cylinders = (u16)drive->bios_cyl; /* truncate */
	return 0;
}

1244 1245
static int ide_floppy_lockdoor(idefloppy_floppy_t *floppy,
		struct ide_atapi_pc *pc, unsigned long arg, unsigned int cmd)
1246 1247 1248 1249 1250 1251
{
	if (floppy->openers > 1)
		return -EBUSY;

	/* The IOMEGA Clik! Drive doesn't support this command -
	 * no room for an eject mechanism */
1252
	if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE)) {
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
		int prevent = arg ? 1 : 0;

		if (cmd == CDROMEJECT)
			prevent = 0;

		idefloppy_create_prevent_cmd(pc, prevent);
		(void) idefloppy_queue_pc_tail(floppy->drive, pc);
	}

	if (cmd == CDROMEJECT) {
		idefloppy_create_start_stop_cmd(pc, 2);
		(void) idefloppy_queue_pc_tail(floppy->drive, pc);
	}

	return 0;
}

static int ide_floppy_format_unit(idefloppy_floppy_t *floppy,
				  int __user *arg)
{
	int blocks, length, flags, err = 0;
1274
	struct ide_atapi_pc pc;
1275 1276 1277

	if (floppy->openers > 1) {
		/* Don't format if someone is using the disk */
1278
		floppy->flags &= ~IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS;
1279 1280 1281
		return -EBUSY;
	}

1282
	floppy->flags |= IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS;
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313

	/*
	 * Send ATAPI_FORMAT_UNIT to the drive.
	 *
	 * Userland gives us the following structure:
	 *
	 * struct idefloppy_format_command {
	 *        int nblocks;
	 *        int blocksize;
	 *        int flags;
	 *        } ;
	 *
	 * flags is a bitmask, currently, the only defined flag is:
	 *
	 *        0x01 - verify media after format.
	 */
	if (get_user(blocks, arg) ||
			get_user(length, arg+1) ||
			get_user(flags, arg+2)) {
		err = -EFAULT;
		goto out;
	}

	(void) idefloppy_get_sfrp_bit(floppy->drive);
	idefloppy_create_format_unit_cmd(&pc, blocks, length, flags);

	if (idefloppy_queue_pc_tail(floppy->drive, &pc))
		err = -EIO;

out:
	if (err)
1314
		floppy->flags &= ~IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS;
1315 1316 1317 1318
	return err;
}


L
Linus Torvalds 已提交
1319 1320 1321 1322 1323 1324
static int idefloppy_ioctl(struct inode *inode, struct file *file,
			unsigned int cmd, unsigned long arg)
{
	struct block_device *bdev = inode->i_bdev;
	struct ide_floppy_obj *floppy = ide_floppy_g(bdev->bd_disk);
	ide_drive_t *drive = floppy->drive;
1325
	struct ide_atapi_pc pc;
L
Linus Torvalds 已提交
1326
	void __user *argp = (void __user *)arg;
1327
	int err;
L
Linus Torvalds 已提交
1328 1329 1330 1331 1332

	switch (cmd) {
	case CDROMEJECT:
		/* fall through */
	case CDROM_LOCKDOOR:
1333
		return ide_floppy_lockdoor(floppy, &pc, arg, cmd);
L
Linus Torvalds 已提交
1334 1335 1336
	case IDEFLOPPY_IOCTL_FORMAT_SUPPORTED:
		return 0;
	case IDEFLOPPY_IOCTL_FORMAT_GET_CAPACITY:
1337
		return ide_floppy_get_format_capacities(drive, argp);
L
Linus Torvalds 已提交
1338 1339 1340 1341
	case IDEFLOPPY_IOCTL_FORMAT_START:
		if (!(file->f_mode & 2))
			return -EPERM;

1342
		return ide_floppy_format_unit(floppy, (int __user *)arg);
L
Linus Torvalds 已提交
1343 1344 1345
	case IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS:
		return idefloppy_get_format_progress(drive, argp);
	}
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360

	/*
	 * skip SCSI_IOCTL_SEND_COMMAND (deprecated)
	 * and CDROM_SEND_PACKET (legacy) ioctls
	 */
	if (cmd != CDROM_SEND_PACKET && cmd != SCSI_IOCTL_SEND_COMMAND)
		err = scsi_cmd_ioctl(file, bdev->bd_disk->queue,
					bdev->bd_disk, cmd, argp);
	else
		err = -ENOTTY;

	if (err == -ENOTTY)
		err = generic_ide_ioctl(drive, file, bdev, cmd, arg);

	return err;
L
Linus Torvalds 已提交
1361 1362 1363 1364 1365 1366
}

static int idefloppy_media_changed(struct gendisk *disk)
{
	struct ide_floppy_obj *floppy = ide_floppy_g(disk);
	ide_drive_t *drive = floppy->drive;
1367
	int ret;
L
Linus Torvalds 已提交
1368 1369 1370 1371 1372 1373

	/* do not scan partitions twice if this is a removable device */
	if (drive->attach) {
		drive->attach = 0;
		return 0;
	}
1374 1375 1376
	ret = !!(floppy->flags & IDEFLOPPY_FLAG_MEDIA_CHANGED);
	floppy->flags &= ~IDEFLOPPY_FLAG_MEDIA_CHANGED;
	return ret;
L
Linus Torvalds 已提交
1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
}

static int idefloppy_revalidate_disk(struct gendisk *disk)
{
	struct ide_floppy_obj *floppy = ide_floppy_g(disk);
	set_capacity(disk, idefloppy_capacity(floppy->drive));
	return 0;
}

static struct block_device_operations idefloppy_ops = {
1387 1388 1389 1390 1391 1392 1393
	.owner			= THIS_MODULE,
	.open			= idefloppy_open,
	.release		= idefloppy_release,
	.ioctl			= idefloppy_ioctl,
	.getgeo			= idefloppy_getgeo,
	.media_changed		= idefloppy_media_changed,
	.revalidate_disk	= idefloppy_revalidate_disk
L
Linus Torvalds 已提交
1394 1395
};

1396
static int ide_floppy_probe(ide_drive_t *drive)
L
Linus Torvalds 已提交
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
{
	idefloppy_floppy_t *floppy;
	struct gendisk *g;

	if (!strstr("ide-floppy", drive->driver_req))
		goto failed;
	if (!drive->present)
		goto failed;
	if (drive->media != ide_floppy)
		goto failed;
1407 1408 1409
	if (!idefloppy_identify_device(drive, drive->id)) {
		printk(KERN_ERR "ide-floppy: %s: not supported by this version"
				" of ide-floppy\n", drive->name);
L
Linus Torvalds 已提交
1410 1411
		goto failed;
	}
1412 1413 1414 1415
	floppy = kzalloc(sizeof(idefloppy_floppy_t), GFP_KERNEL);
	if (!floppy) {
		printk(KERN_ERR "ide-floppy: %s: Can't allocate a floppy"
				" structure\n", drive->name);
L
Linus Torvalds 已提交
1416 1417 1418 1419 1420 1421 1422 1423 1424
		goto failed;
	}

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

	ide_init_disk(g, drive);

1425
	ide_proc_register_driver(drive, &idefloppy_driver);
L
Linus Torvalds 已提交
1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436

	kref_init(&floppy->kref);

	floppy->drive = drive;
	floppy->driver = &idefloppy_driver;
	floppy->disk = g;

	g->private_data = &floppy->driver;

	drive->driver_data = floppy;

1437
	idefloppy_setup(drive, floppy);
1438

L
Linus Torvalds 已提交
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449
	g->minors = 1 << PARTN_BITS;
	g->driverfs_dev = &drive->gendev;
	g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
	g->fops = &idefloppy_ops;
	drive->attach = 1;
	add_disk(g);
	return 0;

out_free_floppy:
	kfree(floppy);
failed:
1450
	return -ENODEV;
L
Linus Torvalds 已提交
1451 1452
}

1453
static void __exit idefloppy_exit(void)
L
Linus Torvalds 已提交
1454
{
1455
	driver_unregister(&idefloppy_driver.gen_driver);
L
Linus Torvalds 已提交
1456 1457
}

1458
static int __init idefloppy_init(void)
L
Linus Torvalds 已提交
1459 1460
{
	printk("ide-floppy driver " IDEFLOPPY_VERSION "\n");
1461
	return driver_register(&idefloppy_driver.gen_driver);
L
Linus Torvalds 已提交
1462 1463
}

1464
MODULE_ALIAS("ide:*m-floppy*");
L
Linus Torvalds 已提交
1465 1466 1467
module_init(idefloppy_init);
module_exit(idefloppy_exit);
MODULE_LICENSE("GPL");
1468 1469
MODULE_DESCRIPTION("ATAPI FLOPPY Driver");