--- linux/kernel/blk_drv/hd.c 2018/04/24 18:01:40 1.1.1.1 +++ linux/kernel/blk_drv/hd.c 2018/04/24 18:15:22 1.1.1.10 @@ -1,7 +1,7 @@ /* * linux/kernel/hd.c * - * (C) 1991 Linus Torvalds + * Copyright (C) 1991, 1992 Linus Torvalds */ /* @@ -9,13 +9,28 @@ * 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 +#ifdef CONFIG_BLK_DEV_HD + +#define HD_IRQ 14 + +#include +#include #include +#include #include #include #include +#include + +#define REALLY_SLOW_IO #include #include #include @@ -23,15 +38,34 @@ #define MAJOR_NR 3 #include "blk.h" +static inline unsigned char CMOS_READ(unsigned char addr) +{ + outb_p(0x80|addr,0x70); + return inb_p(0x71); +} + +#define HD_DELAY 0 + /* Max read/write errors/sector */ -#define MAX_ERRORS 5 +#define MAX_ERRORS 7 #define MAX_HD 2 +static void recal_intr(void); +static void bad_rw_intr(void); + +static char recalibrate[ MAX_HD ] = { 0, }; + +static int reset = 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 { - int head,sect,cyl,wpcom,lzone,ctl; + unsigned int head,sect,cyl,wpcom,lzone,ctl; }; #ifdef HD_TYPE struct hd_i_struct hd_info[] = { HD_TYPE }; @@ -41,10 +75,8 @@ struct hd_i_struct hd_info[] = { {0,0,0, static int NR_HD = 0; #endif -static struct hd_struct { - long start_sect; - long nr_sects; -} hd[5*MAX_HD]={{0,0},}; +static struct hd_struct hd[MAX_HD<<6]={{0,0},}; +static int hd_sizes[MAX_HD<<6] = {0, }; #define port_read(port,buf,nr) \ __asm__("cld;rep;insw"::"d" (port),"D" (buf),"c" (nr):"cx","di") @@ -52,93 +84,67 @@ __asm__("cld;rep;insw"::"d" (port),"D" ( #define port_write(port,buf,nr) \ __asm__("cld;rep;outsw"::"d" (port),"S" (buf),"c" (nr):"cx","si") -extern void hd_interrupt(void); - -/* This may be used only once, enforced by 'static int callable' */ -int sys_setup(void * BIOS) +#if (HD_DELAY > 0) +unsigned long read_timer(void) { - static int callable = 1; - int i,drive; - struct partition *p; - struct buffer_head * bh; - - if (!callable) - return -1; - callable = 0; -#ifndef HD_TYPE - for (drive=0 ; drive<2 ; drive++) { - hd_info[drive].cyl = *(unsigned short *) BIOS; - hd_info[drive].head = *(unsigned char *) (2+BIOS); - hd_info[drive].wpcom = *(unsigned short *) (5+BIOS); - hd_info[drive].ctl = *(unsigned char *) (8+BIOS); - hd_info[drive].lzone = *(unsigned short *) (12+BIOS); - hd_info[drive].sect = *(unsigned char *) (14+BIOS); - BIOS += 16; - } - if (hd_info[1].cyl) - NR_HD=2; - else - NR_HD=1; -#endif - for (i=0 ; ib_data[510] != 0x55 || (unsigned char) - bh->b_data[511] != 0xAA) { - printk("Bad partition table on drive %d\n\r",drive); - panic(""); - } - p = 0x1BE + (void *)bh->b_data; - for (i=1;i<5;i++,p++) { - hd[i+5*drive].start_sect = p->start_sect; - hd[i+5*drive].nr_sects = p->nr_sects; - } - brelse(bh); - } - printk("Partition table%s ok.\n\r",(NR_HD>1)?"s":""); - mount_root(); - return (0); + unsigned long t; + int i; + + cli(); + outb_p(0xc2, 0x43); + t = jiffies * 11931 + (inb_p(0x40) & 0x80 ? 5966 : 11932); + i = inb_p(0x40); + i |= inb(0x40) << 8; + sti(); + return(t - i / 2); } +#endif static int controller_ready(void) { - int retries=1000; + int retries = 100000; - while (--retries && (inb(HD_STATUS)&0xc0)!=0x40); + while (--retries && (inb_p(HD_STATUS)&0x80)) + /* nothing */; + if (!retries) + printk("controller_ready: status = %02x\n\r", + (unsigned char) inb_p(HD_STATUS)); return (retries); } static int win_result(void) { - int i=inb(HD_STATUS); + int i=inb_p(HD_STATUS); if ((i & (BUSY_STAT | READY_STAT | WRERR_STAT | SEEK_STAT | ERR_STAT)) == (READY_STAT | SEEK_STAT)) - return(0); /* ok */ - if (i&1) i=inb(HD_ERROR); - return (1); + return 0; /* ok */ + printk("HD: win_result: status = 0x%02x\n",i); + if (i&1) { + i=inb(HD_ERROR); + printk("HD: win_result: error = 0x%02x\n",i); + } + return 1; } 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)) { - register int port asm("dx"); + unsigned short port; if (drive>1 || head>15) panic("Trying to write bad sector"); - if (!controller_ready()) - panic("HD controller not ready"); - do_hd = intr_addr; - outb(hd_info[drive].ctl,HD_CMD); +#if (HD_DELAY > 0) + while (read_timer() - last_req < HD_DELAY) + /* nothing */; +#endif + if (reset || !controller_ready()) { + 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); @@ -146,21 +152,21 @@ static void hd_out(unsigned int drive,un outb_p(cyl,++port); outb_p(cyl>>8,++port); outb_p(0xA0|(drive<<4)|head,++port); - outb(cmd,++port); + outb_p(cmd,++port); } static int drive_busy(void) { unsigned int i; + unsigned char c; - for (i = 0; i < 100000; i++) - if (READY_STAT == (inb(HD_STATUS) & (BUSY_STAT | READY_STAT))) - break; - i = inb(HD_STATUS); - i &= BUSY_STAT | READY_STAT | SEEK_STAT; - if (i == READY_STAT | SEEK_STAT) - return(0); - printk("HD controller times out\n\r"); + 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\r",c); return(1); } @@ -168,116 +174,440 @@ static void reset_controller(void) { int i; + printk("HD-controller reset\r\n"); outb(4,HD_CMD); for(i = 0; i < 1000; i++) nop(); - outb(0,HD_CMD); - for(i = 0; i < 10000 && drive_busy(); i++) /* nothing */; + outb(hd_info[0].ctl & 0x0f ,HD_CMD); if (drive_busy()) printk("HD-controller still busy\n\r"); - if((i = inb(ERR_STAT)) != 1) + if ((i = inb(HD_ERROR)) != 1) printk("HD-controller reset failed: %02x\n\r",i); } -static void redo_hd_request(void) +static void reset_hd(void) { - do_hd = NULL; - do_hd_request(); -} + static int i; -static void reset_hd(int nr) -{ - reset_controller(); - hd_out(nr,hd_info[nr].sect,hd_info[nr].sect,hd_info[nr].head-1, - hd_info[nr].cyl,WIN_SPECIFY,&redo_hd_request); +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("Unexpected HD interrupt\n\r"); + SET_TIMER; } static void bad_rw_intr(void) { - int i = CURRENT_DEV; + int i; - if (CURRENT->errors++ >= MAX_ERRORS) + if (!CURRENT) + return; + if (++CURRENT->errors >= MAX_ERRORS) end_request(0); - reset_hd(i); + else if (CURRENT->errors > MAX_ERRORS/2) + reset = 1; + else + for (i=0; i < NR_HD; i++) + recalibrate[i] = 1; +} + +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) { - if (win_result()) { - bad_rw_intr(); - return; + int i; + int retries = 100000; + + do { + i = (unsigned) inb_p(HD_STATUS); + 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) { + i = (unsigned) inb(HD_ERROR); + printk("HD: read_intr: error = 0x%02x\n",i); } + bad_rw_intr(); + cli(); + do_hd_request(); + return; +ok_to_read: port_read(HD_DATA,CURRENT->buffer,256); CURRENT->errors = 0; CURRENT->buffer += 512; CURRENT->sector++; - if (--CURRENT->nr_sectors) + 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; - end_request(1); + } +#if (HD_DELAY > 0) + last_req = read_timer(); +#endif do_hd_request(); + return; } static void write_intr(void) { - if (win_result()) { - bad_rw_intr(); - return; + int i; + int retries = 100000; + + do { + i = (unsigned) inb_p(HD_STATUS); + 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) { + i = (unsigned) inb(HD_ERROR); + printk("HD: write_intr: error = 0x%02x\n",i); } - if (--CURRENT->nr_sectors) { - CURRENT->sector++; - CURRENT->buffer += 512; + 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); port_write(HD_DATA,CURRENT->buffer,256); + sti(); + } else { +#if (HD_DELAY > 0) + last_req = read_timer(); +#endif + do_hd_request(); + } + return; +} + +static void recal_intr(void) +{ + if (win_result()) + bad_rw_intr(); + do_hd_request(); +} + +/* + * This is another of the error-routines I don't know what to do with. The + * best idea seems to just set reset, and start all over again. + */ +static void hd_times_out(void) +{ + DEVICE_INTR = NULL; + sti(); + reset = 1; + if (!CURRENT) return; + printk("HD timeout\n\r"); + cli(); + if (++CURRENT->errors >= MAX_ERRORS) { +#ifdef DEBUG + printk("hd : too many errors.\n"); +#endif + end_request(0); } - end_request(1); + do_hd_request(); } -void do_hd_request(void) +/* + * The driver has been modified to enable interrupts a bit more: in order to + * do this we first (a) disable the timeout-interrupt and (b) clear the + * device-interrupt. This way the interrupts won't mess with out code (the + * worst that can happen is that an unexpected HD-interrupt comes in and + * sets the "reset" variable and starts the timer) + */ +static void do_hd_request(void) { - int i,r; unsigned int block,dev; - unsigned int sec,head,cyl; + unsigned int sec,head,cyl,track; unsigned int nsect; + if (DEVICE_INTR) + return; +repeat: + timer_active &= ~(1<dev); block = CURRENT->sector; - if (dev >= 5*NR_HD || block+2 > hd[dev].nr_sects) { + nsect = CURRENT->nr_sectors; + if (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects) { +#ifdef DEBUG + printk("hd%d : attempted read for sector %d past end of device at sector %d.\n", + block, hd[dev].nr_sects); +#endif end_request(0); goto repeat; } block += hd[dev].start_sect; - dev /= 5; - __asm__("divl %4":"=a" (block),"=d" (sec):"0" (block),"1" (0), - "r" (hd_info[dev].sect)); - __asm__("divl %4":"=a" (cyl),"=d" (head):"0" (block),"1" (0), - "r" (hd_info[dev].head)); - sec++; - nsect = CURRENT->nr_sectors; + dev >>= 6; + sec = block % hd_info[dev].sect + 1; + track = block / hd_info[dev].sect; + head = track % hd_info[dev].head; + cyl = track / hd_info[dev].head; +#ifdef DEBUG + printk("hd%d : cyl = %d, head = %d, sector = %d, buffer = %08x\n", + dev, cyl, head, sec, CURRENT->buffer); +#endif + cli(); + if (reset) { + int i; + + for (i=0; i < NR_HD; i++) + recalibrate[i] = 1; + reset_hd(); + sti(); + return; + } + if (recalibrate[dev]) { + recalibrate[dev] = 0; + hd_out(dev,hd_info[dev].sect,0,0,0,WIN_RESTORE,&recal_intr); + if (reset) + goto repeat; + sti(); + return; + } if (CURRENT->cmd == WRITE) { hd_out(dev,nsect,sec,head,cyl,WIN_WRITE,&write_intr); - for(i=0 ; i<3000 && !(r=inb_p(HD_STATUS)&DRQ_STAT) ; i++) - /* nothing */ ; - if (!r) { - reset_hd(CURRENT_DEV); - return; + if (reset) + goto repeat; + if (wait_DRQ()) { + printk("HD: do_hd_request: no DRQ\n"); + bad_rw_intr(); + goto repeat; } port_write(HD_DATA,CURRENT->buffer,256); - } else if (CURRENT->cmd == READ) { + sti(); + return; + } + if (CURRENT->cmd == READ) { hd_out(dev,nsect,sec,head,cyl,WIN_READ,&read_intr); - } else - panic("unknown hd-command"); + if (reset) + goto repeat; + sti(); + return; + } + panic("unknown hd-command"); +} + +static int hd_ioctl(struct inode * inode, struct file * file, + unsigned int cmd, unsigned int arg) +{ + struct hd_geometry *loc = (void *) arg; + int dev; + + if (!loc || !inode) + return -EINVAL; + dev = MINOR(inode->i_rdev) >> 6; + if (dev >= NR_HD) + return -EINVAL; + switch (cmd) { + case HDIO_REQ: + verify_area(loc, sizeof(*loc)); + put_fs_byte(hd_info[dev].head, + (char *) &loc->heads); + put_fs_byte(hd_info[dev].sect, + (char *) &loc->sectors); + put_fs_word(hd_info[dev].cyl, + (short *) &loc->cylinders); + put_fs_long(hd[MINOR(inode->i_rdev)].start_sect, + (long *) &loc->start); + return 0; + RO_IOCTLS(inode->i_rdev,arg); + default: + return -EINVAL; + } +} + +/* + * Releasing a block device means we sync() it, so that it can safely + * be forgotten about... + */ +static void hd_release(struct inode * inode, struct file * file) +{ + sync_dev(inode->i_rdev); +} + +static void hd_geninit(); + +static struct gendisk hd_gendisk = { + MAJOR_NR, /* Major number */ + "hd", /* Major name */ + 6, /* Bits to shift to get real from partition */ + 1 << 6, /* Number of partitions per real */ + MAX_HD, /* maximum number of real */ + hd_geninit, /* init function */ + hd, /* hd struct */ + hd_sizes, /* block sizes */ + 0, /* number */ + (void *) hd_info, /* internal */ + NULL /* next */ +}; + +static void hd_geninit(void) +{ + int drive, i; +#ifndef HD_TYPE + extern struct drive_info drive_info; + void *BIOS = (void *) &drive_info; + int cmos_disks; + + for (drive=0 ; drive<2 ; drive++) { + hd_info[drive].cyl = *(unsigned short *) BIOS; + hd_info[drive].head = *(unsigned char *) (2+BIOS); + hd_info[drive].wpcom = *(unsigned short *) (5+BIOS); + hd_info[drive].ctl = *(unsigned char *) (8+BIOS); + hd_info[drive].lzone = *(unsigned short *) (12+BIOS); + hd_info[drive].sect = *(unsigned char *) (14+BIOS); + BIOS += 16; + } + + /* + We querry CMOS about hard disks : it could be that + we have a SCSI/ESDI/etc controller that is BIOS + compatable with ST-506, and thus showing up in our + BIOS table, but not register compatable, and therefore + not present in CMOS. + + Furthurmore, we will assume that our ST-506 drives + are the primary drives in the system, and + the ones reflected as drive 1 or 2. + + The first drive is stored in the high nibble of CMOS + byte 0x12, the second in the low nibble. This will be + either a 4 bit drive type or 0xf indicating use byte 0x19 + for an 8 bit type, drive 1, 0x1a for drive 2 in CMOS. + + Needless to say, a non-zero value means we have + an AT controller hard disk for that drive. + + + */ + + if ((cmos_disks = CMOS_READ(0x12)) & 0xf0) + if (cmos_disks & 0x0f) + NR_HD = 2; + else + NR_HD = 1; + else + NR_HD = 0; +#endif + + for (i = 0 ; i < NR_HD ; i++) + hd[i<<6].nr_sects = hd_info[i].head* + hd_info[i].sect*hd_info[i].cyl; + + hd_gendisk.nr_real = NR_HD; } -void hd_init(void) +static struct file_operations hd_fops = { + NULL, /* lseek - default */ + block_read, /* read - general block-dev read */ + block_write, /* write - general block-dev write */ + NULL, /* readdir - bad */ + NULL, /* select */ + hd_ioctl, /* ioctl */ + NULL, /* no special open code */ + hd_release /* release */ +}; + +static void hd_interrupt(int unused) +{ + void (*handler)(void) = DEVICE_INTR; + + DEVICE_INTR = NULL; + timer_active &= ~(1<