ide-floppy.c 64.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
/*
 * linux/drivers/ide/ide-floppy.c	Version 0.99	Feb 24 2002
 *
 * Copyright (C) 1996 - 1999 Gadi Oxman <gadio@netvision.net.il>
 * Copyright (C) 2000 - 2002 Paul Bristow <paul@paulbristow.net>
 */

/*
 * IDE ATAPI floppy driver.
 *
 * The driver currently doesn't have any fancy features, just the bare
 * minimum read/write support.
 *
 * This driver supports the following IDE floppy drives:
 *
 * LS-120/240 SuperDisk
 * Iomega Zip 100/250
 * Iomega PC Card Clik!/PocketZip
 *
 * Many thanks to Lode Leroy <Lode.Leroy@www.ibase.be>, who tested so many
 * ALPHA patches to this driver on an EASYSTOR LS-120 ATAPI floppy drive.
 *
 * Ver 0.1   Oct 17 96   Initial test version, mostly based on ide-tape.c.
 * Ver 0.2   Oct 31 96   Minor changes.
 * Ver 0.3   Dec  2 96   Fixed error recovery bug.
 * Ver 0.4   Jan 26 97   Add support for the HDIO_GETGEO ioctl.
 * Ver 0.5   Feb 21 97   Add partitions support.
 *                       Use the minimum of the LBA and CHS capacities.
 *                       Avoid hwgroup->rq == NULL on the last irq.
 *                       Fix potential null dereferencing with DEBUG_LOG.
 * Ver 0.8   Dec  7 97   Increase irq timeout from 10 to 50 seconds.
 *                       Add media write-protect detection.
 *                       Issue START command only if TEST UNIT READY fails.
 *                       Add work-around for IOMEGA ZIP revision 21.D.
 *                       Remove idefloppy_get_capabilities().
 * Ver 0.9   Jul  4 99   Fix a bug which might have caused the number of
 *                        bytes requested on each interrupt to be zero.
 *                        Thanks to <shanos@es.co.nz> for pointing this out.
 * Ver 0.9.sv Jan 6 01   Sam Varshavchik <mrsam@courier-mta.com>
 *                       Implement low level formatting.  Reimplemented
 *                       IDEFLOPPY_CAPABILITIES_PAGE, since we need the srfp
 *                       bit.  My LS-120 drive barfs on
 *                       IDEFLOPPY_CAPABILITIES_PAGE, but maybe it's just me.
 *                       Compromise by not reporting a failure to get this
 *                       mode page.  Implemented four IOCTLs in order to
 *                       implement formatting.  IOCTls begin with 0x4600,
 *                       0x46 is 'F' as in Format.
 *            Jan 9 01   Userland option to select format verify.
 *                       Added PC_SUPPRESS_ERROR flag - some idefloppy drives
 *                       do not implement IDEFLOPPY_CAPABILITIES_PAGE, and
 *                       return a sense error.  Suppress error reporting in
 *                       this particular case in order to avoid spurious
 *                       errors in syslog.  The culprit is
 *                       idefloppy_get_capability_page(), so move it to
 *                       idefloppy_begin_format() so that it's not used
 *                       unless absolutely necessary.
 *                       If drive does not support format progress indication
 *                       monitor the dsc bit in the status register.
 *                       Also, O_NDELAY on open will allow the device to be
 *                       opened without a disk available.  This can be used to
 *                       open an unformatted disk, or get the device capacity.
 * Ver 0.91  Dec 11 99   Added IOMEGA Clik! drive support by 
 *     		   <paul@paulbristow.net>
 * Ver 0.92  Oct 22 00   Paul Bristow became official maintainer for this 
 *           		   driver.  Included Powerbook internal zip kludge.
 * Ver 0.93  Oct 24 00   Fixed bugs for Clik! drive
 *                        no disk on insert and disk change now works
 * Ver 0.94  Oct 27 00   Tidied up to remove strstr(Clik) everywhere
 * Ver 0.95  Nov  7 00   Brought across to kernel 2.4
 * Ver 0.96  Jan  7 01   Actually in line with release version of 2.4.0
 *                       including set_bit patch from Rusty Russell
 * Ver 0.97  Jul 22 01   Merge 0.91-0.96 onto 0.9.sv for ac series
 * Ver 0.97.sv Aug 3 01  Backported from 2.4.7-ac3
 * Ver 0.98  Oct 26 01   Split idefloppy_transfer_pc into two pieces to
 *                        fix a lost interrupt problem. It appears the busy
 *                        bit was being deasserted by my IOMEGA ATAPI ZIP 100
 *                        drive before the drive was actually ready.
 * Ver 0.98a Oct 29 01   Expose delay value so we can play.
 * Ver 0.99  Feb 24 02   Remove duplicate code, modify clik! detection code 
 *                        to support new PocketZip drives 
 */

#define IDEFLOPPY_VERSION "0.99.newide"

#include <linux/config.h>
#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 <asm/byteorder.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/unaligned.h>
#include <asm/bitops.h>

/*
 *	The following are used to debug the driver.
 */
#define IDEFLOPPY_DEBUG_LOG		0
#define IDEFLOPPY_DEBUG_INFO		0
#define IDEFLOPPY_DEBUG_BUGS		1

/* #define IDEFLOPPY_DEBUG(fmt, args...) printk(KERN_INFO fmt, ## args) */
#define IDEFLOPPY_DEBUG( fmt, args... )


/*
 *	Some drives require a longer irq timeout.
 */
#define IDEFLOPPY_WAIT_CMD		(5 * WAIT_CMD)

/*
 *	After each failed packet command we issue a request sense command
 *	and retry the packet command IDEFLOPPY_MAX_PC_RETRIES times.
 */
#define IDEFLOPPY_MAX_PC_RETRIES	3

/*
 *	With each packet command, we allocate a buffer of
 *	IDEFLOPPY_PC_BUFFER_SIZE bytes.
 */
#define IDEFLOPPY_PC_BUFFER_SIZE	256

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

/*
 *	Our view of a packet command.
 */
typedef struct idefloppy_packet_command_s {
	u8 c[12];				/* Actual packet bytes */
	int retries;				/* On each retry, we increment retries */
	int error;				/* Error code */
	int request_transfer;			/* Bytes to transfer */
	int actually_transferred;		/* Bytes actually transferred */
	int buffer_size;			/* Size of our data buffer */
	char *b_data;				/* Pointer which runs on the buffers */
	int b_count;				/* Missing/Available data on the current buffer */
	struct request *rq;			/* The corresponding request */
Jens Axboe's avatar
Jens Axboe committed
156 157
	u8 *buffer;				/* Data buffer */
	u8 *current_position;			/* Pointer into the above buffer */
158
	void (*callback) (ide_drive_t *);	/* Called when this packet command is completed */
Jens Axboe's avatar
Jens Axboe committed
159
	u8 pc_buffer[IDEFLOPPY_PC_BUFFER_SIZE];	/* Temporary buffer */
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
	unsigned long flags;			/* Status/Action bit flags: long for set_bit */
} idefloppy_pc_t;

/*
 *	Packet command flag bits.
 */
#define	PC_ABORT			0	/* Set when an error is considered normal - We won't retry */
#define PC_DMA_RECOMMENDED		2	/* 1 when we prefer to use DMA if possible */
#define	PC_DMA_IN_PROGRESS		3	/* 1 while DMA in progress */
#define	PC_DMA_ERROR			4	/* 1 when encountered problem during DMA */
#define	PC_WRITING			5	/* Data direction */

#define	PC_SUPPRESS_ERROR		6	/* Suppress error reporting */

/*
 *	Removable Block Access Capabilities Page
 */
typedef struct {
#if defined(__LITTLE_ENDIAN_BITFIELD)
	unsigned	page_code	:6;	/* Page code - Should be 0x1b */
	unsigned	reserved1_6	:1;	/* Reserved */
	unsigned	ps		:1;	/* Should be 0 */
#elif defined(__BIG_ENDIAN_BITFIELD)
	unsigned	ps		:1;	/* Should be 0 */
	unsigned	reserved1_6	:1;	/* Reserved */
	unsigned	page_code	:6;	/* Page code - Should be 0x1b */
#else
#error "Bitfield endianness not defined! Check your byteorder.h"
#endif
	u8		page_length;		/* Page Length - Should be 0xa */
#if defined(__LITTLE_ENDIAN_BITFIELD)
	unsigned	reserved2	:6;
	unsigned	srfp		:1;	/* Supports reporting progress of format */
	unsigned	sflp		:1;	/* System floppy type device */
	unsigned	tlun		:3;	/* Total logical units supported by the device */
	unsigned	reserved3	:3;
	unsigned	sml		:1;	/* Single / Multiple lun supported */
	unsigned	ncd		:1;	/* Non cd optical device */
#elif defined(__BIG_ENDIAN_BITFIELD)
	unsigned	sflp		:1;	/* System floppy type device */
	unsigned	srfp		:1;	/* Supports reporting progress of format */
	unsigned	reserved2	:6;
	unsigned	ncd		:1;	/* Non cd optical device */
	unsigned	sml		:1;	/* Single / Multiple lun supported */
	unsigned	reserved3	:3;
	unsigned	tlun		:3;	/* Total logical units supported by the device */
#else
#error "Bitfield endianness not defined! Check your byteorder.h"
#endif
	u8		reserved[8];
} idefloppy_capabilities_page_t;

/*
 *	Flexible disk page.
 */
typedef struct {
#if defined(__LITTLE_ENDIAN_BITFIELD)
	unsigned	page_code	:6;	/* Page code - Should be 0x5 */
	unsigned	reserved1_6	:1;	/* Reserved */
	unsigned	ps		:1;	/* The device is capable of saving the page */
#elif defined(__BIG_ENDIAN_BITFIELD)
	unsigned	ps		:1;	/* The device is capable of saving the page */
	unsigned	reserved1_6	:1;	/* Reserved */
	unsigned	page_code	:6;	/* Page code - Should be 0x5 */
#else
#error "Bitfield endianness not defined! Check your byteorder.h"
#endif
	u8		page_length;		/* Page Length - Should be 0x1e */
	u16		transfer_rate;		/* In kilobits per second */
	u8		heads, sectors;		/* Number of heads, Number of sectors per track */
	u16		sector_size;		/* Byes per sector */
	u16		cyls;			/* Number of cylinders */
	u8		reserved10[10];
	u8		motor_delay;		/* Motor off delay */
	u8		reserved21[7];
	u16		rpm;			/* Rotations per minute */
	u8		reserved30[2];
} idefloppy_flexible_disk_page_t;
 
/*
 *	Format capacity
 */
typedef struct {
	u8		reserved[3];
	u8		length;			/* Length of the following descriptors in bytes */
} idefloppy_capacity_header_t;

typedef struct {
	u32		blocks;			/* Number of blocks */
#if defined(__LITTLE_ENDIAN_BITFIELD)
	unsigned	dc		:2;	/* Descriptor Code */
	unsigned	reserved	:6;
#elif defined(__BIG_ENDIAN_BITFIELD)
	unsigned	reserved	:6;
	unsigned	dc		:2;	/* Descriptor Code */
#else
#error "Bitfield endianness not defined! Check your byteorder.h"
#endif
	u8		length_msb;		/* Block Length (MSB)*/
	u16		length;			/* Block Length */
} idefloppy_capacity_descriptor_t;

#define CAPACITY_INVALID	0x00
#define CAPACITY_UNFORMATTED	0x01
#define CAPACITY_CURRENT	0x02
#define CAPACITY_NO_CARTRIDGE	0x03

/*
 *	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.
 */
typedef struct {
	ide_drive_t *drive;

Jens Axboe's avatar
Jens Axboe committed
275 276 277 278 279 280 281 282
	/* Current packet command */
	idefloppy_pc_t *pc;
	/* Last failed packet command */
	idefloppy_pc_t *failed_pc;
	/* Packet command stack */
	idefloppy_pc_t pc_stack[IDEFLOPPY_PC_STACK];
	/* Next free packet command storage space */
	int pc_stack_index;
283
	struct request rq_stack[IDEFLOPPY_PC_STACK];
Jens Axboe's avatar
Jens Axboe committed
284 285
	/* We implement a circular array */
	int rq_stack_index;
286 287 288 289

	/*
	 *	Last error information
	 */
Jens Axboe's avatar
Jens Axboe committed
290 291 292
	u8 sense_key, asc, ascq;
	/* delay this long before sending packet command */
	u8 ticks;
293 294 295 296 297
	int progress_indication;

	/*
	 *	Device information
	 */
Jens Axboe's avatar
Jens Axboe committed
298 299 300 301 302 303 304 305 306 307 308 309
	/* Current format */
	int blocks, block_size, bs_factor;
	/* Last format capacity */
	idefloppy_capacity_descriptor_t capacity;
	/* Copy of the flexible disk page */
	idefloppy_flexible_disk_page_t flexible_disk_page;
	/* Write protect */
	int wp;
	/* Supports format progress report */
	int srfp;
	/* Status/Action flags */
	unsigned long flags;
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
} idefloppy_floppy_t;

#define IDEFLOPPY_TICKS_DELAY	3	/* default delay for ZIP 100 */

/*
 *	Floppy flag bits values.
 */
#define IDEFLOPPY_DRQ_INTERRUPT		0	/* DRQ interrupt device */
#define IDEFLOPPY_MEDIA_CHANGED		1	/* Media may have changed */
#define IDEFLOPPY_USE_READ12		2	/* Use READ12/WRITE12 or READ10/WRITE10 */
#define	IDEFLOPPY_FORMAT_IN_PROGRESS	3	/* Format in progress */
#define IDEFLOPPY_CLIK_DRIVE	        4       /* Avoid commands not supported in Clik drive */
#define IDEFLOPPY_ZIP_DRIVE		5	/* Requires BH algorithm for packets */

/*
 *	ATAPI floppy drive packet commands
 */
#define IDEFLOPPY_FORMAT_UNIT_CMD	0x04
#define IDEFLOPPY_INQUIRY_CMD		0x12
#define IDEFLOPPY_MODE_SELECT_CMD	0x55
#define IDEFLOPPY_MODE_SENSE_CMD	0x5a
#define IDEFLOPPY_READ10_CMD		0x28
#define IDEFLOPPY_READ12_CMD		0xa8
#define IDEFLOPPY_READ_CAPACITY_CMD	0x23
#define IDEFLOPPY_REQUEST_SENSE_CMD	0x03
#define IDEFLOPPY_PREVENT_REMOVAL_CMD	0x1e
#define IDEFLOPPY_SEEK_CMD		0x2b
#define IDEFLOPPY_START_STOP_CMD	0x1b
#define IDEFLOPPY_TEST_UNIT_READY_CMD	0x00
#define IDEFLOPPY_VERIFY_CMD		0x2f
#define IDEFLOPPY_WRITE10_CMD		0x2a
#define IDEFLOPPY_WRITE12_CMD		0xaa
#define IDEFLOPPY_WRITE_VERIFY_CMD	0x2e

/*
 *	Defines for the mode sense command
 */
#define MODE_SENSE_CURRENT		0x00
#define MODE_SENSE_CHANGEABLE		0x01
#define MODE_SENSE_DEFAULT		0x02 
#define MODE_SENSE_SAVED		0x03

/*
 *	IOCTLs used in low-level formatting.
 */

#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

#if 0
/*
 *	Special requests for our block device strategy routine.
 */
Jens Axboe's avatar
Jens Axboe committed
365
#define	IDEFLOPPY_FIRST_RQ	90
366 367 368 369

/*
 * 	IDEFLOPPY_PC_RQ is used to queue a packet command in the request queue.
 */
Jens Axboe's avatar
Jens Axboe committed
370
#define	IDEFLOPPY_PC_RQ		90
371

Jens Axboe's avatar
Jens Axboe committed
372
#define IDEFLOPPY_LAST_RQ	90
373 374 375 376 377

/*
 *	A macro which can be used to check if a given request command
 *	originated in the driver or in the buffer cache layer.
 */
Jens Axboe's avatar
Jens Axboe committed
378
#define IDEFLOPPY_RQ_CMD(cmd) 	((cmd >= IDEFLOPPY_FIRST_RQ) && (cmd <= IDEFLOPPY_LAST_RQ))
379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521

#endif

/*
 *	Error codes which are returned in rq->errors to the higher part
 *	of the driver.
 */
#define	IDEFLOPPY_ERROR_GENERAL		101

/*
 *	The following is used to format the general configuration word of
 *	the ATAPI IDENTIFY DEVICE command.
 */
struct idefloppy_id_gcw {	
#if defined(__LITTLE_ENDIAN_BITFIELD)
	unsigned packet_size		:2;	/* Packet Size */
	unsigned reserved234		:3;	/* Reserved */
	unsigned drq_type		:2;	/* Command packet DRQ type */
	unsigned removable		:1;	/* Removable media */
	unsigned device_type		:5;	/* Device type */
	unsigned reserved13		:1;	/* Reserved */
	unsigned protocol		:2;	/* Protocol type */
#elif defined(__BIG_ENDIAN_BITFIELD)
	unsigned protocol		:2;	/* Protocol type */
	unsigned reserved13		:1;	/* Reserved */
	unsigned device_type		:5;	/* Device type */
	unsigned removable		:1;	/* Removable media */
	unsigned drq_type		:2;	/* Command packet DRQ type */
	unsigned reserved234		:3;	/* Reserved */
	unsigned packet_size		:2;	/* Packet Size */
#else
#error "Bitfield endianness not defined! Check your byteorder.h"
#endif
};

/*
 *	INQUIRY packet command - Data Format
 */
typedef struct {
#if defined(__LITTLE_ENDIAN_BITFIELD)
	unsigned	device_type	:5;	/* Peripheral Device Type */
	unsigned	reserved0_765	:3;	/* Peripheral Qualifier - Reserved */
	unsigned	reserved1_6t0	:7;	/* Reserved */
	unsigned	rmb		:1;	/* Removable Medium Bit */
	unsigned	ansi_version	:3;	/* ANSI Version */
	unsigned	ecma_version	:3;	/* ECMA Version */
	unsigned	iso_version	:2;	/* ISO Version */
	unsigned	response_format :4;	/* Response Data Format */
	unsigned	reserved3_45	:2;	/* Reserved */
	unsigned	reserved3_6	:1;	/* TrmIOP - Reserved */
	unsigned	reserved3_7	:1;	/* AENC - Reserved */
#elif defined(__BIG_ENDIAN_BITFIELD)
	unsigned	reserved0_765	:3;	/* Peripheral Qualifier - Reserved */
	unsigned	device_type	:5;	/* Peripheral Device Type */
	unsigned	rmb		:1;	/* Removable Medium Bit */
	unsigned	reserved1_6t0	:7;	/* Reserved */
	unsigned	iso_version	:2;	/* ISO Version */
	unsigned	ecma_version	:3;	/* ECMA Version */
	unsigned	ansi_version	:3;	/* ANSI Version */
	unsigned	reserved3_7	:1;	/* AENC - Reserved */
	unsigned	reserved3_6	:1;	/* TrmIOP - Reserved */
	unsigned	reserved3_45	:2;	/* Reserved */
	unsigned	response_format :4;	/* Response Data Format */
#else
#error "Bitfield endianness not defined! Check your byteorder.h"
#endif
	u8		additional_length;	/* Additional Length (total_length-4) */
	u8		rsv5, rsv6, rsv7;	/* Reserved */
	u8		vendor_id[8];		/* Vendor Identification */
	u8		product_id[16];		/* Product Identification */
	u8		revision_level[4];	/* Revision Level */
	u8		vendor_specific[20];	/* Vendor Specific - Optional */
	u8		reserved56t95[40];	/* Reserved - Optional */
						/* Additional information may be returned */
} idefloppy_inquiry_result_t;

/*
 *	REQUEST SENSE packet command result - Data Format.
 */
typedef struct {
#if defined(__LITTLE_ENDIAN_BITFIELD)
	unsigned	error_code	:7;	/* Current error (0x70) */
	unsigned	valid		:1;	/* The information field conforms to SFF-8070i */
	u8		reserved1	:8;	/* Reserved */
	unsigned	sense_key	:4;	/* Sense Key */
	unsigned	reserved2_4	:1;	/* Reserved */
	unsigned	ili		:1;	/* Incorrect Length Indicator */
	unsigned	reserved2_67	:2;
#elif defined(__BIG_ENDIAN_BITFIELD)
	unsigned	valid		:1;	/* The information field conforms to SFF-8070i */
	unsigned	error_code	:7;	/* Current error (0x70) */
	u8		reserved1	:8;	/* Reserved */
	unsigned	reserved2_67	:2;
	unsigned	ili		:1;	/* Incorrect Length Indicator */
	unsigned	reserved2_4	:1;	/* Reserved */
	unsigned	sense_key	:4;	/* Sense Key */
#else
#error "Bitfield endianness not defined! Check your byteorder.h"
#endif
	u32		information __attribute__ ((packed));
	u8		asl;			/* Additional sense length (n-7) */
	u32		command_specific;	/* Additional command specific information */
	u8		asc;			/* Additional Sense Code */
	u8		ascq;			/* Additional Sense Code Qualifier */
	u8		replaceable_unit_code;	/* Field Replaceable Unit Code */
	u8		sksv[3];
	u8		pad[2];			/* Padding to 20 bytes */
} idefloppy_request_sense_result_t;

/*
 *	Pages of the SELECT SENSE / MODE SENSE packet commands.
 */
#define	IDEFLOPPY_CAPABILITIES_PAGE	0x1b
#define IDEFLOPPY_FLEXIBLE_DISK_PAGE	0x05

/*
 *	Mode Parameter Header for the MODE SENSE packet command
 */
typedef struct {
	u16		mode_data_length;	/* Length of the following data transfer */
	u8		medium_type;		/* Medium Type */
#if defined(__LITTLE_ENDIAN_BITFIELD)
	unsigned	reserved3	:7;
	unsigned	wp		:1;	/* Write protect */
#elif defined(__BIG_ENDIAN_BITFIELD)
	unsigned	wp		:1;	/* Write protect */
	unsigned	reserved3	:7;
#else
#error "Bitfield endianness not defined! Check your byteorder.h"
#endif
	u8		reserved[4];
} idefloppy_mode_parameter_header_t;

#define IDEFLOPPY_MIN(a,b)	((a)<(b) ? (a):(b))
#define	IDEFLOPPY_MAX(a,b)	((a)>(b) ? (a):(b))

/*
 *	Too bad. The drive wants to send us data which we are not ready to accept.
 *	Just throw it away.
 */
static void idefloppy_discard_data (ide_drive_t *drive, unsigned int bcount)
{
	while (bcount--)
Jens Axboe's avatar
Jens Axboe committed
522
		(void) HWIF(drive)->INB(IDE_DATA_REG);
523 524 525 526 527 528
}

#if IDEFLOPPY_DEBUG_BUGS
static void idefloppy_write_zeros (ide_drive_t *drive, unsigned int bcount)
{
	while (bcount--)
Jens Axboe's avatar
Jens Axboe committed
529
		HWIF(drive)->OUTB(0, IDE_DATA_REG);
530 531 532 533 534 535 536 537 538 539
}
#endif /* IDEFLOPPY_DEBUG_BUGS */


/*
 *	idefloppy_do_end_request is used to finish servicing a request.
 *
 *	For read/write requests, we will call ide_end_request to pass to the
 *	next buffer.
 */
Jens Axboe's avatar
Jens Axboe committed
540
static int idefloppy_do_end_request(ide_drive_t *drive, int uptodate, int nsecs)
541 542 543 544 545 546
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	struct request *rq = HWGROUP(drive)->rq;
	int error;

#if IDEFLOPPY_DEBUG_LOG
Jens Axboe's avatar
Jens Axboe committed
547
	printk(KERN_INFO "Reached idefloppy_end_request\n");
548 549 550 551 552 553 554 555 556 557 558 559 560 561
#endif /* IDEFLOPPY_DEBUG_LOG */

	switch (uptodate) {
		case 0: error = IDEFLOPPY_ERROR_GENERAL; break;
		case 1: error = 0; break;
		default: error = uptodate;
	}
	if (error)
		floppy->failed_pc = NULL;
	/* Why does this happen? */
	if (!rq)
		return 0;
	if (!(rq->flags & REQ_SPECIAL)) { //if (!IDEFLOPPY_RQ_CMD (rq->cmd)) {
		/* our real local end request function */
Jens Axboe's avatar
Jens Axboe committed
562
		ide_end_request(drive, uptodate, nsecs);
563 564 565 566
		return 0;
	}
	rq->errors = error;
	/* fixme: need to move this local also */
Jens Axboe's avatar
Jens Axboe committed
567
	ide_end_drive_cmd(drive, 0, 0);
568 569 570 571 572 573 574 575 576 577 578 579 580
	return 0;
}

static void idefloppy_input_buffers (ide_drive_t *drive, idefloppy_pc_t *pc, unsigned int bcount)
{
	struct request *rq = pc->rq;
	struct bio *bio = rq->bio;
	int count;

	while (bcount) {
		if (pc->b_count == bio->bi_size) {
			rq->sector += rq->current_nr_sectors;
			rq->nr_sectors -= rq->current_nr_sectors;
Jens Axboe's avatar
Jens Axboe committed
581
			idefloppy_do_end_request(drive, 1, 0);
582 583 584 585
			if ((bio = rq->bio) != NULL)
				pc->b_count = 0;
		}
		if (bio == NULL) {
Jens Axboe's avatar
Jens Axboe committed
586 587 588
			printk(KERN_ERR "%s: bio == NULL in "
				"idefloppy_input_buffers, bcount == %d\n",
				drive->name, bcount);
589 590 591 592 593
			idefloppy_discard_data(drive, bcount);
			return;
		}
		count = IDEFLOPPY_MIN(bio->bi_size - pc->b_count, bcount);
		atapi_input_bytes(drive, bio_data(bio) + pc->b_count, count);
Jens Axboe's avatar
Jens Axboe committed
594 595
		bcount -= count;
		pc->b_count += count;
596 597 598 599 600 601 602 603 604 605 606 607 608
	}
}

static void idefloppy_output_buffers (ide_drive_t *drive, idefloppy_pc_t *pc, unsigned int bcount)
{
	struct request *rq = pc->rq;
	struct bio *bio = rq->bio;
	int count;
	
	while (bcount) {
		if (!pc->b_count) {
			rq->sector += rq->current_nr_sectors;
			rq->nr_sectors -= rq->current_nr_sectors;
Jens Axboe's avatar
Jens Axboe committed
609
			idefloppy_do_end_request(drive, 1, 0);
610 611 612 613 614 615
			if ((bio = rq->bio) != NULL) {
				pc->b_data = bio_data(bio);
				pc->b_count = bio->bi_size;
			}
		}
		if (bio == NULL) {
Jens Axboe's avatar
Jens Axboe committed
616 617 618 619
			printk(KERN_ERR "%s: bio == NULL in "
				"idefloppy_output_buffers, bcount == %d\n",
				drive->name, bcount);
			idefloppy_write_zeros(drive, bcount);
620 621
			return;
		}
Jens Axboe's avatar
Jens Axboe committed
622 623 624 625 626
		count = IDEFLOPPY_MIN(pc->b_count, bcount);
		atapi_output_bytes(drive, pc->b_data, count);
		bcount -= count;
		pc->b_data += count;
		pc->b_count -= count;
627 628 629 630 631 632 633 634 635 636
	}
}

#ifdef CONFIG_BLK_DEV_IDEDMA
static void idefloppy_update_buffers (ide_drive_t *drive, idefloppy_pc_t *pc)
{
	struct request *rq = pc->rq;
	struct bio *bio = rq->bio;

	while ((bio = rq->bio) != NULL)
Jens Axboe's avatar
Jens Axboe committed
637
		idefloppy_do_end_request(drive, 1, 0);
638 639 640 641 642 643 644 645 646 647
}
#endif /* CONFIG_BLK_DEV_IDEDMA */

/*
 *	idefloppy_queue_pc_head generates 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.
 */
static void idefloppy_queue_pc_head (ide_drive_t *drive,idefloppy_pc_t *pc,struct request *rq)
{
Jens Axboe's avatar
Jens Axboe committed
648
	ide_init_drive_cmd(rq);
649 650
	rq->buffer = (char *) pc;
	rq->flags = REQ_SPECIAL;	//rq->cmd = IDEFLOPPY_PC_RQ;
Jens Axboe's avatar
Jens Axboe committed
651
	(void) ide_do_drive_cmd(drive, rq, ide_preempt);
652 653 654 655 656 657
}

static idefloppy_pc_t *idefloppy_next_pc_storage (ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;

Jens Axboe's avatar
Jens Axboe committed
658
	if (floppy->pc_stack_index == IDEFLOPPY_PC_STACK)
659 660 661 662 663 664 665 666
		floppy->pc_stack_index=0;
	return (&floppy->pc_stack[floppy->pc_stack_index++]);
}

static struct request *idefloppy_next_rq_storage (ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;

Jens Axboe's avatar
Jens Axboe committed
667 668
	if (floppy->rq_stack_index == IDEFLOPPY_PC_STACK)
		floppy->rq_stack_index = 0;
669 670 671 672 673 674 675 676 677 678 679
	return (&floppy->rq_stack[floppy->rq_stack_index++]);
}

/*
 *	idefloppy_analyze_error is called on each failed packet command retry
 *	to analyze the request sense.
 */
static void idefloppy_analyze_error (ide_drive_t *drive,idefloppy_request_sense_result_t *result)
{
	idefloppy_floppy_t *floppy = drive->driver_data;

Jens Axboe's avatar
Jens Axboe committed
680 681 682 683 684
	floppy->sense_key = result->sense_key;
	floppy->asc = result->asc;
	floppy->ascq = result->ascq;
	floppy->progress_indication = result->sksv[0] & 0x80 ?
		(u16)get_unaligned((u16 *)(result->sksv+1)):0x10000;
685 686
#if IDEFLOPPY_DEBUG_LOG
	if (floppy->failed_pc)
Jens Axboe's avatar
Jens Axboe committed
687 688 689
		printk(KERN_INFO "ide-floppy: pc = %x, sense key = %x, "
			"asc = %x, ascq = %x\n", floppy->failed_pc->c[0],
			result->sense_key, result->asc, result->ascq);
690
	else
Jens Axboe's avatar
Jens Axboe committed
691 692 693
		printk(KERN_INFO "ide-floppy: sense key = %x, asc = %x, "
			"ascq = %x\n", result->sense_key,
			result->asc, result->ascq);
694 695 696 697 698 699 700 701
#endif /* IDEFLOPPY_DEBUG_LOG */
}

static void idefloppy_request_sense_callback (ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;

#if IDEFLOPPY_DEBUG_LOG
Jens Axboe's avatar
Jens Axboe committed
702
	printk(KERN_INFO "ide-floppy: Reached %s\n", __FUNCTION__);
703 704
#endif /* IDEFLOPPY_DEBUG_LOG */
	if (!floppy->pc->error) {
Jens Axboe's avatar
Jens Axboe committed
705 706
		idefloppy_analyze_error(drive,(idefloppy_request_sense_result_t *) floppy->pc->buffer);
		idefloppy_do_end_request(drive, 1, 0);
707
	} else {
Jens Axboe's avatar
Jens Axboe committed
708 709
		printk(KERN_ERR "Error in REQUEST SENSE itself - Aborting request!\n");
		idefloppy_do_end_request(drive, 0, 0);
710 711 712 713 714 715 716 717 718 719 720
	}
}

/*
 *	General packet command callback function.
 */
static void idefloppy_pc_callback (ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	
#if IDEFLOPPY_DEBUG_LOG
Jens Axboe's avatar
Jens Axboe committed
721
	printk (KERN_INFO "ide-floppy: Reached %s\n", __FUNCTION__);
722 723
#endif /* IDEFLOPPY_DEBUG_LOG */

Jens Axboe's avatar
Jens Axboe committed
724
	idefloppy_do_end_request(drive, floppy->pc->error ? 0 : 1, 0);
725 726 727 728 729 730 731
}

/*
 *	idefloppy_init_pc initializes a packet command.
 */
static void idefloppy_init_pc (idefloppy_pc_t *pc)
{
Jens Axboe's avatar
Jens Axboe committed
732
	memset(pc->c, 0, 12);
733 734 735 736 737 738 739 740 741 742 743 744
	pc->retries = 0;
	pc->flags = 0;
	pc->request_transfer = 0;
	pc->buffer = pc->pc_buffer;
	pc->buffer_size = IDEFLOPPY_PC_BUFFER_SIZE;
	pc->b_data = NULL;
//	pc->bio = NULL;
	pc->callback = &idefloppy_pc_callback;
}

static void idefloppy_create_request_sense_cmd (idefloppy_pc_t *pc)
{
Jens Axboe's avatar
Jens Axboe committed
745
	idefloppy_init_pc(pc);	
746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
	pc->c[0] = IDEFLOPPY_REQUEST_SENSE_CMD;
	pc->c[4] = 255;
	pc->request_transfer = 18;
	pc->callback = &idefloppy_request_sense_callback;
}

/*
 *	idefloppy_retry_pc is called when an error was detected during the
 *	last packet command. We queue a request sense packet command in
 *	the head of the request list.
 */
static void idefloppy_retry_pc (ide_drive_t *drive)
{
	idefloppy_pc_t *pc;
	struct request *rq;
Jens Axboe's avatar
Jens Axboe committed
761
	atapi_error_t error;
762

Jens Axboe's avatar
Jens Axboe committed
763 764 765 766 767
	error.all = HWIF(drive)->INB(IDE_ERROR_REG);
	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);
768 769 770 771 772 773 774 775 776
}

/*
 *	idefloppy_pc_intr is the usual interrupt handler which will be called
 *	during a packet command.
 */
static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
Jens Axboe's avatar
Jens Axboe committed
777 778 779 780
	atapi_status_t status;
	atapi_bcount_t bcount;
	atapi_ireason_t ireason;
	idefloppy_pc_t *pc = floppy->pc;
781 782 783 784
	struct request *rq = pc->rq;
	unsigned int temp;

#if IDEFLOPPY_DEBUG_LOG
Jens Axboe's avatar
Jens Axboe committed
785 786
	printk(KERN_INFO "ide-floppy: Reached %s interrupt handler\n",
		__FUNCTION__);
787 788 789
#endif /* IDEFLOPPY_DEBUG_LOG */	

#ifdef CONFIG_BLK_DEV_IDEDMA
Jens Axboe's avatar
Jens Axboe committed
790 791 792
	if (test_bit(PC_DMA_IN_PROGRESS, &pc->flags)) {
		if (HWIF(drive)->ide_dma_end(drive)) {
			set_bit(PC_DMA_ERROR, &pc->flags);
793
		} else {
Jens Axboe's avatar
Jens Axboe committed
794 795
			pc->actually_transferred = pc->request_transfer;
			idefloppy_update_buffers(drive, pc);
796 797 798 799 800 801 802
		}
#if IDEFLOPPY_DEBUG_LOG
		printk (KERN_INFO "ide-floppy: DMA finished\n");
#endif /* IDEFLOPPY_DEBUG_LOG */
	}
#endif /* CONFIG_BLK_DEV_IDEDMA */

Jens Axboe's avatar
Jens Axboe committed
803 804
	/* Clear the interrupt */
	status.all = HWIF(drive)->INB(IDE_STATUS_REG);
805

Jens Axboe's avatar
Jens Axboe committed
806
	if (!status.b.drq) {			/* No more interrupts */
807
#if IDEFLOPPY_DEBUG_LOG
Jens Axboe's avatar
Jens Axboe committed
808 809
		printk(KERN_INFO "Packet command completed, %d bytes "
			"transferred\n", pc->actually_transferred);
810
#endif /* IDEFLOPPY_DEBUG_LOG */
Jens Axboe's avatar
Jens Axboe committed
811
		clear_bit(PC_DMA_IN_PROGRESS, &pc->flags);
812 813 814

		local_irq_enable();

Jens Axboe's avatar
Jens Axboe committed
815 816
		if (status.b.check || test_bit(PC_DMA_ERROR, &pc->flags)) {
			/* Error detected */
817
#if IDEFLOPPY_DEBUG_LOG
Jens Axboe's avatar
Jens Axboe committed
818 819
			printk(KERN_INFO "ide-floppy: %s: I/O error\n",
				drive->name);
820 821 822
#endif /* IDEFLOPPY_DEBUG_LOG */
			rq->errors++;
			if (pc->c[0] == IDEFLOPPY_REQUEST_SENSE_CMD) {
Jens Axboe's avatar
Jens Axboe committed
823 824 825
				printk(KERN_ERR "ide-floppy: I/O error in "
					"request sense command\n");
				return ide_do_reset(drive);
826
			}
Jens Axboe's avatar
Jens Axboe committed
827 828 829 830
			/* Retry operation */
			idefloppy_retry_pc(drive);
			/* queued, but not started */
			return ide_stopped;
831 832 833
		}
		pc->error = 0;
		if (floppy->failed_pc == pc)
Jens Axboe's avatar
Jens Axboe committed
834 835 836
			floppy->failed_pc = NULL;
		/* Command finished - Call the callback function */
		pc->callback(drive);
837 838 839
		return ide_stopped;
	}
#ifdef CONFIG_BLK_DEV_IDEDMA
Jens Axboe's avatar
Jens Axboe committed
840 841 842 843 844
	if (test_and_clear_bit(PC_DMA_IN_PROGRESS, &pc->flags)) {
		printk(KERN_ERR "ide-floppy: The floppy wants to issue "
			"more interrupts in DMA mode\n");
		(void) HWIF(drive)->ide_dma_off(drive);
		return ide_do_reset(drive);
845 846
	}
#endif /* CONFIG_BLK_DEV_IDEDMA */
Jens Axboe's avatar
Jens Axboe committed
847 848 849 850 851
	/* Get the number of bytes to transfer */
	bcount.b.high = HWIF(drive)->INB(IDE_BCOUNTH_REG);
	bcount.b.low = HWIF(drive)->INB(IDE_BCOUNTL_REG);
	/* on this interrupt */
	ireason.all = HWIF(drive)->INB(IDE_IREASON_REG);
852 853

	if (ireason.b.cod) {
Jens Axboe's avatar
Jens Axboe committed
854 855
		printk(KERN_ERR "ide-floppy: CoD != 0 in idefloppy_pc_intr\n");
		return ide_do_reset(drive);
856
	}
Jens Axboe's avatar
Jens Axboe committed
857 858 859 860 861 862 863
	if (ireason.b.io == test_bit(PC_WRITING, &pc->flags)) {
		/* Hopefully, we will never get here */
		printk(KERN_ERR "ide-floppy: We wanted to %s, ",
			ireason.b.io ? "Write":"Read");
		printk(KERN_ERR "but the floppy wants us to %s !\n",
			ireason.b.io ? "Read":"Write");
		return ide_do_reset(drive);
864
	}
Jens Axboe's avatar
Jens Axboe committed
865 866
	if (!test_bit(PC_WRITING, &pc->flags)) {
		/* Reading - Check that we have enough space */
867
		temp = pc->actually_transferred + bcount.all;
Jens Axboe's avatar
Jens Axboe committed
868
		if (temp > pc->request_transfer) {
869
			if (temp > pc->buffer_size) {
Jens Axboe's avatar
Jens Axboe committed
870 871 872 873
				printk(KERN_ERR "ide-floppy: The floppy wants "
					"to send us more data than expected "
					"- discarding data\n");
				idefloppy_discard_data(drive,bcount.all);
874 875
				if (HWGROUP(drive)->handler != NULL)
					BUG();
Jens Axboe's avatar
Jens Axboe committed
876 877 878 879
				ide_set_handler(drive,
						&idefloppy_pc_intr,
						IDEFLOPPY_WAIT_CMD,
						NULL);
880 881 882
				return ide_started;
			}
#if IDEFLOPPY_DEBUG_LOG
Jens Axboe's avatar
Jens Axboe committed
883 884 885
			printk(KERN_NOTICE "ide-floppy: The floppy wants to "
				"send us more data than expected - "
				"allowing transfer\n");
886 887 888
#endif /* IDEFLOPPY_DEBUG_LOG */
		}
	}
Jens Axboe's avatar
Jens Axboe committed
889
	if (test_bit(PC_WRITING, &pc->flags)) {
890
		if (pc->buffer != NULL)
Jens Axboe's avatar
Jens Axboe committed
891 892 893 894
			/* Write the current buffer */
			HWIF(drive)->atapi_output_bytes(drive,
						pc->current_position,
						bcount.all);
895
		else
Jens Axboe's avatar
Jens Axboe committed
896
			idefloppy_output_buffers(drive, pc, bcount.all);
897 898
	} else {
		if (pc->buffer != NULL)
Jens Axboe's avatar
Jens Axboe committed
899 900 901 902
			/* Read the current buffer */
			HWIF(drive)->atapi_input_bytes(drive,
						pc->current_position,
						bcount.all);
903
		else
Jens Axboe's avatar
Jens Axboe committed
904
			idefloppy_input_buffers(drive, pc, bcount.all);
905
	}
Jens Axboe's avatar
Jens Axboe committed
906 907 908
	/* Update the current position */
	pc->actually_transferred += bcount.all;
	pc->current_position += bcount.all;
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924

	if (HWGROUP(drive)->handler != NULL)
		BUG();
	ide_set_handler(drive, &idefloppy_pc_intr, IDEFLOPPY_WAIT_CMD, NULL);		/* And set the interrupt handler again */
	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
 */
static ide_startstop_t idefloppy_transfer_pc (ide_drive_t *drive)
{
	ide_startstop_t startstop;
	idefloppy_floppy_t *floppy = drive->driver_data;
Jens Axboe's avatar
Jens Axboe committed
925
	atapi_ireason_t ireason;
926

Jens Axboe's avatar
Jens Axboe committed
927
	if (ide_wait_stat(&startstop, drive, DRQ_STAT, BUSY_STAT, WAIT_READY)) {
928 929 930 931
		printk(KERN_ERR "ide-floppy: Strange, packet command "
				"initiated yet DRQ isn't asserted\n");
		return startstop;
	}
Jens Axboe's avatar
Jens Axboe committed
932
	ireason.all = HWIF(drive)->INB(IDE_IREASON_REG);
933 934 935
	if (!ireason.b.cod || ireason.b.io) {
		printk(KERN_ERR "ide-floppy: (IO,CoD) != (0,1) while "
				"issuing a packet command\n");
Jens Axboe's avatar
Jens Axboe committed
936
		return ide_do_reset(drive);
937 938 939
	}
	if (HWGROUP(drive)->handler != NULL)
		BUG();
Jens Axboe's avatar
Jens Axboe committed
940 941 942 943
	/* Set the interrupt routine */
	ide_set_handler(drive, &idefloppy_pc_intr, IDEFLOPPY_WAIT_CMD, NULL);
	/* Send the actual packet */
	HWIF(drive)->atapi_output_bytes(drive, floppy->pc->c, 12);
944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963
	return ide_started;
}


/*
 * 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 it's ready to receive a packet. However,
 * we need to delay about 2-3 ticks before issuing the packet or we
 * gets in trouble.
 *
 * 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.
 */
static int idefloppy_transfer_pc2 (ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;

Jens Axboe's avatar
Jens Axboe committed
964 965 966 967
	/* Send the actual packet */
	HWIF(drive)->atapi_output_bytes(drive, floppy->pc->c, 12);
	/* Timeout for the packet command */
	return IDEFLOPPY_WAIT_CMD;
968 969 970 971 972 973
}

static ide_startstop_t idefloppy_transfer_pc1 (ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	ide_startstop_t startstop;
Jens Axboe's avatar
Jens Axboe committed
974
	atapi_ireason_t ireason;
975

Jens Axboe's avatar
Jens Axboe committed
976
	if (ide_wait_stat(&startstop, drive, DRQ_STAT, BUSY_STAT, WAIT_READY)) {
977 978 979 980
		printk(KERN_ERR "ide-floppy: Strange, packet command "
				"initiated yet DRQ isn't asserted\n");
		return startstop;
	}
Jens Axboe's avatar
Jens Axboe committed
981
	ireason.all = HWIF(drive)->INB(IDE_IREASON_REG);
982 983 984
	if (!ireason.b.cod || ireason.b.io) {
		printk(KERN_ERR "ide-floppy: (IO,CoD) != (0,1) "
				"while issuing a packet command\n");
Jens Axboe's avatar
Jens Axboe committed
985
		return ide_do_reset(drive);
986 987
	}
	/* 
Jens Axboe's avatar
Jens Axboe committed
988 989 990 991 992 993
	 * 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.
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
	 */
	if (HWGROUP(drive)->handler != NULL)
		BUG();
	ide_set_handler(drive, 
	  &idefloppy_pc_intr, 		/* service routine for packet command */
	  floppy->ticks,		/* wait this long before "failing" */
	  &idefloppy_transfer_pc2);	/* fail == transfer_pc2 */
	return ide_started;
}

/*
 *	Issue a packet command
 */
static ide_startstop_t idefloppy_issue_pc (ide_drive_t *drive, idefloppy_pc_t *pc)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
Jens Axboe's avatar
Jens Axboe committed
1010 1011
	atapi_feature_t feature;
	atapi_bcount_t bcount;
1012 1013 1014
	ide_handler_t *pkt_xfer_routine;

#if IDEFLOPPY_DEBUG_BUGS
Jens Axboe's avatar
Jens Axboe committed
1015 1016 1017 1018
	if (floppy->pc->c[0] == IDEFLOPPY_REQUEST_SENSE_CMD &&
	    pc->c[0] == IDEFLOPPY_REQUEST_SENSE_CMD) {
		printk(KERN_ERR "ide-floppy: possible ide-floppy.c bug - "
			"Two request sense in serial were issued\n");
1019 1020 1021
	}
#endif /* IDEFLOPPY_DEBUG_BUGS */

Jens Axboe's avatar
Jens Axboe committed
1022 1023 1024 1025 1026
	if (floppy->failed_pc == NULL &&
	    pc->c[0] != IDEFLOPPY_REQUEST_SENSE_CMD)
		floppy->failed_pc = pc;
	/* Set the current packet command */
	floppy->pc = pc;
1027

Jens Axboe's avatar
Jens Axboe committed
1028 1029
	if (pc->retries > IDEFLOPPY_MAX_PC_RETRIES ||
	    test_bit(PC_ABORT, &pc->flags)) {
1030 1031 1032 1033
		/*
		 *	We will "abort" retrying a packet command in case
		 *	a legitimate error code was received.
		 */
Jens Axboe's avatar
Jens Axboe committed
1034 1035
		if (!test_bit(PC_ABORT, &pc->flags)) {
			if (!test_bit(PC_SUPPRESS_ERROR, &pc->flags)) {
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
				printk(KERN_ERR "ide-floppy: %s: I/O error, "
						"pc = %2x, key = %2x, "
						"asc = %2x, ascq = %2x\n",
						drive->name, pc->c[0],
						floppy->sense_key,
						floppy->asc, floppy->ascq);
			}
			/* Giving up */
			pc->error = IDEFLOPPY_ERROR_GENERAL;
		}
Jens Axboe's avatar
Jens Axboe committed
1046
		floppy->failed_pc = NULL;
1047 1048 1049 1050
		pc->callback(drive);
		return ide_stopped;
	}
#if IDEFLOPPY_DEBUG_LOG
Jens Axboe's avatar
Jens Axboe committed
1051
	printk(KERN_INFO "Retry number - %d\n",pc->retries);
1052 1053 1054
#endif /* IDEFLOPPY_DEBUG_LOG */

	pc->retries++;
Jens Axboe's avatar
Jens Axboe committed
1055 1056 1057
	/* We haven't transferred any data yet */
	pc->actually_transferred = 0;
	pc->current_position = pc->buffer;
1058 1059 1060
	bcount.all = min(pc->request_transfer, 63 * 1024);

#ifdef CONFIG_BLK_DEV_IDEDMA
Jens Axboe's avatar
Jens Axboe committed
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
	if (test_and_clear_bit(PC_DMA_ERROR, &pc->flags)) {
		(void) HWIF(drive)->ide_dma_off(drive);
	}
#endif /* CONFIG_BLK_DEV_IDEDMA */
	feature.all = 0;
#ifdef CONFIG_BLK_DEV_IDEDMA
	if (test_bit(PC_DMA_RECOMMENDED, &pc->flags) && drive->using_dma) {
		if (test_bit(PC_WRITING, &pc->flags)) {
			feature.b.dma = !HWIF(drive)->ide_dma_write(drive);
		} else {
			feature.b.dma = !HWIF(drive)->ide_dma_read(drive);
		}
1073 1074 1075 1076
	}
#endif /* CONFIG_BLK_DEV_IDEDMA */

	if (IDE_CONTROL_REG)
Jens Axboe's avatar
Jens Axboe committed
1077 1078 1079 1080 1081 1082
		HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
	/* Use PIO/DMA */
	HWIF(drive)->OUTB(feature.all, IDE_FEATURE_REG);
	HWIF(drive)->OUTB(bcount.b.high, IDE_BCOUNTH_REG);
	HWIF(drive)->OUTB(bcount.b.low, IDE_BCOUNTL_REG);
	HWIF(drive)->OUTB(drive->select.all, IDE_SELECT_REG);
1083 1084

#ifdef CONFIG_BLK_DEV_IDEDMA
Jens Axboe's avatar
Jens Axboe committed
1085 1086 1087
	if (feature.b.dma) {	/* Begin DMA, if necessary */
		set_bit(PC_DMA_IN_PROGRESS, &pc->flags);
		(void) (HWIF(drive)->ide_dma_begin(drive));
1088 1089 1090 1091
	}
#endif /* CONFIG_BLK_DEV_IDEDMA */

	/* Can we transfer the packet when we get the interrupt or wait? */
Jens Axboe's avatar
Jens Axboe committed
1092 1093 1094
	if (test_bit(IDEFLOPPY_ZIP_DRIVE, &floppy->flags)) {
		/* wait */
		pkt_xfer_routine = &idefloppy_transfer_pc1;
1095
	} else {
Jens Axboe's avatar
Jens Axboe committed
1096 1097
		/* immediate */
		pkt_xfer_routine = &idefloppy_transfer_pc;
1098 1099 1100 1101 1102
	}
	
	if (test_bit (IDEFLOPPY_DRQ_INTERRUPT, &floppy->flags)) {
		if (HWGROUP(drive)->handler != NULL)
			BUG();
Jens Axboe's avatar
Jens Axboe committed
1103 1104 1105 1106 1107 1108
		ide_set_handler(drive,
				pkt_xfer_routine,
				IDEFLOPPY_WAIT_CMD,
				NULL);
		/* Issue the packet command */
		HWIF(drive)->OUTB(WIN_PACKETCMD, IDE_COMMAND_REG);
1109 1110
		return ide_started;
	} else {
Jens Axboe's avatar
Jens Axboe committed
1111 1112
		/* Issue the packet command */
		HWIF(drive)->OUTB(WIN_PACKETCMD, IDE_COMMAND_REG);
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
		return (*pkt_xfer_routine) (drive);
	}
}

static void idefloppy_rw_callback (ide_drive_t *drive)
{
#if IDEFLOPPY_DEBUG_LOG	
	printk (KERN_INFO "ide-floppy: Reached idefloppy_rw_callback\n");
#endif /* IDEFLOPPY_DEBUG_LOG */

Jens Axboe's avatar
Jens Axboe committed
1123
	idefloppy_do_end_request(drive, 1, 0);
1124 1125 1126 1127 1128 1129
	return;
}

static void idefloppy_create_prevent_cmd (idefloppy_pc_t *pc, int prevent)
{
#if IDEFLOPPY_DEBUG_LOG
Jens Axboe's avatar
Jens Axboe committed
1130 1131
	printk(KERN_INFO "ide-floppy: creating prevent removal command, "
		"prevent = %d\n", prevent);
1132 1133
#endif /* IDEFLOPPY_DEBUG_LOG */

Jens Axboe's avatar
Jens Axboe committed
1134
	idefloppy_init_pc(pc);
1135 1136 1137 1138 1139 1140
	pc->c[0] = IDEFLOPPY_PREVENT_REMOVAL_CMD;
	pc->c[4] = prevent;
}

static void idefloppy_create_read_capacity_cmd (idefloppy_pc_t *pc)
{
Jens Axboe's avatar
Jens Axboe committed
1141
	idefloppy_init_pc(pc);
1142 1143 1144 1145 1146 1147 1148 1149 1150
	pc->c[0] = IDEFLOPPY_READ_CAPACITY_CMD;
	pc->c[7] = 255;
	pc->c[8] = 255;
	pc->request_transfer = 255;
}

static void idefloppy_create_format_unit_cmd (idefloppy_pc_t *pc, int b, int l,
					      int flags)
{
Jens Axboe's avatar
Jens Axboe committed
1151
	idefloppy_init_pc(pc);
1152 1153 1154 1155 1156
	pc->c[0] = IDEFLOPPY_FORMAT_UNIT_CMD;
	pc->c[1] = 0x17;

	memset(pc->buffer, 0, 12);
	pc->buffer[1] = 0xA2;
Jens Axboe's avatar
Jens Axboe committed
1157
	/* Default format list header, u8 1: FOV/DCRT/IMM bits set */
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171

	if (flags & 1)				/* Verify bit on... */
		pc->buffer[1] ^= 0x20;		/* ... turn off DCRT bit */
	pc->buffer[3] = 8;

	put_unaligned(htonl(b), (unsigned int *)(&pc->buffer[4]));
	put_unaligned(htonl(l), (unsigned int *)(&pc->buffer[8]));
	pc->buffer_size=12;
	set_bit(PC_WRITING, &pc->flags);
}

/*
 *	A mode sense command is used to "sense" floppy parameters.
 */
Jens Axboe's avatar
Jens Axboe committed
1172
static void idefloppy_create_mode_sense_cmd (idefloppy_pc_t *pc, u8 page_code, u8 type)
1173
{
Jens Axboe's avatar
Jens Axboe committed
1174
	u16 length = sizeof(idefloppy_mode_parameter_header_t);
1175
	
Jens Axboe's avatar
Jens Axboe committed
1176
	idefloppy_init_pc(pc);
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188
	pc->c[0] = IDEFLOPPY_MODE_SENSE_CMD;
	pc->c[1] = 0;
	pc->c[2] = page_code + (type << 6);

	switch (page_code) {
		case IDEFLOPPY_CAPABILITIES_PAGE:
			length += 12;
			break;
		case IDEFLOPPY_FLEXIBLE_DISK_PAGE:
			length += 32;
			break;
		default:
Jens Axboe's avatar
Jens Axboe committed
1189 1190
			printk(KERN_ERR "ide-floppy: unsupported page code "
				"in create_mode_sense_cmd\n");
1191
	}
Jens Axboe's avatar
Jens Axboe committed
1192
	put_unaligned(htons(length), (u16 *) &pc->c[7]);
1193 1194 1195 1196 1197
	pc->request_transfer = length;
}

static void idefloppy_create_start_stop_cmd (idefloppy_pc_t *pc, int start)
{
Jens Axboe's avatar
Jens Axboe committed
1198
	idefloppy_init_pc(pc);
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
	pc->c[0] = IDEFLOPPY_START_STOP_CMD;
	pc->c[4] = start;
}

static void idefloppy_create_test_unit_ready_cmd(idefloppy_pc_t *pc)
{
	idefloppy_init_pc(pc);
	pc->c[0] = IDEFLOPPY_TEST_UNIT_READY_CMD;
}

static void idefloppy_create_rw_cmd (idefloppy_floppy_t *floppy, idefloppy_pc_t *pc, struct request *rq, unsigned long sector)
{
	int block = sector / floppy->bs_factor;
	int blocks = rq->nr_sectors / floppy->bs_factor;
	int cmd = rq_data_dir(rq);

#if IDEFLOPPY_DEBUG_LOG
Jens Axboe's avatar
Jens Axboe committed
1216 1217 1218
	printk("create_rw1%d_cmd: block == %d, blocks == %d\n",
		2 * test_bit (IDEFLOPPY_USE_READ12, &floppy->flags),
		block, blocks);
1219 1220
#endif /* IDEFLOPPY_DEBUG_LOG */

Jens Axboe's avatar
Jens Axboe committed
1221 1222
	idefloppy_init_pc(pc);
	if (test_bit(IDEFLOPPY_USE_READ12, &floppy->flags)) {
1223
		pc->c[0] = cmd == READ ? IDEFLOPPY_READ12_CMD : IDEFLOPPY_WRITE12_CMD;
Jens Axboe's avatar
Jens Axboe committed
1224
		put_unaligned(htonl(blocks), (unsigned int *) &pc->c[6]);
1225 1226
	} else {
		pc->c[0] = cmd == READ ? IDEFLOPPY_READ10_CMD : IDEFLOPPY_WRITE10_CMD;
Jens Axboe's avatar
Jens Axboe committed
1227
		put_unaligned(htons(blocks), (unsigned short *) &pc->c[7]);
1228
	}
Jens Axboe's avatar
Jens Axboe committed
1229
	put_unaligned(htonl(block), (unsigned int *) &pc->c[2]);
1230 1231 1232 1233 1234
	pc->callback = &idefloppy_rw_callback;
	pc->rq = rq;
	pc->b_data = rq->buffer;
	pc->b_count = cmd == READ ? 0 : rq->bio->bi_size;
	if (rq->flags & REQ_RW)
Jens Axboe's avatar
Jens Axboe committed
1235
		set_bit(PC_WRITING, &pc->flags);
1236 1237
	pc->buffer = NULL;
	pc->request_transfer = pc->buffer_size = blocks * floppy->block_size;
Jens Axboe's avatar
Jens Axboe committed
1238
	set_bit(PC_DMA_RECOMMENDED, &pc->flags);
1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
}

/*
 *	idefloppy_do_request is our request handling function.	
 */
static ide_startstop_t idefloppy_do_request (ide_drive_t *drive, struct request *rq, unsigned long block)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	idefloppy_pc_t *pc;

#if IDEFLOPPY_DEBUG_LOG
	printk(KERN_INFO "rq_status: %d, rq_dev: %u, flags: %lx, errors: %d\n",
			rq->rq_status, (unsigned int) rq->rq_dev,
			rq->flags, rq->errors);
	printk(KERN_INFO "sector: %ld, nr_sectors: %ld, "
			"current_nr_sectors: %ld\n", rq->sector,
			rq->nr_sectors, rq->current_nr_sectors);
#endif /* IDEFLOPPY_DEBUG_LOG */

	if (rq->errors >= ERROR_MAX) {
		if (floppy->failed_pc != NULL)
			printk(KERN_ERR "ide-floppy: %s: I/O error, pc = %2x,"
					" key = %2x, asc = %2x, ascq = %2x\n",
				drive->name, floppy->failed_pc->c[0],
				floppy->sense_key, floppy->asc, floppy->ascq);
		else
			printk(KERN_ERR "ide-floppy: %s: I/O error\n",
				drive->name);
Jens Axboe's avatar
Jens Axboe committed
1267
		idefloppy_do_end_request(drive, 0, 0);
1268 1269 1270 1271 1272 1273 1274
		return ide_stopped;
	}
	if (rq->flags & REQ_CMD) {
		if ((rq->sector % floppy->bs_factor) ||
		    (rq->nr_sectors % floppy->bs_factor)) {
			printk("%s: unsupported r/w request size\n",
				drive->name);
Jens Axboe's avatar
Jens Axboe committed
1275
			idefloppy_do_end_request(drive, 0, 0);
1276 1277
			return ide_stopped;
		}
Jens Axboe's avatar
Jens Axboe committed
1278 1279
		pc = idefloppy_next_pc_storage(drive);
		idefloppy_create_rw_cmd(floppy, pc, rq, block);
1280 1281 1282 1283 1284
	} else if (rq->flags & REQ_SPECIAL) {
		pc = (idefloppy_pc_t *) rq->buffer;
	} else {
		blk_dump_rq_flags(rq,
			"ide-floppy: unsupported command in queue");
Jens Axboe's avatar
Jens Axboe committed
1285
		idefloppy_do_end_request(drive, 0, 0);
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
		return ide_stopped;
	}

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

/*
 *	idefloppy_queue_pc_tail adds a special packet command request to the
 *	tail of the request queue, and waits for it to be serviced.
 */
static int idefloppy_queue_pc_tail (ide_drive_t *drive,idefloppy_pc_t *pc)
{
	struct request rq;

	ide_init_drive_cmd (&rq);
	rq.buffer = (char *) pc;
	rq.flags = REQ_SPECIAL;		//	rq.cmd = IDEFLOPPY_PC_RQ;

Jens Axboe's avatar
Jens Axboe committed
1305
	return ide_do_drive_cmd(drive, &rq, ide_wait);
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
}

/*
 *	Look at the flexible disk page parameters. We will ignore the CHS
 *	capacity parameters and use the LBA parameters instead.
 */
static int idefloppy_get_flexible_disk_page (ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	idefloppy_pc_t pc;
	idefloppy_mode_parameter_header_t *header;
	idefloppy_flexible_disk_page_t *page;
	int capacity, lba_capacity;

Jens Axboe's avatar
Jens Axboe committed
1320 1321 1322 1323
	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");
1324 1325 1326 1327 1328 1329
		return 1;
	}
	header = (idefloppy_mode_parameter_header_t *) pc.buffer;
	floppy->wp = header->wp;
	page = (idefloppy_flexible_disk_page_t *) (header + 1);

Jens Axboe's avatar
Jens Axboe committed
1330 1331 1332 1333
	page->transfer_rate = ntohs(page->transfer_rate);
	page->sector_size = ntohs(page->sector_size);
	page->cyls = ntohs(page->cyls);
	page->rpm = ntohs(page->rpm);
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362
	capacity = page->cyls * page->heads * page->sectors * page->sector_size;
	if (memcmp (page, &floppy->flexible_disk_page, sizeof (idefloppy_flexible_disk_page_t)))
		printk(KERN_INFO "%s: %dkB, %d/%d/%d CHS, %d kBps, "
				"%d sector size, %d rpm\n",
			drive->name, capacity / 1024, page->cyls,
			page->heads, page->sectors,
			page->transfer_rate / 8, page->sector_size, page->rpm);

	floppy->flexible_disk_page = *page;
	drive->bios_cyl = page->cyls;
	drive->bios_head = page->heads;
	drive->bios_sect = page->sectors;
	lba_capacity = floppy->blocks * floppy->block_size;
	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);
		floppy->blocks = floppy->block_size ? capacity / floppy->block_size : 0;
	}
	return 0;
}

static int idefloppy_get_capability_page(ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	idefloppy_pc_t pc;
	idefloppy_mode_parameter_header_t *header;
	idefloppy_capabilities_page_t *page;

Jens Axboe's avatar
Jens Axboe committed
1363 1364
	floppy->srfp = 0;
	idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_CAPABILITIES_PAGE,
1365 1366 1367
						 MODE_SENSE_CURRENT);

	set_bit(PC_SUPPRESS_ERROR, &pc.flags);
Jens Axboe's avatar
Jens Axboe committed
1368
	if (idefloppy_queue_pc_tail(drive,&pc)) {
1369 1370 1371 1372 1373
		return 1;
	}

	header = (idefloppy_mode_parameter_header_t *) pc.buffer;
	page= (idefloppy_capabilities_page_t *)(header+1);
Jens Axboe's avatar
Jens Axboe committed
1374
	floppy->srfp = page->srfp;
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392
	return (0);
}

/*
 *	Determine if a media is present in the floppy drive, and if so,
 *	its LBA capacity.
 */
static int idefloppy_get_capacity (ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	idefloppy_pc_t pc;
	idefloppy_capacity_header_t *header;
	idefloppy_capacity_descriptor_t *descriptor;
	int i, descriptors, rc = 1, blocks, length;
	
	drive->bios_cyl = 0;
	drive->bios_head = drive->bios_sect = 0;
	floppy->blocks = floppy->bs_factor = 0;
1393
	set_capacity(drive->disk, 0);
1394

Jens Axboe's avatar
Jens Axboe committed
1395 1396 1397
	idefloppy_create_read_capacity_cmd(&pc);
	if (idefloppy_queue_pc_tail(drive, &pc)) {
		printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");
1398 1399 1400
		return 1;
	}
	header = (idefloppy_capacity_header_t *) pc.buffer;
Jens Axboe's avatar
Jens Axboe committed
1401
	descriptors = header->length / sizeof(idefloppy_capacity_descriptor_t);
1402 1403 1404
	descriptor = (idefloppy_capacity_descriptor_t *) (header + 1);

	for (i = 0; i < descriptors; i++, descriptor++) {
Jens Axboe's avatar
Jens Axboe committed
1405 1406
		blocks = descriptor->blocks = ntohl(descriptor->blocks);
		length = descriptor->length = ntohs(descriptor->length);
1407 1408 1409

		if (!i) 
		{
Jens Axboe's avatar
Jens Axboe committed
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
		switch (descriptor->dc) {
		/* Clik! drive returns this instead of CAPACITY_CURRENT */
		case CAPACITY_UNFORMATTED:
			if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags))
                                /*
				 * If it is not a clik drive, break out
				 * (maintains previous driver behaviour)
				 */
				break;
		case CAPACITY_CURRENT:
			/* Normal Zip/LS-120 disks */
			if (memcmp(descriptor, &floppy->capacity, sizeof (idefloppy_capacity_descriptor_t)))
				printk(KERN_INFO "%s: %dkB, %d blocks, %d "
					"sector size\n", drive->name,
					blocks * length / 1024, blocks, length);
			floppy->capacity = *descriptor;
			if (!length || length % 512) {
				printk(KERN_NOTICE "%s: %d bytes block size "
					"not supported\n", drive->name, length);
			} else {
1430 1431 1432
                                floppy->blocks = blocks;
                                floppy->block_size = length;
                                if ((floppy->bs_factor = length / 512) != 1)
Jens Axboe's avatar
Jens Axboe committed
1433 1434 1435 1436
                                        printk(KERN_NOTICE "%s: warning: non "
						"512 bytes block size not "
						"fully supported\n",
						drive->name);
1437
                                rc = 0;
Jens Axboe's avatar
Jens Axboe committed
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
			}
			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;
1451 1452 1453
		}
		}
		if (!i) {
Jens Axboe's avatar
Jens Axboe committed
1454 1455
			IDEFLOPPY_DEBUG( "Descriptor 0 Code: %d\n",
				descriptor->dc);
1456
		}
Jens Axboe's avatar
Jens Axboe committed
1457 1458 1459
		IDEFLOPPY_DEBUG( "Descriptor %d: %dkB, %d blocks, %d "
			"sector size\n", i, blocks * length / 1024, blocks,
			length);
1460 1461 1462 1463
	}

	/* Clik! disk does not support get_flexible_disk_page */
        if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags)) {
Jens Axboe's avatar
Jens Axboe committed
1464
		(void) idefloppy_get_flexible_disk_page(drive);
1465 1466
	}

1467
	set_capacity(drive->disk, floppy->blocks * floppy->bs_factor);
1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
	return rc;
}

/*
** Obtain the list of formattable capacities.
** Very similar to idefloppy_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.
**
*/

static int idefloppy_get_format_capacities (ide_drive_t *drive,
					    struct inode *inode,
					    struct file *file,
					    int *arg)	/* Cheater */
{
        idefloppy_pc_t pc;
	idefloppy_capacity_header_t *header;
        idefloppy_capacity_descriptor_t *descriptor;
	int i, descriptors, blocks, length;
	int u_array_size;
	int u_index;
	int *argp;

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

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

Jens Axboe's avatar
Jens Axboe committed
1511 1512 1513
	idefloppy_create_read_capacity_cmd(&pc);
	if (idefloppy_queue_pc_tail(drive, &pc)) {
		printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");
1514 1515 1516 1517
                return (-EIO);
        }
        header = (idefloppy_capacity_header_t *) pc.buffer;
        descriptors = header->length /
Jens Axboe's avatar
Jens Axboe committed
1518
		sizeof(idefloppy_capacity_descriptor_t);
1519 1520
	descriptor = (idefloppy_capacity_descriptor_t *) (header + 1);

Jens Axboe's avatar
Jens Axboe committed
1521 1522
	u_index = 0;
	argp = arg + 1;
1523 1524 1525 1526 1527 1528 1529

	/*
	** We always skip the first capacity descriptor.  That's the
	** current capacity.  We are interested in the remaining descriptors,
	** the formattable capacities.
	*/

Jens Axboe's avatar
Jens Axboe committed
1530
	for (i=0; i<descriptors; i++, descriptor++) {
1531 1532 1533 1534 1535
		if (u_index >= u_array_size)
			break;	/* User-supplied buffer too small */
		if (i == 0)
			continue;	/* Skip the first descriptor */

Jens Axboe's avatar
Jens Axboe committed
1536 1537
		blocks = ntohl(descriptor->blocks);
		length = ntohs(descriptor->length);
1538 1539

		if (put_user(blocks, argp))
Jens Axboe's avatar
Jens Axboe committed
1540
			return(-EFAULT);
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
		++argp;

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

		++u_index;
	}

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

/*
** 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.
*/

static int idefloppy_begin_format(ide_drive_t *drive,
				  struct inode *inode,
				  struct file *file,
				  int *arg)
{
	int blocks;
	int length;
	int flags;
	idefloppy_pc_t pc;

Jens Axboe's avatar
Jens Axboe committed
1581 1582 1583
	if (get_user(blocks, arg) ||
	    get_user(length, arg+1) ||
	    get_user(flags, arg+2)) {
1584 1585 1586
		return (-EFAULT);
	}

Jens Axboe's avatar
Jens Axboe committed
1587 1588
	/* Get the SFRP bit */
	(void) idefloppy_get_capability_page(drive);
1589
	idefloppy_create_format_unit_cmd(&pc, blocks, length, flags);
Jens Axboe's avatar
Jens Axboe committed
1590
	if (idefloppy_queue_pc_tail(drive, &pc)) {
1591
                return (-EIO);
Jens Axboe's avatar
Jens Axboe committed
1592 1593
	}

1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613
	return (0);
}

/*
** Get ATAPI_FORMAT_UNIT progress indication.
**
** Userland gives a pointer to an int.  The int is set to a progresss
** 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.
*/

static int idefloppy_get_format_progress(ide_drive_t *drive,
					 struct inode *inode,
					 struct file *file,
					 int *arg)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	idefloppy_pc_t pc;
Jens Axboe's avatar
Jens Axboe committed
1614
	int progress_indication = 0x10000;
1615

Jens Axboe's avatar
Jens Axboe committed
1616
	if (floppy->srfp) {
1617
		idefloppy_create_request_sense_cmd(&pc);
Jens Axboe's avatar
Jens Axboe committed
1618
		if (idefloppy_queue_pc_tail(drive, &pc)) {
1619 1620 1621
			return (-EIO);
		}

Jens Axboe's avatar
Jens Axboe committed
1622 1623 1624 1625
		if (floppy->sense_key == 2 &&
		    floppy->asc == 4 &&
		    floppy->ascq == 4) {
			progress_indication = floppy->progress_indication;
1626 1627 1628
		}
		/* Else assume format_unit has finished, and we're
		** at 0x10000 */
Jens Axboe's avatar
Jens Axboe committed
1629 1630
	} else {
		atapi_status_t status;
1631 1632 1633
		unsigned long flags;

		local_irq_save(flags);
Jens Axboe's avatar
Jens Axboe committed
1634
		status.all = HWIF(drive)->INB(IDE_STATUS_REG);
1635 1636
		local_irq_restore(flags);

Jens Axboe's avatar
Jens Axboe committed
1637
		progress_indication = !status.b.dsc ? 0 : 0x10000;
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
	}
	if (put_user(progress_indication, arg))
		return (-EFAULT);

	return (0);
}

/*
 *	Our special ide-floppy ioctl's.
 *
 *	Currently there aren't any ioctl's.
 */
static int idefloppy_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file,
				 unsigned int cmd, unsigned long arg)
{
	idefloppy_pc_t pc;
	idefloppy_floppy_t *floppy = drive->driver_data;
	int prevent = (arg) ? 1 : 0;

	switch (cmd) {
	case CDROMEJECT:
		prevent = 0;
		/* fall through */
	case CDROM_LOCKDOOR:
		if (drive->usage > 1)
			return -EBUSY;

		/* The IOMEGA Clik! Drive doesn't support this command - no room for an eject mechanism */
                if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags)) {
Jens Axboe's avatar
Jens Axboe committed
1667 1668
			idefloppy_create_prevent_cmd(&pc, prevent);
			(void) idefloppy_queue_pc_tail(drive, &pc);
1669 1670
		}
		if (cmd == CDROMEJECT) {
Jens Axboe's avatar
Jens Axboe committed
1671 1672
			idefloppy_create_start_stop_cmd(&pc, 2);
			(void) idefloppy_queue_pc_tail(drive, &pc);
1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687
		}
		return 0;
	case IDEFLOPPY_IOCTL_FORMAT_SUPPORTED:
		return (0);
	case IDEFLOPPY_IOCTL_FORMAT_GET_CAPACITY:
		return (idefloppy_get_format_capacities(drive, inode, file,
							(int *)arg));
	case IDEFLOPPY_IOCTL_FORMAT_START:

		if (!(file->f_mode & 2))
			return (-EPERM);

		{
			idefloppy_floppy_t *floppy = drive->driver_data;

Jens Axboe's avatar
Jens Axboe committed
1688
			if (drive->usage > 1) {
1689 1690 1691 1692 1693
				/* Don't format if someone is using the disk */

				clear_bit(IDEFLOPPY_FORMAT_IN_PROGRESS,
					  &floppy->flags);
				return -EBUSY;
Jens Axboe's avatar
Jens Axboe committed
1694
			} else {
1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720
				int rc;

				set_bit(IDEFLOPPY_FORMAT_IN_PROGRESS,
					&floppy->flags);

				rc=idefloppy_begin_format(drive, inode,
							      file,
							      (int *)arg);

				if (rc)
					clear_bit(IDEFLOPPY_FORMAT_IN_PROGRESS,
						  &floppy->flags);
				return (rc);

			/*
			** Note, the bit will be cleared when the device is
			** closed.  This is the cleanest way to handle the
			** situation where the drive does not support
			** format progress reporting.
			*/
			}
		}
	case IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS:
		return (idefloppy_get_format_progress(drive, inode, file,
						      (int *)arg));
	}
1721
 	return -EINVAL;
1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732
}

/*
 *	Our open/release functions
 */
static int idefloppy_open (struct inode *inode, struct file *filp, ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	idefloppy_pc_t pc;
	
#if IDEFLOPPY_DEBUG_LOG
Jens Axboe's avatar
Jens Axboe committed
1733
	printk(KERN_INFO "Reached idefloppy_open\n");
1734 1735 1736 1737 1738 1739 1740 1741 1742
#endif /* IDEFLOPPY_DEBUG_LOG */

	MOD_INC_USE_COUNT;
	if (drive->usage == 1) {
		clear_bit(IDEFLOPPY_FORMAT_IN_PROGRESS, &floppy->flags);
		/* Just in case */

		idefloppy_create_test_unit_ready_cmd(&pc);
		if (idefloppy_queue_pc_tail(drive, &pc)) {
Jens Axboe's avatar
Jens Axboe committed
1743 1744
			idefloppy_create_start_stop_cmd(&pc, 1);
			(void) idefloppy_queue_pc_tail(drive, &pc);
1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764
		}

		if (idefloppy_get_capacity (drive)
		   && (filp->f_flags & O_NDELAY) == 0
		    /*
		    ** 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
		    */
		    ) {
			drive->usage--;
			MOD_DEC_USE_COUNT;
			return -EIO;
		}

		if (floppy->wp && (filp->f_mode & 2)) {
			drive->usage--;
			MOD_DEC_USE_COUNT;
			return -EROFS;
		}		
Jens Axboe's avatar
Jens Axboe committed
1765
		set_bit(IDEFLOPPY_MEDIA_CHANGED, &floppy->flags);
1766 1767
		/* IOMEGA Clik! drives do not support lock/unlock commands */
                if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags)) {
Jens Axboe's avatar
Jens Axboe committed
1768 1769
			idefloppy_create_prevent_cmd(&pc, 1);
			(void) idefloppy_queue_pc_tail(drive, &pc);
1770 1771
		}
		check_disk_change(inode->i_bdev);
Jens Axboe's avatar
Jens Axboe committed
1772
	} else if (test_bit(IDEFLOPPY_FORMAT_IN_PROGRESS, &floppy->flags)) {
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792
		drive->usage--;
		MOD_DEC_USE_COUNT;
		return -EBUSY;
	}
	return 0;
}

static void idefloppy_release (struct inode *inode, struct file *filp, ide_drive_t *drive)
{
	idefloppy_pc_t pc;
	
#if IDEFLOPPY_DEBUG_LOG
	printk (KERN_INFO "Reached idefloppy_release\n");
#endif /* IDEFLOPPY_DEBUG_LOG */

	if (!drive->usage) {
		idefloppy_floppy_t *floppy = drive->driver_data;

		/* IOMEGA Clik! drives do not support lock/unlock commands */
                if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags)) {
Jens Axboe's avatar
Jens Axboe committed
1793 1794
			idefloppy_create_prevent_cmd(&pc, 0);
			(void) idefloppy_queue_pc_tail(drive, &pc);
1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808
		}

		clear_bit(IDEFLOPPY_FORMAT_IN_PROGRESS, &floppy->flags);
	}
	MOD_DEC_USE_COUNT;
}

/*
 *	Check media change. Use a simple algorithm for now.
 */
static int idefloppy_media_change (ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	
Jens Axboe's avatar
Jens Axboe committed
1809
	return test_and_clear_bit(IDEFLOPPY_MEDIA_CHANGED, &floppy->flags);
1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
}

/*
 *	Revalidate the new media. Should set blk_size[]
 */
static void idefloppy_revalidate (ide_drive_t *drive)
{
	ide_revalidate_drive(drive);
}

/*
 *	Return the current floppy capacity to ide.c.
 */
static unsigned long idefloppy_capacity (ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
	unsigned long capacity = floppy->blocks * floppy->bs_factor;

	return capacity;
}

/*
 *	idefloppy_identify_device checks if we can support a drive,
 *	based on the ATAPI IDENTIFY command results.
 */
static int idefloppy_identify_device (ide_drive_t *drive,struct hd_driveid *id)
{
	struct idefloppy_id_gcw gcw;
#if IDEFLOPPY_DEBUG_INFO
Jens Axboe's avatar
Jens Axboe committed
1839
	u16 mask,i;
1840 1841 1842
	char buffer[80];
#endif /* IDEFLOPPY_DEBUG_INFO */

Jens Axboe's avatar
Jens Axboe committed
1843
	*((u16 *) &gcw) = id->config;
1844 1845 1846

#ifdef CONFIG_PPC
	/* kludge for Apple PowerBook internal zip */
Jens Axboe's avatar
Jens Axboe committed
1847 1848 1849
	if ((gcw.device_type == 5) &&
	    !strstr(id->model, "CD-ROM") &&
	    strstr(id->model, "ZIP"))
1850 1851 1852 1853
		gcw.device_type = 0;			
#endif

#if IDEFLOPPY_DEBUG_INFO
Jens Axboe's avatar
Jens Axboe committed
1854
	printk(KERN_INFO "Dumping ATAPI Identify Device floppy parameters\n");
1855
	switch (gcw.protocol) {
Jens Axboe's avatar
Jens Axboe committed
1856 1857 1858
		case 0: case 1: sprintf(buffer, "ATA");break;
		case 2:	sprintf(buffer, "ATAPI");break;
		case 3: sprintf(buffer, "Reserved (Unknown to ide-floppy)");break;
1859
	}
Jens Axboe's avatar
Jens Axboe committed
1860
	printk(KERN_INFO "Protocol Type: %s\n", buffer);
1861
	switch (gcw.device_type) {
Jens Axboe's avatar
Jens Axboe committed
1862 1863
		case 0: sprintf(buffer, "Direct-access Device");break;
		case 1: sprintf(buffer, "Streaming Tape Device");break;
1864
		case 2: case 3: case 4: sprintf (buffer, "Reserved");break;
Jens Axboe's avatar
Jens Axboe committed
1865 1866 1867 1868 1869
		case 5: sprintf(buffer, "CD-ROM Device");break;
		case 6: sprintf(buffer, "Reserved");
		case 7: sprintf(buffer, "Optical memory Device");break;
		case 0x1f: sprintf(buffer, "Unknown or no Device type");break;
		default: sprintf(buffer, "Reserved");
1870
	}
Jens Axboe's avatar
Jens Axboe committed
1871 1872
	printk(KERN_INFO "Device Type: %x - %s\n", gcw.device_type, buffer);
	printk(KERN_INFO "Removable: %s\n",gcw.removable ? "Yes":"No");	
1873
	switch (gcw.drq_type) {
Jens Axboe's avatar
Jens Axboe committed
1874 1875 1876 1877
		case 0: sprintf(buffer, "Microprocessor DRQ");break;
		case 1: sprintf(buffer, "Interrupt DRQ");break;
		case 2: sprintf(buffer, "Accelerated DRQ");break;
		case 3: sprintf(buffer, "Reserved");break;
1878
	}
Jens Axboe's avatar
Jens Axboe committed
1879
	printk(KERN_INFO "Command Packet DRQ Type: %s\n", buffer);
1880
	switch (gcw.packet_size) {
Jens Axboe's avatar
Jens Axboe committed
1881 1882 1883
		case 0: sprintf(buffer, "12 bytes");break;
		case 1: sprintf(buffer, "16 bytes");break;
		default: sprintf(buffer, "Reserved");break;
1884
	}
Jens Axboe's avatar
Jens Axboe committed
1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897
	printk(KERN_INFO "Command Packet Size: %s\n", buffer);
	printk(KERN_INFO "Model: %.40s\n",id->model);
	printk(KERN_INFO "Firmware Revision: %.8s\n",id->fw_rev);
	printk(KERN_INFO "Serial Number: %.20s\n",id->serial_no);
	printk(KERN_INFO "Write buffer size(?): %d bytes\n",id->buf_size*512);
	printk(KERN_INFO "DMA: %s",id->capability & 0x01 ? "Yes\n":"No\n");
	printk(KERN_INFO "LBA: %s",id->capability & 0x02 ? "Yes\n":"No\n");
	printk(KERN_INFO "IORDY can be disabled: %s",id->capability & 0x04 ? "Yes\n":"No\n");
	printk(KERN_INFO "IORDY supported: %s",id->capability & 0x08 ? "Yes\n":"Unknown\n");
	printk(KERN_INFO "ATAPI overlap supported: %s",id->capability & 0x20 ? "Yes\n":"No\n");
	printk(KERN_INFO "PIO Cycle Timing Category: %d\n",id->tPIO);
	printk(KERN_INFO "DMA Cycle Timing Category: %d\n",id->tDMA);
	printk(KERN_INFO "Single Word DMA supported modes:\n");
1898 1899
	for (i=0,mask=1;i<8;i++,mask=mask << 1) {
		if (id->dma_1word & mask)
Jens Axboe's avatar
Jens Axboe committed
1900 1901
			printk(KERN_INFO "   Mode %d%s\n", i,
			(id->dma_1word & (mask << 8)) ? " (active)" : "");
1902
	}
Jens Axboe's avatar
Jens Axboe committed
1903
	printk(KERN_INFO "Multi Word DMA supported modes:\n");
1904 1905
	for (i=0,mask=1;i<8;i++,mask=mask << 1) {
		if (id->dma_mword & mask)
Jens Axboe's avatar
Jens Axboe committed
1906 1907
			printk(KERN_INFO "   Mode %d%s\n", i,
			(id->dma_mword & (mask << 8)) ? " (active)" : "");
1908 1909
	}
	if (id->field_valid & 0x0002) {
Jens Axboe's avatar
Jens Axboe committed
1910 1911
		printk(KERN_INFO "Enhanced PIO Modes: %s\n",
			id->eide_pio_modes & 1 ? "Mode 3":"None");
1912
		if (id->eide_dma_min == 0)
Jens Axboe's avatar
Jens Axboe committed
1913
			sprintf(buffer, "Not supported");
1914
		else
Jens Axboe's avatar
Jens Axboe committed
1915 1916
			sprintf(buffer, "%d ns",id->eide_dma_min);
		printk(KERN_INFO "Minimum Multi-word DMA cycle per word: %s\n", buffer);
1917
		if (id->eide_dma_time == 0)
Jens Axboe's avatar
Jens Axboe committed
1918
			sprintf(buffer, "Not supported");
1919
		else
Jens Axboe's avatar
Jens Axboe committed
1920 1921
			sprintf(buffer, "%d ns",id->eide_dma_time);
		printk(KERN_INFO "Manufacturer\'s Recommended Multi-word cycle: %s\n", buffer);
1922
		if (id->eide_pio == 0)
Jens Axboe's avatar
Jens Axboe committed
1923
			sprintf(buffer, "Not supported");
1924
		else
Jens Axboe's avatar
Jens Axboe committed
1925 1926 1927
			sprintf(buffer, "%d ns",id->eide_pio);
		printk(KERN_INFO "Minimum PIO cycle without IORDY: %s\n",
			buffer);
1928
		if (id->eide_pio_iordy == 0)
Jens Axboe's avatar
Jens Axboe committed
1929
			sprintf(buffer, "Not supported");
1930
		else
Jens Axboe's avatar
Jens Axboe committed
1931 1932
			sprintf(buffer, "%d ns",id->eide_pio_iordy);
		printk(KERN_INFO "Minimum PIO cycle with IORDY: %s\n", buffer);
1933
	} else
Jens Axboe's avatar
Jens Axboe committed
1934
		printk(KERN_INFO "According to the device, fields 64-70 are not valid.\n");
1935 1936 1937
#endif /* IDEFLOPPY_DEBUG_INFO */

	if (gcw.protocol != 2)
Jens Axboe's avatar
Jens Axboe committed
1938
		printk(KERN_ERR "ide-floppy: Protocol is not ATAPI\n");
1939
	else if (gcw.device_type != 0)
Jens Axboe's avatar
Jens Axboe committed
1940
		printk(KERN_ERR "ide-floppy: Device type is not set to floppy\n");
1941
	else if (!gcw.removable)
Jens Axboe's avatar
Jens Axboe committed
1942
		printk(KERN_ERR "ide-floppy: The removable flag is not set\n");
1943
	else if (gcw.drq_type == 3) {
Jens Axboe's avatar
Jens Axboe committed
1944
		printk(KERN_ERR "ide-floppy: Sorry, DRQ type %d not supported\n", gcw.drq_type);
1945
	} else if (gcw.packet_size != 0) {
Jens Axboe's avatar
Jens Axboe committed
1946
		printk(KERN_ERR "ide-floppy: Packet size is not 12 bytes long\n");
1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971
	} else
		return 1;
	return 0;
}

static void idefloppy_add_settings(ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;

/*
 *			drive	setting name	read/write	ioctl	ioctl		data type	min	max	mul_factor	div_factor	data pointer		set function
 */
	ide_add_setting(drive,	"bios_cyl",		SETTING_RW,					-1,			-1,			TYPE_INT,	0,	1023,				1,	1,	&drive->bios_cyl,		NULL);
	ide_add_setting(drive,	"bios_head",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	255,				1,	1,	&drive->bios_head,		NULL);
	ide_add_setting(drive,	"bios_sect",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	63,				1,	1,	&drive->bios_sect,		NULL);
	ide_add_setting(drive,	"ticks",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	255,				1,	1,	&floppy->ticks,		NULL);
}

/*
 *	Driver initialization.
 */
static void idefloppy_setup (ide_drive_t *drive, idefloppy_floppy_t *floppy)
{
	struct idefloppy_id_gcw gcw;

Jens Axboe's avatar
Jens Axboe committed
1972
	*((u16 *) &gcw) = drive->id->config;
1973 1974
	drive->driver_data = floppy;
	drive->ready_stat = 0;
Jens Axboe's avatar
Jens Axboe committed
1975
	memset(floppy, 0, sizeof(idefloppy_floppy_t));
1976 1977 1978
	floppy->drive = drive;
	floppy->pc = floppy->pc_stack;
	if (gcw.drq_type == 1)
Jens Axboe's avatar
Jens Axboe committed
1979
		set_bit(IDEFLOPPY_DRQ_INTERRUPT, &floppy->flags);
1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990
	/*
	 *	We used to check revisions here. At this point however
	 *	I'm giving up. Just assume they are all broken, its easier.
	 *
	 *	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.
	 */

Jens Axboe's avatar
Jens Axboe committed
1991
	if (strcmp(drive->id->model, "IOMEGA ZIP 100 ATAPI") == 0) {
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002
		set_bit(IDEFLOPPY_ZIP_DRIVE, &floppy->flags);
		/* This value will be visible in the /proc/ide/hdx/settings */
		floppy->ticks = IDEFLOPPY_TICKS_DELAY;
		blk_queue_max_sectors(&drive->queue, 64);
	}

	/*
	*      Guess what?  The IOMEGA Clik! drive also needs the
	*      above fix.  It makes nasty clicking noises without
	*      it, so please don't remove this.
	*/
Jens Axboe's avatar
Jens Axboe committed
2003
	if (strncmp(drive->id->model, "IOMEGA Clik!", 11) == 0) {
2004 2005 2006 2007 2008
		blk_queue_max_sectors(&drive->queue, 64);
		set_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags);
	}


Jens Axboe's avatar
Jens Axboe committed
2009
	(void) idefloppy_get_capacity(drive);
2010 2011 2012 2013 2014 2015
	idefloppy_add_settings(drive);
}

static int idefloppy_cleanup (ide_drive_t *drive)
{
	idefloppy_floppy_t *floppy = drive->driver_data;
2016
	struct gendisk *g = drive->disk;
2017

Jens Axboe's avatar
Jens Axboe committed
2018
	if (ide_unregister_subdriver(drive))
2019 2020
		return 1;
	drive->driver_data = NULL;
Jens Axboe's avatar
Jens Axboe committed
2021
	kfree(floppy);
2022
	del_gendisk(g);
2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038
	return 0;
}

#ifdef CONFIG_PROC_FS

static ide_proc_entry_t idefloppy_proc[] = {
	{ "geometry",	S_IFREG|S_IRUGO,	proc_ide_read_geometry,	NULL },
	{ NULL, 0, NULL, NULL }
};

#else

#define	idefloppy_proc	NULL

#endif	/* CONFIG_PROC_FS */

Jens Axboe's avatar
Jens Axboe committed
2039
static int idefloppy_attach(ide_drive_t *drive);
2040 2041 2042 2043 2044

/*
 *	IDE subdriver functions, registered with ide.c
 */
static ide_driver_t idefloppy_driver = {
2045
	owner:			THIS_MODULE,
2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073
	name:			"ide-floppy",
	version:		IDEFLOPPY_VERSION,
	media:			ide_floppy,
	busy:			0,
#ifdef CONFIG_IDEDMA_ONLYDISK
	supports_dma:		0,
#else
	supports_dma:		1,
#endif
	supports_dsc_overlap:	0,
	cleanup:		idefloppy_cleanup,
	standby:		NULL,
	suspend:		NULL,
	resume:			NULL,
	flushcache:		NULL,
	do_request:		idefloppy_do_request,
	end_request:		idefloppy_do_end_request,
	sense:			NULL,
	error:			NULL,
	ioctl:			idefloppy_ioctl,
	open:			idefloppy_open,
	release:		idefloppy_release,
	media_change:		idefloppy_media_change,
	revalidate:		idefloppy_revalidate,
	pre_reset:		NULL,
	capacity:		idefloppy_capacity,
	special:		NULL,
	proc:			idefloppy_proc,
Jens Axboe's avatar
Jens Axboe committed
2074
	attach:			idefloppy_attach,
2075 2076
	ata_prebuilder:		NULL,
	atapi_prebuilder:	NULL,
2077
	drives:			LIST_HEAD_INIT(idefloppy_driver.drives),
2078 2079
};

Jens Axboe's avatar
Jens Axboe committed
2080
static int idefloppy_attach (ide_drive_t *drive)
2081 2082
{
	idefloppy_floppy_t *floppy;
2083
	struct gendisk *g = drive->disk;
2084 2085 2086 2087 2088 2089
	if (!strstr("ide-floppy", drive->driver_req))
		goto failed;
	if (!drive->present)
		goto failed;
	if (drive->media != ide_floppy)
		goto failed;
2090 2091
	if (!idefloppy_identify_device (drive, drive->id)) {
		printk (KERN_ERR "ide-floppy: %s: not supported by this version of ide-floppy\n", drive->name);
2092
		goto failed;
2093
	}
2094 2095
	if (drive->scsi) {
		printk("ide-floppy: passing drive %s to ide-scsi emulation.\n", drive->name);
2096
		goto failed;
2097 2098 2099
	}
	if ((floppy = (idefloppy_floppy_t *) kmalloc (sizeof (idefloppy_floppy_t), GFP_KERNEL)) == NULL) {
		printk (KERN_ERR "ide-floppy: %s: Can't allocate a floppy structure\n", drive->name);
2100
		goto failed;
2101 2102 2103 2104
	}
	if (ide_register_subdriver (drive, &idefloppy_driver, IDE_SUBDRIVER_VERSION)) {
		printk (KERN_ERR "ide-floppy: %s: Failed to register the driver with ide.c\n", drive->name);
		kfree (floppy);
2105
		goto failed;
2106 2107 2108 2109
	}
	DRIVER(drive)->busy++;
	idefloppy_setup (drive, floppy);
	DRIVER(drive)->busy--;
2110
	g->minor_shift = PARTN_BITS;
2111
	g->de = drive->de;
2112
	g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
2113
	g->flags |= GENHD_FL_DEVFS;
2114 2115 2116
	add_gendisk(g);
	register_disk(g, mk_kdev(g->major,g->first_minor),
		      1<<g->minor_shift, ide_fops,
2117
		      get_capacity(g));
2118
	return 0;
2119 2120
failed:
	return 1;
2121 2122 2123 2124 2125 2126
}

MODULE_DESCRIPTION("ATAPI FLOPPY Driver");

static void __exit idefloppy_exit (void)
{
2127
	ide_unregister_driver(&idefloppy_driver);
2128 2129 2130 2131 2132
}

/*
 *	idefloppy_init will register the driver for each floppy.
 */
2133
static int idefloppy_init (void)
2134 2135
{
	printk("ide-floppy driver " IDEFLOPPY_VERSION "\n");
2136
	ide_register_driver(&idefloppy_driver);
2137 2138 2139 2140 2141 2142
	return 0;
}

module_init(idefloppy_init);
module_exit(idefloppy_exit);
MODULE_LICENSE("GPL");