/* *  linux/kernel/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 */#include <linux/errno.h>#include <linux/signal.h>#include <linux/sched.h>#include <linux/timer.h>#include <linux/fs.h>#include <linux/kernel.h>#include <linux/hdreg.h>#include <linux/genhd.h>#include <linux/config.h>#define REALLY_SLOW_IO#include <asm/system.h>#include <asm/io.h>#include <asm/segment.h>#define MAJOR_NR HD_MAJOR#include "blk.h"#define HD_IRQ 14static int revalidate_hddisk(int, int);static inline unsigned char CMOS_READ(unsigned char addr){	outb_p(addr,0x70);	return inb_p(0x71);}#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		2static void recal_intr(void);static void bad_rw_intr(void);static char recalibrate[ MAX_HD ] = { 0, };static int access_count[MAX_HD] = {0, };static char busy[MAX_HD] = {0, };static struct wait_queue * busy_wait = NULL;static int reset = 0;static int hd_error = 0;#if (HD_DELAY > 0)unsigned long last_req, read_timer();#endif/* *  This struct defines the HD's and their types. */struct hd_i_struct {	unsigned int head,sect,cyl,wpcom,lzone,ctl;	};#ifdef HD_TYPEstruct hd_i_struct hd_info[] = { HD_TYPE };static int NR_HD = ((sizeof (hd_info))/(sizeof (struct hd_i_struct)));#elsestruct hd_i_struct hd_info[] = { {0,0,0,0,0,0},{0,0,0,0,0,0} };static int NR_HD = 0;#endifstatic struct hd_struct hd[MAX_HD<<6]={{0,0},};static int hd_sizes[MAX_HD<<6] = {0, };static int hd_blocksizes[MAX_HD<<6] = {0, };#if (HD_DELAY > 0)unsigned long read_timer(void){	unsigned long t;	int i;	cli();	t = jiffies * 11932;    	outb_p(0, 0x43);	i = inb_p(0x40);	i |= inb(0x40) << 8;	sti();	return(t - i);}#endifvoid 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 int win_result(void){	int i=inb_p(HD_STATUS);	if ((i & (BUSY_STAT | READY_STAT | WRERR_STAT | SEEK_STAT | ERR_STAT))		== (READY_STAT | SEEK_STAT)) {	        hd_error = 0;		return 0; /* ok */	}	printk("HD: win_result: status = 0x%02x\n",i);	if (i&1) {		hd_error = inb(HD_ERROR);		printk("HD: win_result: error = 0x%02x\n",hd_error);	}		return 1;}static int controller_busy(void);static int status_ok(void);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 int status_ok(void){	unsigned char status = inb_p(HD_STATUS);	if (status & BUSY_STAT)		return 1;	if (status & WRERR_STAT)		return 0;	if (!(status & READY_STAT))		return 0;	if (!(status & SEEK_STAT))		return 0;	return 1;}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 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 (drive>1 || head>15)		panic("Trying to write bad sector");#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 int drive_busy(void){	unsigned int i;	unsigned char c;	for (i = 0; i < 500000 ; i++) {		c = inb_p(HD_STATUS);		c &= (BUSY_STAT | READY_STAT | SEEK_STAT);		if (c == (READY_STAT | SEEK_STAT))			return 0;	}	printk("HD controller times out, status = 0x%02x\n",c);	return 1;}static void reset_controller(void){	int	i;	printk(KERN_DEBUG "HD-controller reset\n");	outb_p(4,HD_CMD);	for(i = 0; i < 1000; i++) nop();	outb(hd_info[0].ctl & 0x0f ,HD_CMD);	if (drive_busy())		printk("HD-controller still busy\n");	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 if (win_result()) {		bad_rw_intr();		if (reset)			goto repeat;	}	i++;	if (i < NR_HD) {		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		do_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. */void unexpected_hd_interrupt(void){	sti();	printk(KERN_DEBUG "Unexpected HD interrupt\n");	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 (!CURRENT)		return;	dev = MINOR(CURRENT->dev) >> 6;	if (++CURRENT->errors >= MAX_ERRORS || (hd_error & BBD_ERR)) {		end_request(0);		recalibrate[dev] = 1;	} else if (CURRENT->errors % RESET_FREQ == 0)		reset = 1;	else if ((hd_error & TRK0_ERR) || CURRENT->errors % RECAL_FREQ == 0)		recalibrate[dev] = 1;	/* Otherwise just retry */}static inline int wait_DRQ(void){	int retries = 100000;	while (--retries > 0)		if (inb_p(HD_STATUS) & DRQ_STAT)			return 0;	return -1;}#define STAT_MASK (BUSY_STAT | READY_STAT | WRERR_STAT | SEEK_STAT | ERR_STAT)#define STAT_OK (READY_STAT | SEEK_STAT)static void read_intr(void){	int i;	int retries = 100000;	do {		i = (unsigned) inb_p(HD_STATUS);		if (i & BUSY_STAT)			continue;		if ((i & STAT_MASK) != STAT_OK)			break;		if (i & DRQ_STAT)			goto ok_to_read;	} while (--retries > 0);	sti();	printk("HD: read_intr: status = 0x%02x\n",i);	if (i & ERR_STAT) {		hd_error = (unsigned) inb(HD_ERROR);		printk("HD: read_intr: error = 0x%02x\n",hd_error);	}	bad_rw_intr();	cli();	do_hd_request();	return;ok_to_read:	insw(HD_DATA,CURRENT->buffer,256);	CURRENT->errors = 0;	CURRENT->buffer += 512;	CURRENT->sector++;	i = --CURRENT->nr_sectors;	--CURRENT->current_nr_sectors;#ifdef DEBUG	printk("hd%d : sector = %d, %d remaining to buffer = %08x\n",		MINOR(CURRENT->dev), CURRENT->sector, i, CURRENT-> 		buffer);#endif	if (!i || (CURRENT->bh && !SUBSECTOR(i)))		end_request(1);	if (i > 0) {		SET_INTR(&read_intr);		sti();		return;	}	(void) inb_p(HD_STATUS);#if (HD_DELAY > 0)	last_req = read_timer();#endif	do_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 ((i & STAT_MASK) != STAT_OK)			break;		if ((CURRENT->nr_sectors <= 1) || (i & DRQ_STAT))			goto ok_to_write;	} while (--retries > 0);	sti();	printk("HD: write_intr: status = 0x%02x\n",i);	if (i & ERR_STAT) {		hd_error = (unsigned) inb(HD_ERROR);		printk("HD: write_intr: error = 0x%02x\n",hd_error);	}	bad_rw_intr();	cli();	do_hd_request();	return;ok_to_write:	CURRENT->sector++;	i = --CURRENT->nr_sectors;	--CURRENT->current_nr_sectors;	CURRENT->buffer += 512;	if (!i || (CURRENT->bh && !SUBSECTOR(i)))		end_request(1);	if (i > 0) {		SET_INTR(&write_intr);		outsw(HD_DATA,CURRENT->buffer,256);		sti();	} else {#if (HD_DELAY > 0)		last_req = read_timer();