ide-floppy.c 44.5 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
Borislav Petkov's avatar
Borislav Petkov committed
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
 *
Linus Torvalds's avatar
Linus Torvalds committed
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
 *
Borislav Petkov's avatar
Borislav Petkov committed
14 15
 * For a historical changelog see
 * Documentation/ide/ChangeLog.ide-floppy.1996-2002
Linus Torvalds's avatar
Linus Torvalds committed
16 17
 */

18
#define IDEFLOPPY_VERSION "1.00"
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
36

37 38
#include <scsi/scsi_ioctl.h>

Linus Torvalds's avatar
Linus Torvalds committed
39
#include <asm/byteorder.h>
40 41 42
#include <linux/irq.h>
#include <linux/uaccess.h>
#include <linux/io.h>
Linus Torvalds's avatar
Linus Torvalds committed
43 44
#include <asm/unaligned.h>

45
/* define to see debug info */
Linus Torvalds's avatar
Linus Torvalds committed
46 47 48
#define IDEFLOPPY_DEBUG_LOG		0

/* #define IDEFLOPPY_DEBUG(fmt, args...) printk(KERN_INFO fmt, ## args) */
49
#define IDEFLOPPY_DEBUG(fmt, args...)
Linus Torvalds's avatar
Linus Torvalds committed
50 51

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


59
/* Some drives require a longer irq timeout. */
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
78 79 80
 */
#define IDEFLOPPY_PC_STACK		(10 + IDEFLOPPY_MAX_PC_RETRIES)

81
/* format capacities descriptor codes */
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
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 */
Linus Torvalds's avatar
Linus Torvalds committed
98 99

	/* Current packet command */
100
	struct ide_atapi_pc *pc;
Linus Torvalds's avatar
Linus Torvalds committed
101
	/* Last failed packet command */
102
	struct ide_atapi_pc *failed_pc;
Linus Torvalds's avatar
Linus Torvalds committed
103
	/* Packet command stack */
104
	struct ide_atapi_pc pc_stack[IDEFLOPPY_PC_STACK];
Linus Torvalds's avatar
Linus Torvalds committed
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 */
Linus Torvalds's avatar
Linus Torvalds committed
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 */
Linus Torvalds's avatar
Linus Torvalds committed
118 119
	/* Current format */
	int blocks, block_size, bs_factor;
120 121
	/* Last format capacity descriptor */
	u8 cap_desc[8];
Linus Torvalds's avatar
Linus Torvalds committed
122
	/* Copy of the flexible disk page */
123
	u8 flexible_disk_page[32];
Linus Torvalds's avatar
Linus Torvalds committed
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) */
Linus Torvalds's avatar
Linus Torvalds committed
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),
};
Linus Torvalds's avatar
Linus Torvalds committed
147

148
/* Defines for the MODE SENSE command */
Linus Torvalds's avatar
Linus Torvalds committed
149 150
#define MODE_SENSE_CURRENT		0x00
#define MODE_SENSE_CHANGEABLE		0x01
151
#define MODE_SENSE_DEFAULT		0x02
Linus Torvalds's avatar
Linus Torvalds committed
152 153
#define MODE_SENSE_SAVED		0x03

154
/* IOCTLs used in low-level formatting. */
Linus Torvalds's avatar
Linus Torvalds committed
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. */
Linus Torvalds's avatar
Linus Torvalds committed
161 162 163
#define	IDEFLOPPY_ERROR_GENERAL		101

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

170
static DEFINE_MUTEX(idefloppy_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
182 183 184
	floppy = ide_floppy_g(disk);
	if (floppy)
		kref_get(&floppy->kref);
185
	mutex_unlock(&idefloppy_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
186 187 188
	return floppy;
}

189
static void idefloppy_cleanup_obj(struct kref *);
Linus Torvalds's avatar
Linus Torvalds committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
201
 */
202
static int idefloppy_end_request(ide_drive_t *drive, int uptodate, int nsecs)
Linus Torvalds's avatar
Linus Torvalds committed
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__);
Linus Torvalds's avatar
Linus Torvalds committed
209 210

	switch (uptodate) {
211 212 213
	case 0: error = IDEFLOPPY_ERROR_GENERAL; break;
	case 1: error = 0; break;
	default: error = uptodate;
Linus Torvalds's avatar
Linus Torvalds committed
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)) {
Linus Torvalds's avatar
Linus Torvalds committed
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)
Linus Torvalds's avatar
Linus Torvalds committed
233
{
234
	ide_hwif_t *hwif = drive->hwif;
Linus Torvalds's avatar
Linus Torvalds committed
235
	struct request *rq = pc->rq;
236
	struct req_iterator iter;
Linus Torvalds's avatar
Linus Torvalds committed
237 238
	struct bio_vec *bvec;
	unsigned long flags;
239
	int count, done = 0;
Linus Torvalds's avatar
Linus Torvalds committed
240 241
	char *data;

242
	rq_for_each_segment(bvec, rq, iter) {
243 244
		if (!bcount)
			break;
Linus Torvalds's avatar
Linus Torvalds committed
245

246
		count = min(bvec->bv_len, bcount);
Linus Torvalds's avatar
Linus Torvalds committed
247

248
		data = bvec_kmap_irq(bvec, &flags);
249
		if (direction)
250
			hwif->output_data(drive, NULL, data, count);
251
		else
252
			hwif->input_data(drive, NULL, data, count);
253
		bvec_kunmap_irq(data, &flags);
Linus Torvalds's avatar
Linus Torvalds committed
254

255 256 257
		bcount -= count;
		pc->b_count += count;
		done += count;
Linus Torvalds's avatar
Linus Torvalds committed
258 259
	}

260
	idefloppy_end_request(drive, 1, done >> 9);
Linus Torvalds's avatar
Linus Torvalds committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
266 267 268
	}
}

269 270
static void idefloppy_update_buffers(ide_drive_t *drive,
				struct ide_atapi_pc *pc)
Linus Torvalds's avatar
Linus Torvalds committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
283
 */
284
static void idefloppy_queue_pc_head(ide_drive_t *drive, struct ide_atapi_pc *pc,
285
		struct request *rq)
Linus Torvalds's avatar
Linus Torvalds committed
286 287 288 289 290
{
	struct ide_floppy_obj *floppy = drive->driver_data;

	ide_init_drive_cmd(rq);
	rq->buffer = (char *) pc;
291
	rq->cmd_type = REQ_TYPE_SPECIAL;
Linus Torvalds's avatar
Linus Torvalds committed
292 293 294 295
	rq->rq_disk = floppy->disk;
	(void) ide_do_drive_cmd(drive, rq, ide_preempt);
}

296
static struct ide_atapi_pc *idefloppy_next_pc_storage(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
297 298 299 300
{
	idefloppy_floppy_t *floppy = drive->driver_data;

	if (floppy->pc_stack_index == IDEFLOPPY_PC_STACK)
301
		floppy->pc_stack_index = 0;
Linus Torvalds's avatar
Linus Torvalds committed
302 303 304
	return (&floppy->pc_stack[floppy->pc_stack_index++]);
}

305
static struct request *idefloppy_next_rq_storage(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
306 307 308 309 310 311 312 313
{
	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++]);
}

314
static void idefloppy_request_sense_callback(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
315 316
{
	idefloppy_floppy_t *floppy = drive->driver_data;
317
	u8 *buf = floppy->pc->buf;
Linus Torvalds's avatar
Linus Torvalds committed
318

319 320
	debug_log("Reached %s\n", __func__);

Linus Torvalds's avatar
Linus Torvalds committed
321
	if (!floppy->pc->error) {
322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
		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;

		if (floppy->failed_pc)
			debug_log("pc = %x, sense key = %x, asc = %x,"
					" ascq = %x\n",
					floppy->failed_pc->c[0],
					floppy->sense_key,
					floppy->asc,
					floppy->ascq);
		else
			debug_log("sense key = %x, asc = %x, ascq = %x\n",
					floppy->sense_key,
					floppy->asc,
					floppy->ascq);


342
		idefloppy_end_request(drive, 1, 0);
Linus Torvalds's avatar
Linus Torvalds committed
343
	} else {
344 345
		printk(KERN_ERR "Error in REQUEST SENSE itself - Aborting"
				" request!\n");
346
		idefloppy_end_request(drive, 0, 0);
Linus Torvalds's avatar
Linus Torvalds committed
347 348 349
	}
}

350 351
/* General packet command callback function. */
static void idefloppy_pc_callback(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
352 353
{
	idefloppy_floppy_t *floppy = drive->driver_data;
354 355

	debug_log("Reached %s\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
356

357
	idefloppy_end_request(drive, floppy->pc->error ? 0 : 1, 0);
Linus Torvalds's avatar
Linus Torvalds committed
358 359
}

360
static void idefloppy_init_pc(struct ide_atapi_pc *pc)
Linus Torvalds's avatar
Linus Torvalds committed
361 362 363 364
{
	memset(pc->c, 0, 12);
	pc->retries = 0;
	pc->flags = 0;
365 366 367 368
	pc->req_xfer = 0;
	pc->buf = pc->pc_buf;
	pc->buf_size = IDEFLOPPY_PC_BUFFER_SIZE;
	pc->idefloppy_callback = &idefloppy_pc_callback;
Linus Torvalds's avatar
Linus Torvalds committed
369 370
}

371
static void idefloppy_create_request_sense_cmd(struct ide_atapi_pc *pc)
Linus Torvalds's avatar
Linus Torvalds committed
372
{
373 374
	idefloppy_init_pc(pc);
	pc->c[0] = GPCMD_REQUEST_SENSE;
Linus Torvalds's avatar
Linus Torvalds committed
375
	pc->c[4] = 255;
376 377
	pc->req_xfer = 18;
	pc->idefloppy_callback = &idefloppy_request_sense_callback;
Linus Torvalds's avatar
Linus Torvalds committed
378 379 380
}

/*
381 382
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
383
 */
384
static void idefloppy_retry_pc(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
385
{
386
	struct ide_atapi_pc *pc;
Linus Torvalds's avatar
Linus Torvalds committed
387 388
	struct request *rq;

389
	(void)ide_read_error(drive);
Linus Torvalds's avatar
Linus Torvalds committed
390 391 392 393 394 395
	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);
}

396
/* The usual interrupt handler called during a packet command. */
397
static ide_startstop_t idefloppy_pc_intr(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
398 399
{
	idefloppy_floppy_t *floppy = drive->driver_data;
400
	ide_hwif_t *hwif = drive->hwif;
401
	struct ide_atapi_pc *pc = floppy->pc;
Linus Torvalds's avatar
Linus Torvalds committed
402
	struct request *rq = pc->rq;
403
	xfer_func_t *xferfunc;
Linus Torvalds's avatar
Linus Torvalds committed
404
	unsigned int temp;
405
	int dma_error = 0;
406
	u16 bcount;
407
	u8 stat, ireason;
Linus Torvalds's avatar
Linus Torvalds committed
408

409
	debug_log("Reached %s interrupt handler\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
410

411
	if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
412
		dma_error = hwif->dma_ops->dma_end(drive);
413 414 415
		if (dma_error) {
			printk(KERN_ERR "%s: DMA %s error\n", drive->name,
					rq_data_dir(rq) ? "write" : "read");
416
			pc->flags |= PC_FLAG_DMA_ERROR;
Linus Torvalds's avatar
Linus Torvalds committed
417
		} else {
418
			pc->xferred = pc->req_xfer;
Linus Torvalds's avatar
Linus Torvalds committed
419 420
			idefloppy_update_buffers(drive, pc);
		}
421
		debug_log("DMA finished\n");
Linus Torvalds's avatar
Linus Torvalds committed
422 423 424
	}

	/* Clear the interrupt */
425
	stat = ide_read_status(drive);
Linus Torvalds's avatar
Linus Torvalds committed
426

427 428
	/* No more interrupts */
	if ((stat & DRQ_STAT) == 0) {
429
		debug_log("Packet command completed, %d bytes transferred\n",
430
				pc->xferred);
431
		pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
Linus Torvalds's avatar
Linus Torvalds committed
432

433
		local_irq_enable_in_hardirq();
Linus Torvalds's avatar
Linus Torvalds committed
434

435
		if ((stat & ERR_STAT) || (pc->flags & PC_FLAG_DMA_ERROR)) {
Linus Torvalds's avatar
Linus Torvalds committed
436
			/* Error detected */
437
			debug_log("%s: I/O error\n", drive->name);
Linus Torvalds's avatar
Linus Torvalds committed
438
			rq->errors++;
439
			if (pc->c[0] == GPCMD_REQUEST_SENSE) {
Linus Torvalds's avatar
Linus Torvalds committed
440 441 442 443 444 445 446 447 448 449 450 451 452
				printk(KERN_ERR "ide-floppy: I/O error in "
					"request sense command\n");
				return ide_do_reset(drive);
			}
			/* Retry operation */
			idefloppy_retry_pc(drive);
			/* queued, but not started */
			return ide_stopped;
		}
		pc->error = 0;
		if (floppy->failed_pc == pc)
			floppy->failed_pc = NULL;
		/* Command finished - Call the callback function */
453
		pc->idefloppy_callback(drive);
Linus Torvalds's avatar
Linus Torvalds committed
454 455 456
		return ide_stopped;
	}

457 458
	if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
		pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
Linus Torvalds's avatar
Linus Torvalds committed
459 460
		printk(KERN_ERR "ide-floppy: The floppy wants to issue "
			"more interrupts in DMA mode\n");
461
		ide_dma_off(drive);
Linus Torvalds's avatar
Linus Torvalds committed
462 463 464 465
		return ide_do_reset(drive);
	}

	/* Get the number of bytes to transfer */
466 467
	bcount = (hwif->INB(hwif->io_ports.lbah_addr) << 8) |
		  hwif->INB(hwif->io_ports.lbam_addr);
Linus Torvalds's avatar
Linus Torvalds committed
468
	/* on this interrupt */
469
	ireason = hwif->INB(hwif->io_ports.nsect_addr);
Linus Torvalds's avatar
Linus Torvalds committed
470

471
	if (ireason & CD) {
472
		printk(KERN_ERR "ide-floppy: CoD != 0 in %s\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
473 474
		return ide_do_reset(drive);
	}
475
	if (((ireason & IO) == IO) == !!(pc->flags & PC_FLAG_WRITING)) {
Linus Torvalds's avatar
Linus Torvalds committed
476 477
		/* Hopefully, we will never get here */
		printk(KERN_ERR "ide-floppy: We wanted to %s, ",
478
				(ireason & IO) ? "Write" : "Read");
Linus Torvalds's avatar
Linus Torvalds committed
479
		printk(KERN_ERR "but the floppy wants us to %s !\n",
480
				(ireason & IO) ? "Read" : "Write");
Linus Torvalds's avatar
Linus Torvalds committed
481 482
		return ide_do_reset(drive);
	}
483
	if (!(pc->flags & PC_FLAG_WRITING)) {
Linus Torvalds's avatar
Linus Torvalds committed
484
		/* Reading - Check that we have enough space */
485 486 487
		temp = pc->xferred + bcount;
		if (temp > pc->req_xfer) {
			if (temp > pc->buf_size) {
Linus Torvalds's avatar
Linus Torvalds committed
488 489 490
				printk(KERN_ERR "ide-floppy: The floppy wants "
					"to send us more data than expected "
					"- discarding data\n");
491
				ide_pad_transfer(drive, 0, bcount);
492

Linus Torvalds's avatar
Linus Torvalds committed
493 494 495 496 497 498
				ide_set_handler(drive,
						&idefloppy_pc_intr,
						IDEFLOPPY_WAIT_CMD,
						NULL);
				return ide_started;
			}
499 500
			debug_log("The floppy wants to send us more data than"
					" expected - allowing transfer\n");
Linus Torvalds's avatar
Linus Torvalds committed
501 502
		}
	}
503
	if (pc->flags & PC_FLAG_WRITING)
504
		xferfunc = hwif->output_data;
505
	else
506
		xferfunc = hwif->input_data;
507

508
	if (pc->buf)
509
		xferfunc(drive, NULL, pc->cur_pos, bcount);
510
	else
511
		ide_floppy_io_buffers(drive, pc, bcount,
512
				      !!(pc->flags & PC_FLAG_WRITING));
513

Linus Torvalds's avatar
Linus Torvalds committed
514
	/* Update the current position */
515 516
	pc->xferred += bcount;
	pc->cur_pos += bcount;
Linus Torvalds's avatar
Linus Torvalds committed
517

518 519
	/* And set the interrupt handler again */
	ide_set_handler(drive, &idefloppy_pc_intr, IDEFLOPPY_WAIT_CMD, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
520 521 522 523 524 525 526 527
	return ide_started;
}

/*
 * This is the original routine that did the packet transfer.
 * It fails at high speeds on the Iomega ZIP drive, so there's a slower version
 * for that drive below. The algorithm is chosen based on drive type
 */
528
static ide_startstop_t idefloppy_transfer_pc(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
529
{
530
	ide_hwif_t *hwif = drive->hwif;
Linus Torvalds's avatar
Linus Torvalds committed
531 532
	ide_startstop_t startstop;
	idefloppy_floppy_t *floppy = drive->driver_data;
533
	u8 ireason;
Linus Torvalds's avatar
Linus Torvalds committed
534 535 536 537 538 539

	if (ide_wait_stat(&startstop, drive, DRQ_STAT, BUSY_STAT, WAIT_READY)) {
		printk(KERN_ERR "ide-floppy: Strange, packet command "
				"initiated yet DRQ isn't asserted\n");
		return startstop;
	}
540
	ireason = hwif->INB(hwif->io_ports.nsect_addr);
541
	if ((ireason & CD) == 0 || (ireason & IO)) {
Linus Torvalds's avatar
Linus Torvalds committed
542 543 544 545
		printk(KERN_ERR "ide-floppy: (IO,CoD) != (0,1) while "
				"issuing a packet command\n");
		return ide_do_reset(drive);
	}
546

Linus Torvalds's avatar
Linus Torvalds committed
547 548
	/* Set the interrupt routine */
	ide_set_handler(drive, &idefloppy_pc_intr, IDEFLOPPY_WAIT_CMD, NULL);
549

Linus Torvalds's avatar
Linus Torvalds committed
550
	/* Send the actual packet */
551 552
	hwif->output_data(drive, NULL, floppy->pc->c, 12);

Linus Torvalds's avatar
Linus Torvalds committed
553 554 555 556 557
	return ide_started;
}


/*
558 559 560 561
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
562
 *
563 564 565
 * So, follow carefully. transfer_pc1 is called as an interrupt (or directly).
 * In either case, when the device says it's ready for a packet, we schedule
 * the packet transfer to occur about 2-3 ticks later in transfer_pc2.
Linus Torvalds's avatar
Linus Torvalds committed
566
 */
567
static int idefloppy_transfer_pc2(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
568 569 570 571
{
	idefloppy_floppy_t *floppy = drive->driver_data;

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

Linus Torvalds's avatar
Linus Torvalds committed
574 575 576 577
	/* Timeout for the packet command */
	return IDEFLOPPY_WAIT_CMD;
}

578
static ide_startstop_t idefloppy_transfer_pc1(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
579
{
580
	ide_hwif_t *hwif = drive->hwif;
Linus Torvalds's avatar
Linus Torvalds committed
581 582
	idefloppy_floppy_t *floppy = drive->driver_data;
	ide_startstop_t startstop;
583
	u8 ireason;
Linus Torvalds's avatar
Linus Torvalds committed
584 585 586 587 588 589

	if (ide_wait_stat(&startstop, drive, DRQ_STAT, BUSY_STAT, WAIT_READY)) {
		printk(KERN_ERR "ide-floppy: Strange, packet command "
				"initiated yet DRQ isn't asserted\n");
		return startstop;
	}
590
	ireason = hwif->INB(hwif->io_ports.nsect_addr);
591
	if ((ireason & CD) == 0 || (ireason & IO)) {
Linus Torvalds's avatar
Linus Torvalds committed
592 593 594 595
		printk(KERN_ERR "ide-floppy: (IO,CoD) != (0,1) "
				"while issuing a packet command\n");
		return ide_do_reset(drive);
	}
596
	/*
Linus Torvalds's avatar
Linus Torvalds committed
597 598 599 600 601 602 603
	 * 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.
	 */
604

605 606
	ide_set_handler(drive, &idefloppy_pc_intr, floppy->ticks,
			&idefloppy_transfer_pc2);
Linus Torvalds's avatar
Linus Torvalds committed
607 608 609
	return ide_started;
}

610
static void ide_floppy_report_error(idefloppy_floppy_t *floppy,
611
				    struct ide_atapi_pc *pc)
Linus Torvalds's avatar
Linus Torvalds committed
612
{
613
	/* supress error messages resulting from Medium not present */
Linus Torvalds's avatar
Linus Torvalds committed
614 615 616
	if (floppy->sense_key == 0x02 &&
	    floppy->asc       == 0x3a &&
	    floppy->ascq      == 0x00)
617 618 619 620 621 622 623
		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);

Linus Torvalds's avatar
Linus Torvalds committed
624 625
}

626
static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
627
		struct ide_atapi_pc *pc)
Linus Torvalds's avatar
Linus Torvalds committed
628 629 630 631
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	ide_hwif_t *hwif = drive->hwif;
	ide_handler_t *pkt_xfer_routine;
632
	u16 bcount;
633
	u8 dma;
Linus Torvalds's avatar
Linus Torvalds committed
634 635

	if (floppy->failed_pc == NULL &&
636
	    pc->c[0] != GPCMD_REQUEST_SENSE)
Linus Torvalds's avatar
Linus Torvalds committed
637 638 639 640
		floppy->failed_pc = pc;
	/* Set the current packet command */
	floppy->pc = pc;

641
	if (pc->retries > IDEFLOPPY_MAX_PC_RETRIES) {
642
		if (!(pc->flags & PC_FLAG_SUPPRESS_ERROR))
643 644 645 646
			ide_floppy_report_error(floppy, pc);
		/* Giving up */
		pc->error = IDEFLOPPY_ERROR_GENERAL;

Linus Torvalds's avatar
Linus Torvalds committed
647
		floppy->failed_pc = NULL;
648
		pc->idefloppy_callback(drive);
Linus Torvalds's avatar
Linus Torvalds committed
649 650 651
		return ide_stopped;
	}

652
	debug_log("Retry number - %d\n", pc->retries);
Linus Torvalds's avatar
Linus Torvalds committed
653 654 655

	pc->retries++;
	/* We haven't transferred any data yet */
656 657 658
	pc->xferred = 0;
	pc->cur_pos = pc->buf;
	bcount = min(pc->req_xfer, 63 * 1024);
Linus Torvalds's avatar
Linus Torvalds committed
659

660 661
	if (pc->flags & PC_FLAG_DMA_ERROR) {
		pc->flags &= ~PC_FLAG_DMA_ERROR;
662
		ide_dma_off(drive);
663
	}
664
	dma = 0;
Linus Torvalds's avatar
Linus Torvalds committed
665

666
	if ((pc->flags & PC_FLAG_DMA_RECOMMENDED) && drive->using_dma)
667
		dma = !hwif->dma_ops->dma_setup(drive);
Linus Torvalds's avatar
Linus Torvalds committed
668

669 670
	ide_pktcmd_tf_load(drive, IDE_TFLAG_NO_SELECT_MASK |
			   IDE_TFLAG_OUT_DEVICE, bcount, dma);
Linus Torvalds's avatar
Linus Torvalds committed
671

672 673
	if (dma) {
		/* Begin DMA, if necessary */
674
		pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
675
		hwif->dma_ops->dma_start(drive);
Linus Torvalds's avatar
Linus Torvalds committed
676 677 678
	}

	/* Can we transfer the packet when we get the interrupt or wait? */
679
	if (floppy->flags & IDEFLOPPY_FLAG_ZIP_DRIVE) {
Linus Torvalds's avatar
Linus Torvalds committed
680 681 682 683 684 685
		/* wait */
		pkt_xfer_routine = &idefloppy_transfer_pc1;
	} else {
		/* immediate */
		pkt_xfer_routine = &idefloppy_transfer_pc;
	}
686

687
	if (floppy->flags & IDEFLOPPY_FLAG_DRQ_INTERRUPT) {
Linus Torvalds's avatar
Linus Torvalds committed
688 689 690 691 692 693 694 695
		/* Issue the packet command */
		ide_execute_command(drive, WIN_PACKETCMD,
				pkt_xfer_routine,
				IDEFLOPPY_WAIT_CMD,
				NULL);
		return ide_started;
	} else {
		/* Issue the packet command */
696
		ide_execute_pkt_cmd(drive);
Linus Torvalds's avatar
Linus Torvalds committed
697 698 699 700
		return (*pkt_xfer_routine) (drive);
	}
}

701
static void idefloppy_rw_callback(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
702
{
703
	debug_log("Reached %s\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
704

705
	idefloppy_end_request(drive, 1, 0);
Linus Torvalds's avatar
Linus Torvalds committed
706 707 708
	return;
}

709
static void idefloppy_create_prevent_cmd(struct ide_atapi_pc *pc, int prevent)
Linus Torvalds's avatar
Linus Torvalds committed
710
{
711
	debug_log("creating prevent removal command, prevent = %d\n", prevent);
Linus Torvalds's avatar
Linus Torvalds committed
712 713

	idefloppy_init_pc(pc);
714
	pc->c[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
Linus Torvalds's avatar
Linus Torvalds committed
715 716 717
	pc->c[4] = prevent;
}

718
static void idefloppy_create_read_capacity_cmd(struct ide_atapi_pc *pc)
Linus Torvalds's avatar
Linus Torvalds committed
719 720
{
	idefloppy_init_pc(pc);
721
	pc->c[0] = GPCMD_READ_FORMAT_CAPACITIES;
Linus Torvalds's avatar
Linus Torvalds committed
722 723
	pc->c[7] = 255;
	pc->c[8] = 255;
724
	pc->req_xfer = 255;
Linus Torvalds's avatar
Linus Torvalds committed
725 726
}

727 728
static void idefloppy_create_format_unit_cmd(struct ide_atapi_pc *pc, int b,
		int l, int flags)
Linus Torvalds's avatar
Linus Torvalds committed
729 730
{
	idefloppy_init_pc(pc);
731
	pc->c[0] = GPCMD_FORMAT_UNIT;
Linus Torvalds's avatar
Linus Torvalds committed
732 733
	pc->c[1] = 0x17;

734 735
	memset(pc->buf, 0, 12);
	pc->buf[1] = 0xA2;
Linus Torvalds's avatar
Linus Torvalds committed
736 737 738
	/* Default format list header, u8 1: FOV/DCRT/IMM bits set */

	if (flags & 1)				/* Verify bit on... */
739 740
		pc->buf[1] ^= 0x20;		/* ... turn off DCRT bit */
	pc->buf[3] = 8;
Linus Torvalds's avatar
Linus Torvalds committed
741

742 743 744
	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;
745
	pc->flags |= PC_FLAG_WRITING;
Linus Torvalds's avatar
Linus Torvalds committed
746 747
}

748
/* A mode sense command is used to "sense" floppy parameters. */
749 750
static void idefloppy_create_mode_sense_cmd(struct ide_atapi_pc *pc,
		u8 page_code, u8 type)
Linus Torvalds's avatar
Linus Torvalds committed
751
{
752
	u16 length = 8; /* sizeof(Mode Parameter Header) = 8 Bytes */
753

Linus Torvalds's avatar
Linus Torvalds committed
754
	idefloppy_init_pc(pc);
755
	pc->c[0] = GPCMD_MODE_SENSE_10;
Linus Torvalds's avatar
Linus Torvalds committed
756 757 758 759
	pc->c[1] = 0;
	pc->c[2] = page_code + (type << 6);

	switch (page_code) {
760 761 762 763 764 765 766 767
	case IDEFLOPPY_CAPABILITIES_PAGE:
		length += 12;
		break;
	case IDEFLOPPY_FLEXIBLE_DISK_PAGE:
		length += 32;
		break;
	default:
		printk(KERN_ERR "ide-floppy: unsupported page code "
Linus Torvalds's avatar
Linus Torvalds committed
768 769
				"in create_mode_sense_cmd\n");
	}
770
	put_unaligned(cpu_to_be16(length), (u16 *) &pc->c[7]);
771
	pc->req_xfer = length;
Linus Torvalds's avatar
Linus Torvalds committed
772 773
}

774
static void idefloppy_create_start_stop_cmd(struct ide_atapi_pc *pc, int start)
Linus Torvalds's avatar
Linus Torvalds committed
775 776
{
	idefloppy_init_pc(pc);
777
	pc->c[0] = GPCMD_START_STOP_UNIT;
Linus Torvalds's avatar
Linus Torvalds committed
778 779 780
	pc->c[4] = start;
}

781
static void idefloppy_create_test_unit_ready_cmd(struct ide_atapi_pc *pc)
Linus Torvalds's avatar
Linus Torvalds committed
782 783
{
	idefloppy_init_pc(pc);
784
	pc->c[0] = GPCMD_TEST_UNIT_READY;
Linus Torvalds's avatar
Linus Torvalds committed
785 786
}

787
static void idefloppy_create_rw_cmd(idefloppy_floppy_t *floppy,
788
				    struct ide_atapi_pc *pc, struct request *rq,
789
				    unsigned long sector)
Linus Torvalds's avatar
Linus Torvalds committed
790 791 792 793 794
{
	int block = sector / floppy->bs_factor;
	int blocks = rq->nr_sectors / floppy->bs_factor;
	int cmd = rq_data_dir(rq);

795
	debug_log("create_rw10_cmd: block == %d, blocks == %d\n",
Linus Torvalds's avatar
Linus Torvalds committed
796 797 798
		block, blocks);

	idefloppy_init_pc(pc);
799 800
	pc->c[0] = cmd == READ ? GPCMD_READ_10 : GPCMD_WRITE_10;
	put_unaligned(cpu_to_be16(blocks), (unsigned short *)&pc->c[7]);
801
	put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[2]);
802

803
	pc->idefloppy_callback = &idefloppy_rw_callback;
Linus Torvalds's avatar
Linus Torvalds committed
804 805
	pc->rq = rq;
	pc->b_count = cmd == READ ? 0 : rq->bio->bi_size;
806
	if (rq->cmd_flags & REQ_RW)
807
		pc->flags |= PC_FLAG_WRITING;
808 809
	pc->buf = NULL;
	pc->req_xfer = pc->buf_size = blocks * floppy->block_size;
810
	pc->flags |= PC_FLAG_DMA_RECOMMENDED;
Linus Torvalds's avatar
Linus Torvalds committed
811 812
}

813
static void idefloppy_blockpc_cmd(idefloppy_floppy_t *floppy,
814
		struct ide_atapi_pc *pc, struct request *rq)
Linus Torvalds's avatar
Linus Torvalds committed
815 816
{
	idefloppy_init_pc(pc);
817
	pc->idefloppy_callback = &idefloppy_rw_callback;
Linus Torvalds's avatar
Linus Torvalds committed
818
	memcpy(pc->c, rq->cmd, sizeof(pc->c));
819 820 821
	pc->rq = rq;
	pc->b_count = rq->data_len;
	if (rq->data_len && rq_data_dir(rq) == WRITE)
822
		pc->flags |= PC_FLAG_WRITING;
823
	pc->buf = rq->data;
824
	if (rq->bio)
825
		pc->flags |= PC_FLAG_DMA_RECOMMENDED;
826 827 828 829
	/*
	 * possibly problematic, doesn't look like ide-floppy correctly
	 * handled scattered requests if dma fails...
	 */
830
	pc->req_xfer = pc->buf_size = rq->data_len;
Linus Torvalds's avatar
Linus Torvalds committed
831 832
}

833 834
static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
		struct request *rq, sector_t block_s)
Linus Torvalds's avatar
Linus Torvalds committed
835 836
{
	idefloppy_floppy_t *floppy = drive->driver_data;
837
	struct ide_atapi_pc *pc;
Linus Torvalds's avatar
Linus Torvalds committed
838 839
	unsigned long block = (unsigned long)block_s;

840
	debug_log("dev: %s, cmd_type: %x, errors: %d\n",
841
			rq->rq_disk ? rq->rq_disk->disk_name : "?",
842 843
			rq->cmd_type, rq->errors);
	debug_log("sector: %ld, nr_sectors: %ld, "
Linus Torvalds's avatar
Linus Torvalds committed
844 845 846 847
			"current_nr_sectors: %d\n", (long)rq->sector,
			rq->nr_sectors, rq->current_nr_sectors);

	if (rq->errors >= ERROR_MAX) {
848 849
		if (floppy->failed_pc)
			ide_floppy_report_error(floppy, floppy->failed_pc);
Linus Torvalds's avatar
Linus Torvalds committed
850 851 852
		else
			printk(KERN_ERR "ide-floppy: %s: I/O error\n",
				drive->name);
853
		idefloppy_end_request(drive, 0, 0);
Linus Torvalds's avatar
Linus Torvalds committed
854 855
		return ide_stopped;
	}
856
	if (blk_fs_request(rq)) {
Linus Torvalds's avatar
Linus Torvalds committed
857 858
		if (((long)rq->sector % floppy->bs_factor) ||
		    (rq->nr_sectors % floppy->bs_factor)) {
859 860
			printk(KERN_ERR "%s: unsupported r/w request size\n",
					drive->name);
861
			idefloppy_end_request(drive, 0, 0);
Linus Torvalds's avatar
Linus Torvalds committed
862 863 864 865
			return ide_stopped;
		}
		pc = idefloppy_next_pc_storage(drive);
		idefloppy_create_rw_cmd(floppy, pc, rq, block);
866
	} else if (blk_special_request(rq)) {
867
		pc = (struct ide_atapi_pc *) rq->buffer;
868
	} else if (blk_pc_request(rq)) {
Linus Torvalds's avatar
Linus Torvalds committed
869
		pc = idefloppy_next_pc_storage(drive);
870
		idefloppy_blockpc_cmd(floppy, pc, rq);
Linus Torvalds's avatar
Linus Torvalds committed
871 872 873
	} else {
		blk_dump_rq_flags(rq,
			"ide-floppy: unsupported command in queue");
874
		idefloppy_end_request(drive, 0, 0);
Linus Torvalds's avatar
Linus Torvalds committed
875 876 877 878 879 880 881 882
		return ide_stopped;
	}

	pc->rq = rq;
	return idefloppy_issue_pc(drive, pc);
}

/*
883 884
 * Add a special packet command request to the tail of the request queue,
 * and wait for it to be serviced.
Linus Torvalds's avatar
Linus Torvalds committed
885
 */
886
static int idefloppy_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc)
Linus Torvalds's avatar
Linus Torvalds committed
887 888 889 890
{
	struct ide_floppy_obj *floppy = drive->driver_data;
	struct request rq;

891
	ide_init_drive_cmd(&rq);
Linus Torvalds's avatar
Linus Torvalds committed
892
	rq.buffer = (char *) pc;
893
	rq.cmd_type = REQ_TYPE_SPECIAL;
Linus Torvalds's avatar
Linus Torvalds committed
894 895 896 897 898 899
	rq.rq_disk = floppy->disk;

	return ide_do_drive_cmd(drive, &rq, ide_wait);
}

/*
900 901
 * Look at the flexible disk page parameters. We ignore the CHS capacity
 * parameters and use the LBA parameters instead.
Linus Torvalds's avatar
Linus Torvalds committed
902
 */
903
static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
904 905
{
	idefloppy_floppy_t *floppy = drive->driver_data;
906
	struct ide_atapi_pc pc;
907
	u8 *page;
Linus Torvalds's avatar
Linus Torvalds committed
908
	int capacity, lba_capacity;
909 910
	u16 transfer_rate, sector_size, cyls, rpm;
	u8 heads, sectors;
Linus Torvalds's avatar
Linus Torvalds committed
911

912 913 914 915 916 917
	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");
Linus Torvalds's avatar
Linus Torvalds committed
918 919
		return 1;
	}
920
	floppy->wp = !!(pc.buf[3] & 0x80);
Linus Torvalds's avatar
Linus Torvalds committed
921
	set_disk_ro(floppy->disk, floppy->wp);
922
	page = &pc.buf[8];
923

924 925 926 927 928 929
	transfer_rate = be16_to_cpu(*(u16 *)&pc.buf[8 + 2]);
	sector_size   = be16_to_cpu(*(u16 *)&pc.buf[8 + 6]);
	cyls          = be16_to_cpu(*(u16 *)&pc.buf[8 + 8]);
	rpm           = be16_to_cpu(*(u16 *)&pc.buf[8 + 28]);
	heads         = pc.buf[8 + 4];
	sectors       = pc.buf[8 + 5];
930 931 932 933

	capacity = cyls * heads * sectors * sector_size;

	if (memcmp(page, &floppy->flexible_disk_page, 32))
Linus Torvalds's avatar
Linus Torvalds committed
934 935
		printk(KERN_INFO "%s: %dkB, %d/%d/%d CHS, %d kBps, "
				"%d sector size, %d rpm\n",
936 937 938 939 940 941 942
				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;
Linus Torvalds's avatar
Linus Torvalds committed
943
	lba_capacity = floppy->blocks * floppy->block_size;
944

Linus Torvalds's avatar
Linus Torvalds committed
945 946 947 948
	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);
949 950
		floppy->blocks = floppy->block_size ?
			capacity / floppy->block_size : 0;
Linus Torvalds's avatar
Linus Torvalds committed
951 952 953 954
	}
	return 0;
}

955
static int idefloppy_get_sfrp_bit(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
956 957
{
	idefloppy_floppy_t *floppy = drive->driver_data;
958
	struct ide_atapi_pc pc;
Linus Torvalds's avatar
Linus Torvalds committed
959 960 961 962 963

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

964
	pc.flags |= PC_FLAG_SUPPRESS_ERROR;
965
	if (idefloppy_queue_pc_tail(drive, &pc))
Linus Torvalds's avatar
Linus Torvalds committed
966 967
		return 1;

968
	floppy->srfp = pc.buf[8 + 2] & 0x40;
Linus Torvalds's avatar
Linus Torvalds committed
969 970 971 972
	return (0);
}

/*
973 974
 * Determine if a media is present in the floppy drive, and if so, its LBA
 * capacity.
Linus Torvalds's avatar
Linus Torvalds committed
975
 */
976
static int ide_floppy_get_capacity(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
977 978
{
	idefloppy_floppy_t *floppy = drive->driver_data;
979
	struct ide_atapi_pc pc;
980 981 982 983
	u8 *cap_desc;
	u8 header_len, desc_cnt;
	int i, rc = 1, blocks, length;

Linus Torvalds's avatar
Linus Torvalds committed
984 985
	drive->bios_cyl = 0;
	drive->bios_head = drive->bios_sect = 0;
986 987
	floppy->blocks = 0;
	floppy->bs_factor = 1;
Linus Torvalds's avatar
Linus Torvalds committed
988 989 990 991 992 993 994
	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;
	}
995 996
	header_len = pc.buf[3];
	cap_desc = &pc.buf[4];
997 998 999 1000 1001
	desc_cnt = header_len / 8; /* capacity descriptor of 8 bytes */

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

1002 1003
		blocks = be32_to_cpu(*(u32 *)&pc.buf[desc_start]);
		length = be16_to_cpu(*(u16 *)&pc.buf[desc_start + 6]);
1004 1005 1006

		debug_log("Descriptor %d: %dkB, %d blocks, %d sector size\n",
				i, blocks * length / 1024, blocks, length);
Linus Torvalds's avatar
Linus Torvalds committed
1007

1008 1009 1010 1011 1012
		if (i)
			continue;
		/*
		 * the code below is valid only for the 1st descriptor, ie i=0
		 */
Linus Torvalds's avatar
Linus Torvalds committed
1013

1014
		switch (pc.buf[desc_start + 4] & 0x03) {
Linus Torvalds's avatar
Linus Torvalds committed
1015 1016
		/* Clik! drive returns this instead of CAPACITY_CURRENT */
		case CAPACITY_UNFORMATTED:
1017
			if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE))
1018
				/*
Linus Torvalds's avatar
Linus Torvalds committed
1019 1020 1021 1022 1023 1024
				 * If it is not a clik drive, break out
				 * (maintains previous driver behaviour)
				 */
				break;
		case CAPACITY_CURRENT:
			/* Normal Zip/LS-120 disks */
1025
			if (memcmp(cap_desc, &floppy->cap_desc, 8))
Linus Torvalds's avatar
Linus Torvalds committed
1026 1027 1028
				printk(KERN_INFO "%s: %dkB, %d blocks, %d "
					"sector size\n", drive->name,
					blocks * length / 1024, blocks, length);
1029 1030
			memcpy(&floppy->cap_desc, cap_desc, 8);

Linus Torvalds's avatar
Linus Torvalds committed
1031 1032 1033 1034
			if (!length || length % 512) {
				printk(KERN_NOTICE "%s: %d bytes block size "
					"not supported\n", drive->name, length);
			} else {
1035 1036 1037 1038 1039
				floppy->blocks = blocks;
				floppy->block_size = length;
				floppy->bs_factor = length / 512;
				if (floppy->bs_factor != 1)
					printk(KERN_NOTICE "%s: warning: non "
Linus Torvalds's avatar
Linus Torvalds committed
1040 1041 1042
						"512 bytes block size not "
						"fully supported\n",
						drive->name);
1043
				rc = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
			}
			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;
		}
1058
		debug_log("Descriptor 0 Code: %d\n",
1059
			  pc.buf[desc_start + 4] & 0x03);
Linus Torvalds's avatar
Linus Torvalds committed
1060 1061 1062
	}

	/* Clik! disk does not support get_flexible_disk_page */
1063
	if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE))
1064
		(void) ide_floppy_get_flexible_disk_page(drive);
Linus Torvalds's avatar
Linus Torvalds committed
1065 1066 1067 1068 1069 1070

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

/*
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087
 * 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.
 */
Linus Torvalds's avatar
Linus Torvalds committed
1088

1089
static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)
Linus Torvalds's avatar
Linus Torvalds committed
1090
{
1091
	struct ide_atapi_pc pc;
1092 1093
	u8 header_len, desc_cnt;
	int i, blocks, length, u_array_size, u_index;
Linus Torvalds's avatar
Linus Torvalds committed
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
	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");
1105 1106
		return (-EIO);
	}
1107
	header_len = pc.buf[3];
1108
	desc_cnt = header_len / 8; /* capacity descriptor of 8 bytes */
Linus Torvalds's avatar
Linus Torvalds committed
1109 1110 1111 1112 1113

	u_index = 0;
	argp = arg + 1;

	/*
1114 1115 1116 1117 1118 1119
	 * 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;
Linus Torvalds's avatar
Linus Torvalds committed
1120 1121 1122 1123

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

1124 1125
		blocks = be32_to_cpu(*(u32 *)&pc.buf[desc_start]);
		length = be16_to_cpu(*(u16 *)&pc.buf[desc_start + 6]);
Linus Torvalds's avatar
Linus Torvalds committed
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143

		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);
}

/*
1144 1145 1146 1147 1148 1149 1150 1151
 * 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.
 */
Linus Torvalds's avatar
Linus Torvalds committed
1152 1153 1154 1155

static int idefloppy_get_format_progress(ide_drive_t *drive, int __user *arg)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
1156
	struct ide_atapi_pc pc;
Linus Torvalds's avatar
Linus Torvalds committed
1157 1158 1159 1160
	int progress_indication = 0x10000;

	if (floppy->srfp) {
		idefloppy_create_request_sense_cmd(&pc);
1161
		if (idefloppy_queue_pc_tail(drive, &pc))
Linus Torvalds's avatar
Linus Torvalds committed
1162 1163 1164 1165
			return (-EIO);

		if (floppy->sense_key == 2 &&
		    floppy->asc == 4 &&
1166
		    floppy->ascq == 4)
Linus Torvalds's avatar
Linus Torvalds committed
1167
			progress_indication = floppy->progress_indication;
1168 1169

		/* Else assume format_unit has finished, and we're at 0x10000 */
Linus Torvalds's avatar
Linus Torvalds committed
1170 1171
	} else {
		unsigned long flags;
1172
		u8 stat;
Linus Torvalds's avatar
Linus Torvalds committed
1173 1174

		local_irq_save(flags);
1175
		stat = ide_read_status(drive);
Linus Torvalds's avatar
Linus Torvalds committed
1176 1177
		local_irq_restore(flags);

1178
		progress_indication = ((stat & SEEK_STAT) == 0) ? 0 : 0x10000;
Linus Torvalds's avatar
Linus Torvalds committed
1179 1180 1181 1182 1183 1184 1185
	}
	if (put_user(progress_indication, arg))
		return (-EFAULT);

	return (0);
}

1186
static sector_t idefloppy_capacity(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
1187 1188 1189 1190 1191 1192 1193 1194
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	unsigned long capacity = floppy->blocks * floppy->bs_factor;

	return capacity;
}

/*
1195 1196
 * Check whether we can support a drive, based on the ATAPI IDENTIFY command
 * results.
Linus Torvalds's avatar
Linus Torvalds committed
1197
 */
1198
static int idefloppy_identify_device(ide_drive_t *drive, struct hd_driveid *id)
Linus Torvalds's avatar
Linus Torvalds committed
1199
{
1200 1201
	u8 gcw[2];
	u8 device_type, protocol, removable, drq_type, packet_size;
Linus Torvalds's avatar
Linus Torvalds committed
1202 1203 1204

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

1205 1206 1207 1208 1209 1210
	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;

Linus Torvalds's avatar
Linus Torvalds committed
1211 1212
#ifdef CONFIG_PPC
	/* kludge for Apple PowerBook internal zip */
1213 1214 1215
	if (device_type == 5 &&
	    !strstr(id->model, "CD-ROM") && strstr(id->model, "ZIP"))
		device_type = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1216 1217
#endif

1218
	if (protocol != 2)
1219
		printk(KERN_ERR "ide-floppy: Protocol (0x%02x) is not ATAPI\n",
1220 1221
			protocol);
	else if (device_type != 0)
1222
		printk(KERN_ERR "ide-floppy: Device type (0x%02x) is not set "
1223 1224
				"to floppy\n", device_type);
	else if (!removable)
Linus Torvalds's avatar
Linus Torvalds committed
1225
		printk(KERN_ERR "ide-floppy: The removable flag is not set\n");
1226
	else if (drq_type == 3)
1227
		printk(KERN_ERR "ide-floppy: Sorry, DRQ type (0x%02x) not "
1228 1229
				"supported\n", drq_type);
	else if (packet_size != 0)
1230
		printk(KERN_ERR "ide-floppy: Packet size (0x%02x) is not 12 "
1231 1232
				"bytes\n", packet_size);
	else
Linus Torvalds's avatar
Linus Torvalds committed
1233 1234 1235 1236
		return 1;
	return 0;
}

1237
#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds's avatar
Linus Torvalds committed
1238 1239 1240 1241
static void idefloppy_add_settings(ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;

1242 1243 1244 1245 1246 1247 1248 1249
	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);
Linus Torvalds's avatar
Linus Torvalds committed
1250
}
1251 1252 1253
#else
static inline void idefloppy_add_settings(ide_drive_t *drive) { ; }
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1254

1255
static void idefloppy_setup(ide_drive_t *drive, idefloppy_floppy_t *floppy)
Linus Torvalds's avatar
Linus Torvalds committed
1256
{
1257
	u8 gcw[2];
Linus Torvalds's avatar
Linus Torvalds committed
1258 1259 1260

	*((u16 *) &gcw) = drive->id->config;
	floppy->pc = floppy->pc_stack;
1261 1262

	if (((gcw[0] & 0x60) >> 5) == 1)
1263
		floppy->flags |= IDEFLOPPY_FLAG_DRQ_INTERRUPT;
Linus Torvalds's avatar
Linus Torvalds committed
1264
	/*
1265 1266
	 * We used to check revisions here. At this point however I'm giving up.
	 * Just assume they are all broken, its easier.
Linus Torvalds's avatar
Linus Torvalds committed
1267
	 *
1268 1269 1270 1271
	 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
1272 1273
	 */
	if (!strncmp(drive->id->model, "IOMEGA ZIP 100 ATAPI", 20)) {
1274
		floppy->flags |= IDEFLOPPY_FLAG_ZIP_DRIVE;
Linus Torvalds's avatar
Linus Torvalds committed
1275 1276 1277 1278 1279 1280
		/* This value will be visible in the /proc/ide/hdx/settings */
		floppy->ticks = IDEFLOPPY_TICKS_DELAY;
		blk_queue_max_sectors(drive->queue, 64);
	}

	/*
1281 1282 1283
	 * Guess what? The IOMEGA Clik! drive also needs the above fix. It makes
	 * nasty clicking noises without it, so please don't remove this.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
1284 1285
	if (strncmp(drive->id->model, "IOMEGA Clik!", 11) == 0) {
		blk_queue_max_sectors(drive->queue, 64);
1286
		floppy->flags |= IDEFLOPPY_FLAG_CLIK_DRIVE;
Linus Torvalds's avatar
Linus Torvalds committed
1287 1288
	}

1289
	(void) ide_floppy_get_capacity(drive);
Linus Torvalds's avatar
Linus Torvalds committed
1290 1291 1292
	idefloppy_add_settings(drive);
}

1293
static void ide_floppy_remove(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
1294 1295 1296 1297
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	struct gendisk *g = floppy->disk;

1298
	ide_proc_unregister_driver(drive, floppy->driver);
Linus Torvalds's avatar
Linus Torvalds committed
1299 1300 1301 1302 1303 1304

	del_gendisk(g);

	ide_floppy_put(floppy);
}

1305
static void idefloppy_cleanup_obj(struct kref *kref)
Linus Torvalds's avatar
Linus Torvalds committed
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
{
	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);
}

1317
#ifdef CONFIG_IDE_PROC_FS
1318 1319
static int proc_idefloppy_read_capacity(char *page, char **start, off_t off,
		int count, int *eof, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
1320 1321 1322 1323
{
	ide_drive_t*drive = (ide_drive_t *)data;
	int len;

1324 1325
	len = sprintf(page, "%llu\n", (long long)idefloppy_capacity(drive));
	PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
Linus Torvalds's avatar
Linus Torvalds committed
1326 1327 1328
}

static ide_proc_entry_t idefloppy_proc[] = {
1329 1330
	{ "capacity",	S_IFREG|S_IRUGO, proc_idefloppy_read_capacity,	NULL },
	{ "geometry",	S_IFREG|S_IRUGO, proc_ide_read_geometry,	NULL },
Linus Torvalds's avatar
Linus Torvalds committed
1331 1332
	{ NULL, 0, NULL, NULL }
};
1333
#endif	/* CONFIG_IDE_PROC_FS */
Linus Torvalds's avatar
Linus Torvalds committed
1334

1335
static int ide_floppy_probe(ide_drive_t *);
Linus Torvalds's avatar
Linus Torvalds committed
1336 1337

static ide_driver_t idefloppy_driver = {
1338
	.gen_driver = {
1339
		.owner		= THIS_MODULE,
1340 1341 1342
		.name		= "ide-floppy",
		.bus		= &ide_bus_type,
	},
1343 1344
	.probe			= ide_floppy_probe,
	.remove			= ide_floppy_remove,
Linus Torvalds's avatar
Linus Torvalds committed
1345 1346 1347 1348
	.version		= IDEFLOPPY_VERSION,
	.media			= ide_floppy,
	.supports_dsc_overlap	= 0,
	.do_request		= idefloppy_do_request,
1349
	.end_request		= idefloppy_end_request,
Linus Torvalds's avatar
Linus Torvalds committed
1350 1351
	.error			= __ide_error,
	.abort			= __ide_abort,
1352
#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds's avatar
Linus Torvalds committed
1353
	.proc			= idefloppy_proc,
1354
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1355 1356 1357 1358 1359 1360 1361
};

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;
1362
	struct ide_atapi_pc pc;
Linus Torvalds's avatar
Linus Torvalds committed
1363 1364
	int ret = 0;

1365
	debug_log("Reached %s\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
1366

1367 1368
	floppy = ide_floppy_get(disk);
	if (!floppy)
Linus Torvalds's avatar
Linus Torvalds committed
1369 1370 1371 1372
		return -ENXIO;

	drive = floppy->drive;

1373
	floppy->openers++;
Linus Torvalds's avatar
Linus Torvalds committed
1374

1375
	if (floppy->openers == 1) {
1376
		floppy->flags &= ~IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS;
Linus Torvalds's avatar
Linus Torvalds committed
1377 1378 1379 1380 1381 1382 1383 1384
		/* Just in case */

		idefloppy_create_test_unit_ready_cmd(&pc);
		if (idefloppy_queue_pc_tail(drive, &pc)) {
			idefloppy_create_start_stop_cmd(&pc, 1);
			(void) idefloppy_queue_pc_tail(drive, &pc);
		}

1385
		if (ide_floppy_get_capacity(drive)
Linus Torvalds's avatar
Linus Torvalds committed
1386 1387
		   && (filp->f_flags & O_NDELAY) == 0
		    /*
1388 1389 1390 1391
		     * 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
		     */
Linus Torvalds's avatar
Linus Torvalds committed
1392 1393 1394 1395 1396 1397 1398 1399 1400
		    ) {
			ret = -EIO;
			goto out_put_floppy;
		}

		if (floppy->wp && (filp->f_mode & 2)) {
			ret = -EROFS;
			goto out_put_floppy;
		}
1401
		floppy->flags |= IDEFLOPPY_FLAG_MEDIA_CHANGED;
Linus Torvalds's avatar
Linus Torvalds committed
1402
		/* IOMEGA Clik! drives do not support lock/unlock commands */
1403
		if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE)) {
Linus Torvalds's avatar
Linus Torvalds committed
1404 1405 1406 1407
			idefloppy_create_prevent_cmd(&pc, 1);
			(void) idefloppy_queue_pc_tail(drive, &pc);
		}
		check_disk_change(inode->i_bdev);
1408
	} else if (floppy->flags & IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS) {
Linus Torvalds's avatar
Linus Torvalds committed
1409 1410 1411 1412 1413 1414
		ret = -EBUSY;
		goto out_put_floppy;
	}
	return 0;

out_put_floppy:
1415
	floppy->openers--;
Linus Torvalds's avatar
Linus Torvalds committed
1416 1417 1418 1419 1420 1421 1422 1423 1424
	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;
1425
	struct ide_atapi_pc pc;
1426 1427

	debug_log("Reached %s\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
1428

1429
	if (floppy->openers == 1) {
Linus Torvalds's avatar
Linus Torvalds committed
1430
		/* IOMEGA Clik! drives do not support lock/unlock commands */
1431
		if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE)) {
Linus Torvalds's avatar
Linus Torvalds committed
1432 1433 1434 1435
			idefloppy_create_prevent_cmd(&pc, 0);
			(void) idefloppy_queue_pc_tail(drive, &pc);
		}

1436
		floppy->flags &= ~IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS;
Linus Torvalds's avatar
Linus Torvalds committed
1437
	}
1438 1439

	floppy->openers--;
Linus Torvalds's avatar
Linus Torvalds committed
1440 1441 1442 1443 1444 1445

	ide_floppy_put(floppy);

	return 0;
}

1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456
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;
}

1457 1458
static int ide_floppy_lockdoor(idefloppy_floppy_t *floppy,
		struct ide_atapi_pc *pc, unsigned long arg, unsigned int cmd)
1459 1460 1461 1462 1463 1464
{
	if (floppy->openers > 1)
		return -EBUSY;

	/* The IOMEGA Clik! Drive doesn't support this command -
	 * no room for an eject mechanism */
1465
	if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE)) {
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486
		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;
1487
	struct ide_atapi_pc pc;
1488 1489 1490

	if (floppy->openers > 1) {
		/* Don't format if someone is using the disk */
1491
		floppy->flags &= ~IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS;
1492 1493 1494
		return -EBUSY;
	}

1495
	floppy->flags |= IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS;
1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526

	/*
	 * 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)
1527
		floppy->flags &= ~IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS;
1528 1529 1530 1531
	return err;
}


Linus Torvalds's avatar
Linus Torvalds committed
1532 1533 1534 1535 1536 1537
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;
1538
	struct ide_atapi_pc pc;
Linus Torvalds's avatar
Linus Torvalds committed
1539
	void __user *argp = (void __user *)arg;
1540
	int err;
Linus Torvalds's avatar
Linus Torvalds committed
1541 1542 1543 1544 1545

	switch (cmd) {
	case CDROMEJECT:
		/* fall through */
	case CDROM_LOCKDOOR:
1546
		return ide_floppy_lockdoor(floppy, &pc, arg, cmd);
Linus Torvalds's avatar
Linus Torvalds committed
1547 1548 1549
	case IDEFLOPPY_IOCTL_FORMAT_SUPPORTED:
		return 0;
	case IDEFLOPPY_IOCTL_FORMAT_GET_CAPACITY:
1550
		return ide_floppy_get_format_capacities(drive, argp);
Linus Torvalds's avatar
Linus Torvalds committed
1551 1552 1553 1554
	case IDEFLOPPY_IOCTL_FORMAT_START:
		if (!(file->f_mode & 2))
			return -EPERM;

1555
		return ide_floppy_format_unit(floppy, (int __user *)arg);
Linus Torvalds's avatar
Linus Torvalds committed
1556 1557 1558
	case IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS:
		return idefloppy_get_format_progress(drive, argp);
	}
1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573

	/*
	 * 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;
Linus Torvalds's avatar
Linus Torvalds committed
1574 1575 1576 1577 1578 1579
}

static int idefloppy_media_changed(struct gendisk *disk)
{
	struct ide_floppy_obj *floppy = ide_floppy_g(disk);
	ide_drive_t *drive = floppy->drive;
1580
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
1581 1582 1583 1584 1585 1586

	/* do not scan partitions twice if this is a removable device */
	if (drive->attach) {
		drive->attach = 0;
		return 0;
	}
1587 1588 1589
	ret = !!(floppy->flags & IDEFLOPPY_FLAG_MEDIA_CHANGED);
	floppy->flags &= ~IDEFLOPPY_FLAG_MEDIA_CHANGED;
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599
}

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 = {
1600 1601 1602 1603 1604 1605 1606
	.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
Linus Torvalds's avatar
Linus Torvalds committed
1607 1608
};

1609
static int ide_floppy_probe(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
{
	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;
1620 1621 1622
	if (!idefloppy_identify_device(drive, drive->id)) {
		printk(KERN_ERR "ide-floppy: %s: not supported by this version"
				" of ide-floppy\n", drive->name);
Linus Torvalds's avatar
Linus Torvalds committed
1623 1624 1625
		goto failed;
	}
	if (drive->scsi) {
1626 1627
		printk(KERN_INFO "ide-floppy: passing drive %s to ide-scsi"
				" emulation.\n", drive->name);
Linus Torvalds's avatar
Linus Torvalds committed
1628 1629
		goto failed;
	}
1630 1631 1632 1633
	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);
Linus Torvalds's avatar
Linus Torvalds committed
1634 1635 1636 1637 1638 1639 1640 1641 1642
		goto failed;
	}

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

	ide_init_disk(g, drive);

1643
	ide_proc_register_driver(drive, &idefloppy_driver);
Linus Torvalds's avatar
Linus Torvalds committed
1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654

	kref_init(&floppy->kref);

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

	g->private_data = &floppy->driver;

	drive->driver_data = floppy;

1655
	idefloppy_setup(drive, floppy);
1656

Linus Torvalds's avatar
Linus Torvalds committed
1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667
	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:
1668
	return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
1669 1670
}

1671
static void __exit idefloppy_exit(void)
Linus Torvalds's avatar
Linus Torvalds committed
1672
{
1673
	driver_unregister(&idefloppy_driver.gen_driver);
Linus Torvalds's avatar
Linus Torvalds committed
1674 1675
}

1676
static int __init idefloppy_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
1677 1678
{
	printk("ide-floppy driver " IDEFLOPPY_VERSION "\n");
1679
	return driver_register(&idefloppy_driver.gen_driver);
Linus Torvalds's avatar
Linus Torvalds committed
1680 1681
}

1682
MODULE_ALIAS("ide:*m-floppy*");
Linus Torvalds's avatar
Linus Torvalds committed
1683 1684 1685
module_init(idefloppy_init);
module_exit(idefloppy_exit);
MODULE_LICENSE("GPL");
1686 1687
MODULE_DESCRIPTION("ATAPI FLOPPY Driver");