/* *  Copyright (C) 1991, 1992  Linus Torvalds * * This is the low-level hd interrupt support. It traverses the * request-list, using interrupts to jump between functions. As * all the functions are called within interrupts, we may not * sleep. Special care is recommended. * *  modified by Drew Eckhardt to check nr of hd's from the CMOS. * *  Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug *  in the early extended-partition checks and added DM partitions * *  IRQ-unmask, drive-id, multiple-mode, support for ">16 heads", *  and general streamlining by Mark Lord. * *  Removed 99% of above. Use Mark's ide driver for those options. *  This is now a lightweight ST-506 driver. (Paul Gortmaker) * *  Modified 1995 Russell King for ARM processor. * *  Bugfix: max_sectors must be <= 255 or the wheels tend to come *  off in a hurry once you queue things up - Paul G. 02/2001 *//* Uncomment the following if you want verbose error reports. *//* #define VERBOSE_ERRORS */#include <linux/blkdev.h>#include <linux/errno.h>#include <linux/signal.h>#include <linux/interrupt.h>#include <linux/timer.h>#include <linux/fs.h>#include <linux/kernel.h>#include <linux/genhd.h>#include <linux/slab.h>#include <linux/string.h>#include <linux/ioport.h>#include <linux/mc146818rtc.h> /* CMOS defines */#include <linux/init.h>#include <linux/blkpg.h>#include <linux/hdreg.h>#define REALLY_SLOW_IO#include <asm/system.h>#include <asm/io.h>#include <asm/uaccess.h>#ifdef __arm__#undef  HD_IRQ#endif#include <asm/irq.h>#ifdef __arm__#define HD_IRQ IRQ_HARDDISK#endif/* Hd controller regster ports */#define HD_DATA		0x1f0		/* _CTL when writing */#define HD_ERROR	0x1f1		/* see err-bits */#define HD_NSECTOR	0x1f2		/* nr of sectors to read/write */#define HD_SECTOR	0x1f3		/* starting sector */#define HD_LCYL		0x1f4		/* starting cylinder */#define HD_HCYL		0x1f5		/* high byte of starting cyl */#define HD_CURRENT	0x1f6		/* 101dhhhh , d=drive, hhhh=head */#define HD_STATUS	0x1f7		/* see status-bits */#define HD_FEATURE	HD_ERROR	/* same io address, read=error, write=feature */#define HD_PRECOMP	HD_FEATURE	/* obsolete use of this port - predates IDE */#define HD_COMMAND	HD_STATUS	/* same io address, read=status, write=cmd */#define HD_CMD		0x3f6		/* used for resets */#define HD_ALTSTATUS	0x3f6		/* same as HD_STATUS but doesn't clear irq *//* Bits of HD_STATUS */#define ERR_STAT		0x01#define INDEX_STAT		0x02#define ECC_STAT		0x04	/* Corrected error */#define DRQ_STAT		0x08#define SEEK_STAT		0x10#define SERVICE_STAT		SEEK_STAT#define WRERR_STAT		0x20#define READY_STAT		0x40#define BUSY_STAT		0x80/* Bits for HD_ERROR */#define MARK_ERR		0x01	/* Bad address mark */#define TRK0_ERR		0x02	/* couldn't find track 0 */#define ABRT_ERR		0x04	/* Command aborted */#define MCR_ERR			0x08	/* media change request */#define ID_ERR			0x10	/* ID field not found */#define MC_ERR			0x20	/* media changed */#define ECC_ERR			0x40	/* Uncorrectable ECC error */#define BBD_ERR			0x80	/* pre-EIDE meaning:  block marked bad */#define ICRC_ERR		0x80	/* new meaning:  CRC error during transfer */static DEFINE_SPINLOCK(hd_lock);static struct request_queue *hd_queue;#define MAJOR_NR HD_MAJOR#define QUEUE (hd_queue)#define CURRENT elv_next_request(hd_queue)#define TIMEOUT_VALUE	(6*HZ)#define	HD_DELAY	0#define MAX_ERRORS     16	/* Max read/write errors/sector */#define RESET_FREQ      8	/* Reset controller every 8th retry */#define RECAL_FREQ      4	/* Recalibrate every 4th retry */#define MAX_HD		2#define STAT_OK		(READY_STAT|SEEK_STAT)#define OK_STATUS(s)	(((s)&(STAT_OK|(BUSY_STAT|WRERR_STAT|ERR_STAT)))==STAT_OK)static void recal_intr(void);static void bad_rw_intr(void);static int reset;static int hd_error;/* *  This struct defines the HD's and their types. */struct hd_i_struct {	unsigned int head,sect,cyl,wpcom,lzone,ctl;	int unit;	int recalibrate;	int special_op;};	#ifdef HD_TYPEstatic struct hd_i_struct hd_info[] = { HD_TYPE };static int NR_HD = ARRAY_SIZE(hd_info);#elsestatic struct hd_i_struct hd_info[MAX_HD];static int NR_HD;#endifstatic struct gendisk *hd_gendisk[MAX_HD];static struct timer_list device_timer;#define TIMEOUT_VALUE (6*HZ)#define SET_TIMER							\	do {								\		mod_timer(&device_timer, jiffies + TIMEOUT_VALUE);	\	} while (0)static void (*do_hd)(void) = NULL;#define SET_HANDLER(x) \if ((do_hd = (x)) != NULL) \	SET_TIMER; \else \	del_timer(&device_timer);#if (HD_DELAY > 0)#include <asm/i8253.h>unsigned long last_req;unsigned long read_timer(void){	unsigned long t, flags;	int i;	spin_lock_irqsave(&i8253_lock, flags);	t = jiffies * 11932;    	outb_p(0, 0x43);	i = inb_p(0x40);	i |= inb(0x40) << 8;	spin_unlock_irqrestore(&i8253_lock, flags);	return(t - i);}#endifstatic void __init hd_setup(char *str, int *ints){	int hdind = 0;	if (ints[0] != 3)		return;	if (hd_info[0].head != 0)		hdind=1;	hd_info[hdind].head = ints[2];	hd_info[hdind].sect = ints[3];	hd_info[hdind].cyl = ints[1];	hd_info[hdind].wpcom = 0;	hd_info[hdind].lzone = ints[1];	hd_info[hdind].ctl = (ints[2] > 8 ? 8 : 0);	NR_HD = hdind+1;}static void dump_status (const char *msg, unsigned int stat){	char *name = "hd?";	if (CURRENT)		name = CURRENT->rq_disk->disk_name;#ifdef VERBOSE_ERRORS	printk("%s: %s: status=0x%02x { ", name, msg, stat & 0xff);	if (stat & BUSY_STAT)	printk("Busy ");	if (stat & READY_STAT)	printk("DriveReady ");	if (stat & WRERR_STAT)	printk("WriteFault ");	if (stat & SEEK_STAT)	printk("SeekComplete ");	if (stat & DRQ_STAT)	printk("DataRequest ");	if (stat & ECC_STAT)	printk("CorrectedError ");	if (stat & INDEX_STAT)	printk("Index ");	if (stat & ERR_STAT)	printk("Error ");	printk("}\n");	if ((stat & ERR_STAT) == 0) {		hd_error = 0;	} else {		hd_error = inb(HD_ERROR);		printk("%s: %s: error=0x%02x { ", name, msg, hd_error & 0xff);		if (hd_error & BBD_ERR)		printk("BadSector ");		if (hd_error & ECC_ERR)		printk("UncorrectableError ");		if (hd_error & ID_ERR)		printk("SectorIdNotFound ");		if (hd_error & ABRT_ERR)	printk("DriveStatusError ");		if (hd_error & TRK0_ERR)	printk("TrackZeroNotFound ");		if (hd_error & MARK_ERR)	printk("AddrMarkNotFound ");		printk("}");		if (hd_error & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {			printk(", CHS=%d/%d/%d", (inb(HD_HCYL)<<8) + inb(HD_LCYL),				inb(HD_CURRENT) & 0xf, inb(HD_SECTOR));			if (CURRENT)				printk(", sector=%ld", CURRENT->sector);		}		printk("\n");	}#else	printk("%s: %s: status=0x%02x.\n", name, msg, stat & 0xff);	if ((stat & ERR_STAT) == 0) {		hd_error = 0;	} else {		hd_error = inb(HD_ERROR);		printk("%s: %s: error=0x%02x.\n", name, msg, hd_error & 0xff);	}#endif}static void check_status(void){	int i = inb_p(HD_STATUS);	if (!OK_STATUS(i)) {		dump_status("check_status", i);		bad_rw_intr();	}}static int controller_busy(void){	int retries = 100000;	unsigned char status;	do {		status = inb_p(HD_STATUS);	} while ((status & BUSY_STAT) && --retries);	return status;}static int status_ok(void){	unsigned char status = inb_p(HD_STATUS);	if (status & BUSY_STAT)		return 1;	/* Ancient, but does it make sense??? */	if (status & WRERR_STAT)		return 0;	if (!(status & READY_STAT))		return 0;	if (!(status & SEEK_STAT))		return 0;	return 1;}static int controller_ready(unsigned int drive, unsigned int head){	int retry = 100;	do {		if (controller_busy() & BUSY_STAT)			return 0;		outb_p(0xA0 | (drive<<4) | head, HD_CURRENT);		if (status_ok())			return 1;	} while (--retry);	return 0;}		static void hd_out(struct hd_i_struct *disk,		   unsigned int nsect,		   unsigned int sect,		   unsigned int head,		   unsigned int cyl,		   unsigned int cmd,		   void (*intr_addr)(void)){	unsigned short port;#if (HD_DELAY > 0)	while (read_timer() - last_req < HD_DELAY)		/* nothing */;#endif	if (reset)		return;	if (!controller_ready(disk->unit, head)) {		reset = 1;		return;	}	SET_HANDLER(intr_addr);	outb_p(disk->ctl,HD_CMD);	port=HD_DATA;	outb_p(disk->wpcom>>2,++port);	outb_p(nsect,++port);	outb_p(sect,++port);	outb_p(cyl,++port);	outb_p(cyl>>8,++port);	outb_p(0xA0|(disk->unit<<4)|head,++port);	outb_p(cmd,++port);}static void hd_request (void);static int drive_busy(void){	unsigned int i;	unsigned char c;	for (i = 0; i < 500000 ; i++) {		c = inb_p(HD_STATUS);		if ((c & (BUSY_STAT | READY_STAT | SEEK_STAT)) == STAT_OK)			return 0;	}	dump_status("reset timed out", c);	return 1;}static void reset_controller(void){	int	i;	outb_p(4,HD_CMD);	for(i = 0; i < 1000; i++) barrier();	outb_p(hd_info[0].ctl & 0x0f,HD_CMD);	for(i = 0; i < 1000; i++) barrier();	if (drive_busy())		printk("hd: controller still busy\n");	else if ((hd_error = inb(HD_ERROR)) != 1)		printk("hd: controller reset failed: %02x\n",hd_error);}static void reset_hd(void){	static int i;repeat:	if (reset) {		reset = 0;		i = -1;		reset_controller();	} else {		check_status();		if (reset)			goto repeat;	}	if (++i < NR_HD) {		struct hd_i_struct *disk = &hd_info[i];		disk->special_op = disk->recalibrate = 1;		hd_out(disk,disk->sect,disk->sect,disk->head-1,			disk->cyl,WIN_SPECIFY,&reset_hd);		if (reset)			goto repeat;	} else		hd_request();}/* * Ok, don't know what to do with the unexpected interrupts: on some machines * doing a reset and a retry seems to result in an eternal loop. Right now I * ignore it, and just set the timeout. * * On laptops (and "green" PCs), an unexpected interrupt occurs whenever the * drive enters "idle", "standby", or "sleep" mode, so if the status looks * "good", we just ignore the interrupt completely. */static void unexpected_hd_interrupt(void){	unsigned int stat = inb_p(HD_STATUS);	if (stat & (BUSY_STAT|DRQ_STAT|ECC_STAT|ERR_STAT)) {		dump_status ("unexpected interrupt", stat);		SET_TIMER;	}}/* * bad_rw_intr() now tries to be a bit smarter and does things * according to the error returned by the controller. * -Mika Liljeberg (liljeber@cs.Helsinki.FI) */static void bad_rw_intr(void)