/* *  linux/drivers/ide/ide-disk.c	Version 1.18	Mar 05, 2003 * *  Copyright (C) 1994-1998  Linus Torvalds & authors (see below) *  Copyright (C) 1998-2002  Linux ATA Developemt *				Andre Hedrick <andre@linux-ide.org> *  Copyright (C) 2003	     Red Hat <alan@redhat.com> * * *//* *  Mostly written by Mark Lord <mlord@pobox.com> *                and Gadi Oxman <gadio@netvision.net.il> *                and Andre Hedrick <andre@linux-ide.org> * * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c. * * Version 1.00		move disk only code from ide.c to ide-disk.c *			support optional byte-swapping of all data * Version 1.01		fix previous byte-swapping code * Version 1.02		remove ", LBA" from drive identification msgs * Version 1.03		fix display of id->buf_size for big-endian * Version 1.04		add /proc configurable settings and S.M.A.R.T support * Version 1.05		add capacity support for ATA3 >= 8GB * Version 1.06		get boot-up messages to show full cyl count * Version 1.07		disable door-locking if it fails * Version 1.08		fixed CHS/LBA translations for ATA4 > 8GB, *			process of adding new ATA4 compliance. *			fixed problems in allowing fdisk to see *			the entire disk. * Version 1.09		added increment of rq->sector in ide_multwrite *			added UDMA 3/4 reporting * Version 1.10		request queue changes, Ultra DMA 100 * Version 1.11		added 48-bit lba * Version 1.12		adding taskfile io access method * Version 1.13		added standby and flush-cache for notifier * Version 1.14		added acoustic-wcache * Version 1.15		convert all calls to ide_raw_taskfile *				since args will return register content. * Version 1.16		added suspend-resume-checkpower * Version 1.17		do flush on standy, do flush on ATA < ATA6 *			fix wcache setup. */#define IDEDISK_VERSION	"1.17"#undef REALLY_SLOW_IO		/* most systems can safely undef this */#include <linux/config.h>#include <linux/module.h>#include <linux/types.h>#include <linux/string.h>#include <linux/kernel.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/delay.h>#define _IDE_DISK#include <linux/ide.h>#include <asm/byteorder.h>#include <asm/irq.h>#include <asm/uaccess.h>#include <asm/io.h>/* FIXME: some day we shouldnt need to look in here! */#include "legacy/pdc4030.h"static int driver_blocked;static inline u32 idedisk_read_24 (ide_drive_t *drive){#if 0	return	(HWIF(drive)->INB(IDE_HCYL_REG)<<16) |		(HWIF(drive)->INB(IDE_LCYL_REG)<<8) |		 HWIF(drive)->INB(IDE_SECTOR_REG);#else	u8 hcyl = HWIF(drive)->INB(IDE_HCYL_REG);	u8 lcyl = HWIF(drive)->INB(IDE_LCYL_REG);	u8 sect = HWIF(drive)->INB(IDE_SECTOR_REG);	return (hcyl<<16)|(lcyl<<8)|sect;#endif}static int idedisk_end_request(ide_drive_t *drive, int uptodate);/* * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity" * value for this drive (from its reported identification information). * * Returns:	1 if lba_capacity looks sensible *		0 otherwise * * It is called only once for each drive. */static int lba_capacity_is_ok (struct hd_driveid *id){	unsigned long lba_sects, chs_sects, head, tail;	if ((id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)) {		printk("48-bit Drive: %llu \n", id->lba_capacity_2);		return 1;	}	/*	 * The ATA spec tells large drives to return	 * C/H/S = 16383/16/63 independent of their size.	 * Some drives can be jumpered to use 15 heads instead of 16.	 * Some drives can be jumpered to use 4092 cyls instead of 16383.	 */	if ((id->cyls == 16383	     || (id->cyls == 4092 && id->cur_cyls == 16383)) &&	    id->sectors == 63 &&	    (id->heads == 15 || id->heads == 16) &&	    (id->lba_capacity >= 16383*63*id->heads))		return 1;	lba_sects   = id->lba_capacity;	chs_sects   = id->cyls * id->heads * id->sectors;	/* perform a rough sanity check on lba_sects:  within 10% is OK */	if ((lba_sects - chs_sects) < chs_sects/10)		return 1;	/* some drives have the word order reversed */	head = ((lba_sects >> 16) & 0xffff);	tail = (lba_sects & 0xffff);	lba_sects = (head | (tail << 16));	if ((lba_sects - chs_sects) < chs_sects/10) {		id->lba_capacity = lba_sects;		return 1;	/* lba_capacity is (now) good */	}	return 0;	/* lba_capacity value may be bad */}#ifndef CONFIG_IDE_TASKFILE_IO/* * read_intr() is the handler for disk read/multread interrupts */static ide_startstop_t read_intr (ide_drive_t *drive){	ide_hwif_t *hwif	= HWIF(drive);	u32 i = 0, nsect	= 0, msect = drive->mult_count;	struct request *rq;	unsigned long flags;	u8 stat;	char *to;	/* new way for dealing with premature shared PCI interrupts */	if (!OK_STAT(stat=hwif->INB(IDE_STATUS_REG),DATA_READY,BAD_R_STAT)) {		if (stat & (ERR_STAT|DRQ_STAT)) {			return DRIVER(drive)->error(drive, "read_intr", stat);		}		/* no data yet, so wait for another interrupt */		ide_set_handler(drive, &read_intr, WAIT_CMD, NULL);		return ide_started;	}	read_next:	rq = HWGROUP(drive)->rq;	if (msect) {		if ((nsect = rq->current_nr_sectors) > msect)			nsect = msect;		msect -= nsect;	} else		nsect = 1;	to = ide_map_buffer(rq, &flags);	taskfile_input_data(drive, to, nsect * SECTOR_WORDS);#ifdef DEBUG	printk("%s:  read: sectors(%ld-%ld), buffer=0x%08lx, remaining=%ld\n",		drive->name, rq->sector, rq->sector+nsect-1,		(unsigned long) rq->buffer+(nsect<<9), rq->nr_sectors-nsect);#endif	ide_unmap_buffer(to, &flags);	rq->sector += nsect;	rq->errors = 0;	i = (rq->nr_sectors -= nsect);	if (((long)(rq->current_nr_sectors -= nsect)) <= 0)		idedisk_end_request(drive, 1);	/*	 * Another BH Page walker and DATA INTERGRITY Questioned on ERROR.	 * If passed back up on multimode read, BAD DATA could be ACKED	 * to FILE SYSTEMS above ...	 */	if (i > 0) {		if (msect)			goto read_next;		ide_set_handler(drive, &read_intr, WAIT_CMD, NULL);                return ide_started;	}        return ide_stopped;}/* * write_intr() is the handler for disk write interrupts */static ide_startstop_t write_intr (ide_drive_t *drive){	ide_hwgroup_t *hwgroup	= HWGROUP(drive);	ide_hwif_t *hwif	= HWIF(drive);	struct request *rq	= hwgroup->rq;	u32 i = 0;	u8 stat;	if (!OK_STAT(stat = hwif->INB(IDE_STATUS_REG),			DRIVE_READY, drive->bad_wstat)) {		printk("%s: write_intr error1: nr_sectors=%ld, stat=0x%02x\n",			drive->name, rq->nr_sectors, stat);        } else {#ifdef DEBUG		printk("%s: write: sector %ld, buffer=0x%08lx, remaining=%ld\n",			drive->name, rq->sector, (unsigned long) rq->buffer,			rq->nr_sectors-1);#endif		if ((rq->nr_sectors == 1) ^ ((stat & DRQ_STAT) != 0)) {			rq->sector++;			rq->errors = 0;			i = --rq->nr_sectors;			--rq->current_nr_sectors;			if (((long)rq->current_nr_sectors) <= 0)				idedisk_end_request(drive, 1);			if (i > 0) {				unsigned long flags;				char *to = ide_map_buffer(rq, &flags);				taskfile_output_data(drive, to, SECTOR_WORDS);				ide_unmap_buffer(to, &flags);				ide_set_handler(drive, &write_intr, WAIT_CMD, NULL);                                return ide_started;			}                        return ide_stopped;		}		/* the original code did this here (?) */		return ide_stopped;	}	return DRIVER(drive)->error(drive, "write_intr", stat);}/* * ide_multwrite() transfers a block of up to mcount sectors of data * to a drive as part of a disk multiple-sector write operation. * * Returns 0 on success. * * Note that we may be called from two contexts - the do_rw_disk context * and IRQ context. The IRQ can happen any time after we've output the * full "mcount" number of sectors, so we must make sure we update the * state _before_ we output the final part of the data! * * The update and return to BH is a BLOCK Layer Fakey to get more data * to satisfy the hardware atomic segment.  If the hardware atomic segment * is shorter or smaller than the BH segment then we should be OKAY. * This is only valid if we can rewind the rq->current_nr_sectors counter. */int ide_multwrite (ide_drive_t *drive, unsigned int mcount){ 	ide_hwgroup_t *hwgroup	= HWGROUP(drive); 	struct request *rq	= &hwgroup->wrq;   	do {  		char *buffer;  		int nsect = rq->current_nr_sectors;		unsigned long flags; 		if (nsect > mcount)			nsect = mcount;		mcount -= nsect;		buffer = ide_map_buffer(rq, &flags);		rq->sector += nsect;		rq->nr_sectors -= nsect;		rq->current_nr_sectors -= nsect;		/* Do we move to the next bh after this? */		if (!rq->current_nr_sectors) {			struct buffer_head *bh = rq->bh->b_reqnext;			/* end early early we ran out of requests */			if (!bh) {				mcount = 0;			} else {				rq->bh = bh;				rq->current_nr_sectors = bh->b_size >> 9;				rq->hard_cur_sectors = rq->current_nr_sectors;				rq->buffer             = bh->b_data;			}		}		/*		 * Ok, we're all setup for the interrupt		 * re-entering us on the last transfer.		 */		taskfile_output_data(drive, buffer, nsect<<7);		ide_unmap_buffer(buffer, &flags);	} while (mcount);        return 0;}/* * multwrite_intr() is the handler for disk multwrite interrupts */static ide_startstop_t multwrite_intr (ide_drive_t *drive){	ide_hwgroup_t *hwgroup	= HWGROUP(drive);	ide_hwif_t *hwif	= HWIF(drive);	struct request *rq	= &hwgroup->wrq;	u32 i = 0;	u8 stat;	if (OK_STAT(stat = hwif->INB(IDE_STATUS_REG),			DRIVE_READY, drive->bad_wstat)) {		if (stat & DRQ_STAT) {			/*			 *	The drive wants data. Remember rq is the copy			 *	of the request			 */			if (rq->nr_sectors) {				if (ide_multwrite(drive, drive->mult_count))					return ide_stopped;				ide_set_handler(drive, &multwrite_intr, WAIT_CMD, NULL);				return ide_started;			}		} else {			/*			 *	If the copy has all the blocks completed then			 *	we can end the original request.			 */			if (!rq->nr_sectors) {	/* all done? */				rq = hwgroup->rq;				for (i = rq->nr_sectors; i > 0;) {					i -= rq->current_nr_sectors;					idedisk_end_request(drive, 1);				}				return ide_stopped;			}		}		/* the original code did this here (?) */		return ide_stopped;	}	return DRIVER(drive)->error(drive, "multwrite_intr", stat);}/* * __ide_do_rw_disk() issues READ and WRITE commands to a disk, * using LBA if supported, or CHS otherwise, to address sectors. * It also takes care of issuing special DRIVE_CMDs. */ide_startstop_t __ide_do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block){	ide_hwif_t *hwif	= HWIF(drive);	u8 lba48		= (drive->addressing == 1) ? 1 : 0;	task_ioreg_t command	= WIN_NOP;	ata_nsector_t		nsectors;	nsectors.all		= (u16) rq->nr_sectors;	if (driver_blocked)		panic("Request while ide driver is blocked?");	if (IDE_CONTROL_REG)		hwif->OUTB(drive->ctl, IDE_CONTROL_REG);	if (drive->select.b.lba) {		if (drive->addressing == 1) {			task_ioreg_t tasklets[10];			tasklets[0] = 0;			tasklets[1] = 0;			tasklets[2] = nsectors.b.low;			tasklets[3] = nsectors.b.high;			tasklets[4] = (task_ioreg_t) block;			tasklets[5] = (task_ioreg_t) (block>>8);			tasklets[6] = (task_ioreg_t) (block>>16);			tasklets[7] = (task_ioreg_t) (block>>24);			tasklets[8] = (task_ioreg_t) 0;			tasklets[9] = (task_ioreg_t) 0;//			tasklets[8] = (task_ioreg_t) (block>>32);//			tasklets[9] = (task_ioreg_t) (block>>40);#ifdef DEBUG			printk("%s: %sing: LBAsect=%lu, sectors=%ld, "				"buffer=0x%08lx, LBAsect=0x%012lx\n",				drive->name,				(rq->cmd==READ)?"read":"writ",				block,				rq->nr_sectors,				(unsigned long) rq->buffer,				block);			printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",				drive->name, tasklets[3], tasklets[2],				tasklets[9], tasklets[8], tasklets[7],				tasklets[6], tasklets[5], tasklets[4]);#endif			hwif->OUTB(tasklets[1], IDE_FEATURE_REG);			hwif->OUTB(tasklets[3], IDE_NSECTOR_REG);			hwif->OUTB(tasklets[7], IDE_SECTOR_REG);			hwif->OUTB(tasklets[8], IDE_LCYL_REG);			hwif->OUTB(tasklets[9], IDE_HCYL_REG);			hwif->OUTB(tasklets[0], IDE_FEATURE_REG);			hwif->OUTB(tasklets[2], IDE_NSECTOR_REG);			hwif->OUTB(tasklets[4], IDE_SECTOR_REG);			hwif->OUTB(tasklets[5], IDE_LCYL_REG);			hwif->OUTB(tasklets[6], IDE_HCYL_REG);			hwif->OUTB(0x00|drive->select.all,IDE_SELECT_REG);		} else {#ifdef DEBUG			printk("%s: %sing: LBAsect=%ld, sectors=%ld, "				"buffer=0x%08lx\n",				drive->name, (rq->cmd==READ)?"read":"writ",				block, rq->nr_sectors,				(unsigned long) rq->buffer);#endif			hwif->OUTB(0x00, IDE_FEATURE_REG);			hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);			hwif->OUTB(block, IDE_SECTOR_REG);			hwif->OUTB(block>>=8, IDE_LCYL_REG);			hwif->OUTB(block>>=8, IDE_HCYL_REG);			hwif->OUTB(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);		}	} else {		unsigned int sect,head,cyl,track;		track = block / drive->sect;		sect  = block % drive->sect + 1;		hwif->OUTB(sect, IDE_SECTOR_REG);		head  = track % drive->head;		cyl   = track / drive->head;		hwif->OUTB(0x00, IDE_FEATURE_REG);		hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);		hwif->OUTB(cyl, IDE_LCYL_REG);		hwif->OUTB(cyl>>8, IDE_HCYL_REG);		hwif->OUTB(head|drive->select.all,IDE_SELECT_REG);#ifdef DEBUG		printk("%s: %sing: CHS=%d/%d/%d, sectors=%ld, buffer=0x%08lx\n",			drive->name, (rq->cmd==READ)?"read":"writ", cyl,			head, sect, rq->nr_sectors, (unsigned long) rq->buffer);#endif	}	if (rq_data_dir(rq) == READ) {#ifdef CONFIG_BLK_DEV_IDEDMA		if (drive->using_dma && !hwif->ide_dma_read(drive))			return ide_started;#endif /* CONFIG_BLK_DEV_IDEDMA */		if (HWGROUP(drive)->handler != NULL)			BUG();		command = ((drive->mult_count) ?			   ((lba48) ? WIN_MULTREAD_EXT : WIN_MULTREAD) :			   ((lba48) ? WIN_READ_EXT : WIN_READ));			ide_execute_command(drive, command, &read_intr, WAIT_CMD, NULL);		return ide_started;	} else if (rq_data_dir(rq) == WRITE) {		ide_startstop_t startstop;#ifdef CONFIG_BLK_DEV_IDEDMA		if (drive->using_dma && !(HWIF(drive)->ide_dma_write(drive)))			return ide_started;#endif /* CONFIG_BLK_DEV_IDEDMA */		command = ((drive->mult_count) ?			   ((lba48) ? WIN_MULTWRITE_EXT : WIN_MULTWRITE) :			   ((lba48) ? WIN_WRITE_EXT : WIN_WRITE));		hwif->OUTB(command, IDE_COMMAND_REG);		if (ide_wait_stat(&startstop, drive, DATA_READY,				drive->bad_wstat, WAIT_DRQ)) {			printk(KERN_ERR "%s: no DRQ after issuing %s\n",				drive->name,				drive->mult_count ? "MULTWRITE" : "WRITE");