/* *  linux/drivers/ide/legacy/hd.c * *  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/errno.h>#include <linux/signal.h>#include <linux/sched.h>#include <linux/timer.h>#include <linux/fs.h>#include <linux/devfs_fs_kernel.h>#include <linux/kernel.h>#include <linux/hdreg.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>#define REALLY_SLOW_IO#include <asm/system.h>#include <asm/io.h>#include <asm/uaccess.h>#define MAJOR_NR HD_MAJOR#include <linux/blk.h>#ifdef __arm__#undef  HD_IRQ#endif#include <asm/irq.h>#ifdef __arm__#define HD_IRQ IRQ_HARDDISK#endifstatic int revalidate_hddisk(kdev_t, int);#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 char recalibrate[MAX_HD];static char special_op[MAX_HD];static int access_count[MAX_HD];static char busy[MAX_HD];static DECLARE_WAIT_QUEUE_HEAD(busy_wait);static int reset;static int hd_error;#define SUBSECTOR(block) (CURRENT->current_nr_sectors > 0)/* *  This struct defines the HD's and their types. */struct hd_i_struct {	unsigned int head,sect,cyl,wpcom,lzone,ctl;};	#ifdef HD_TYPEstatic struct hd_i_struct hd_info[] = { HD_TYPE };static int NR_HD = ((sizeof (hd_info))/(sizeof (struct hd_i_struct)));#elsestatic struct hd_i_struct hd_info[MAX_HD];static int NR_HD;#endifstatic struct hd_struct hd[MAX_HD<<6];static int hd_sizes[MAX_HD<<6];static int hd_blocksizes[MAX_HD<<6];static int hd_hardsectsizes[MAX_HD<<6];static int hd_maxsect[MAX_HD<<6];static struct timer_list device_timer;#define SET_TIMER 							\	do {								\		mod_timer(&device_timer, jiffies + TIMEOUT_VALUE);	\	} while (0)#define CLEAR_TIMER del_timer(&device_timer);#undef SET_INTR#define SET_INTR(x) \if ((DEVICE_INTR = (x)) != NULL) \	SET_TIMER; \else \	CLEAR_TIMER;#if (HD_DELAY > 0)unsigned long last_req;unsigned long read_timer(void){	unsigned long t, flags;	int i;	spin_lock_irqsave(&io_request_lock, flags);	t = jiffies * 11932;    	outb_p(0, 0x43);	i = inb_p(0x40);	i |= inb(0x40) << 8;	spin_unlock_irqrestore(&io_request_lock, flags);	return(t - i);}#endifvoid __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){	unsigned long flags;	char devc;	devc = !QUEUE_EMPTY ? 'a' + DEVICE_NR(CURRENT->rq_dev) : '?';	save_flags (flags);	sti();#ifdef VERBOSE_ERRORS	printk("hd%c: %s: status=0x%02x { ", devc, 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("hd%c: %s: error=0x%02x { ", devc, 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 (!QUEUE_EMPTY)				printk(", sector=%ld", CURRENT->sector);		}		printk("\n");	}#else	printk("hd%c: %s: status=0x%02x.\n", devc, msg, stat & 0xff);	if ((stat & ERR_STAT) == 0) {		hd_error = 0;	} else {		hd_error = inb(HD_ERROR);		printk("hd%c: %s: error=0x%02x.\n", devc, msg, hd_error & 0xff);	}#endif	/* verbose errors */	restore_flags (flags);}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(unsigned int drive,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(drive, head)) {		reset = 1;		return;	}	SET_INTR(intr_addr);	outb_p(hd_info[drive].ctl,HD_CMD);	port=HD_DATA;	outb_p(hd_info[drive].wpcom>>2,++port);	outb_p(nsect,++port);	outb_p(sect,++port);	outb_p(cyl,++port);	outb_p(cyl>>8,++port);	outb_p(0xA0|(drive<<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) {		special_op[i] = recalibrate[i] = 1;		hd_out(i,hd_info[i].sect,hd_info[i].sect,hd_info[i].head-1,			hd_info[i].cyl,WIN_SPECIFY,&reset_hd);		if (reset)			goto repeat;	} else		hd_request();}void do_reset_hd(void){	DEVICE_INTR = NULL;	reset = 1;	reset_hd();}/* * 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. */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){	int dev;	if (QUEUE_EMPTY)		return;	dev = DEVICE_NR(CURRENT->rq_dev);	if (++CURRENT->errors >= MAX_ERRORS || (hd_error & BBD_ERR)) {		end_request(0);		special_op[dev] = recalibrate[dev] = 1;	} else if (CURRENT->errors % RESET_FREQ == 0)		reset = 1;	else if ((hd_error & TRK0_ERR) || CURRENT->errors % RECAL_FREQ == 0)		special_op[dev] = recalibrate[dev] = 1;	/* Otherwise just retry */}static inline int wait_DRQ(void){	int retries = 100000, stat;	while (--retries > 0)		if ((stat = inb_p(HD_STATUS)) & DRQ_STAT)			return 0;	dump_status("wait_DRQ", stat);	return -1;}static void read_intr(void){	int i, retries = 100000;	do {		i = (unsigned) inb_p(HD_STATUS);		if (i & BUSY_STAT)			continue;		if (!OK_STATUS(i))			break;		if (i & DRQ_STAT)			goto ok_to_read;	} while (--retries > 0);	dump_status("read_intr", i);	bad_rw_intr();	hd_request();	return;ok_to_read:	insw(HD_DATA,CURRENT->buffer,256);	CURRENT->sector++;	CURRENT->buffer += 512;	CURRENT->errors = 0;	i = --CURRENT->nr_sectors;	--CURRENT->current_nr_sectors;#ifdef DEBUG	printk("hd%c: read: sector %ld, remaining = %ld, buffer=0x%08lx\n",		dev+'a', CURRENT->sector, CURRENT->nr_sectors,		(unsigned long) CURRENT->buffer+512));#endif	if (CURRENT->current_nr_sectors <= 0)		end_request(1);	if (i > 0) {		SET_INTR(&read_intr);		return;	}	(void) inb_p(HD_STATUS);#if (HD_DELAY > 0)	last_req = read_timer();#endif	if (!QUEUE_EMPTY)		hd_request();	return;}static void write_intr(void){	int i;	int retries = 100000;	do {		i = (unsigned) inb_p(HD_STATUS);		if (i & BUSY_STAT)			continue;		if (!OK_STATUS(i))			break;		if ((CURRENT->nr_sectors <= 1) || (i & DRQ_STAT))