AllinToyou

这个屌丝很懒，什么也没留下！

热门标签

linux-hd.c_hdhdhd x

作者：AllinToyou | 2024-03-05 15:16:36

踩

hdhdhd x

/*/*

* linux/kernel/hd.c

* 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.

#include <linux/config.h>

#include <linux/sched.h>

#include <linux/fs.h>

#include <linux/kernel.h>

#include <linux/hdreg.h>

#include <asm/system.h>

#include <asm/io.h>

#include <asm/segment.h>

#define MAJOR_NR 3

#include "blk.h"

#define CMOS_READ(addr) ({ / //－－读CMOS中硬盘信息

outb_p(0x80|addr,0x70); /

inb_p(0x71); /

})

/* Max read/write errors/sector */

#define MAX_ERRORS 7

#define MAX_HD 2

static void recal_intr(void);

static void bad_rw_intr(void);

static int recalibrate = 0;

static int reset = 0;

* This struct defines the HD's and their types.

struct hd_i_struct { //－－定义硬盘参数及类型

int head,sect,cyl,wpcom,lzone,ctl;

};

#ifdef HD_TYPE

struct hd_i_struct hd_info[] = { HD_TYPE };

#define NR_HD ((sizeof (hd_info))/(sizeof (struct hd_i_struct)))

#else

struct hd_i_struct hd_info[] = { {0,0,0,0,0,0},{0,0,0,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 int hd_sizes[5*MAX_HD] = {0, };

#define port_read(port,buf,nr) / //－－读端口嵌入汇编宏

__asm__("cld;rep;insw"::"d" (port),"D" (buf),"c" (nr):"cx","di")

#define port_write(port,buf,nr) / //－－写端口嵌入汇编宏

__asm__("cld;rep;outsw"::"d" (port),"S" (buf),"c" (nr):"cx","si")

extern void hd_interrupt(void); //－－硬盘中断过程

extern void rd_load(void); //－－虚拟盘创建加载函数

/* This may be used only once, enforced by 'static int callable' */

int sys_setup(void * BIOS) //－－系统设置函数，只在初始化时被调用一次

{ //－－BIOS为指向硬盘参数表结构的指针

static int callable = 1;

int i,drive;

unsigned char cmos_disks;

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; //－－每个硬盘参数表长16个字节，这里指向下一表

}

if (hd_info[1].cyl) //－－如果没有第二个硬盘，则信息为空

NR_HD=2;

else

NR_HD=1;

#endif

for (i=0 ; i<NR_HD ; i++) { //－－设置硬盘分区结构数组hd[]

hd[i*5].start_sect = 0;

hd[i*5].nr_sects = hd_info[i].head*

hd_info[i].sect*hd_info[i].cyl;

}

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

<if any> 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) //－－检测硬盘是不是AT控制器兼容的。

if (cmos_disks & 0x0f)

NR_HD = 2;

else

NR_HD = 1;

else

NR_HD = 0;

for (i = NR_HD ; i < 2 ; i++) {

hd[i*5].start_sect = 0;

hd[i*5].nr_sects = 0;

} //－－到此最终确定硬盘数量

for (drive=0 ; drive<NR_HD ; drive++) { //－－读取硬盘上第一个扇区的分区表信息，来设置分区结构数组hd[]

if (!(bh = bread(0x300 + drive*5,0))) { //－－bread()读取硬盘第一个数据块

printk("Unable to read partition table of drive %d/n/r",

drive);

panic("");

}

if (bh->b_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); //－－释放为存放硬盘数据块而申请的缓冲区

}

for (i=0 ; i<5*MAX_HD ; i++) //－－对每个分区中数据块进行统计并保存

hd_sizes[i] = hd[i].nr_sects>>1 ;

blk_size[MAJOR_NR] = hd_sizes;

if (NR_HD)

printk("Partition table%s ok./n/r",(NR_HD>1)?"s":"");

rd_load();

init_swapping();

mount_root();

return (0);

}

static int controller_ready(void) //－－判断并循环等待硬盘控制器就绪

{

int retries = 100000;

while (--retries && (inb_p(HD_STATUS)&0xc0)!=0x40);

return (retries);

}

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))

return(0); /* ok */

if (i&1) i=inb(HD_ERROR);

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)) //－－向硬盘控制器发送命令块

{ //－－在硬盘控制器就绪之后，先设置全局函数指针变量do_hd指向硬盘中断处理程序中将会调用的C处理函数

if (drive>1 || head>15)

panic("Trying to write bad sector");

if (!controller_ready())

panic("HD controller not ready");

SET_INTR(intr_addr); //－－do_hd = 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(cmd,++port);

}

static int drive_busy(void) //－－等待硬盘就绪

{

unsigned int i;

unsigned char c;

for (i = 0; i < 50000; i++) { //－－循环50000次等待HD_STATUS

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/n/r");

return(1);

}

static void reset_controller(void) //－－重新校正硬盘控制器

{

int i;

outb(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/r");

if ((i = inb(HD_ERROR)) != 1)

printk("HD-controller reset failed: %02x/n/r",i);

}

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);

} else

do_hd_request();

}

void unexpected_hd_interrupt(void) //－－意外硬盘中断处理函数

{

printk("Unexpected HD interrupt/n/r");

reset = 1;

do_hd_request();

}

static void bad_rw_intr(void) //－－读写硬盘失败处理函数

{

if (++CURRENT->errors >= MAX_ERRORS)

end_request(0);

if (CURRENT->errors > MAX_ERRORS/2)

reset = 1;

}

static void read_intr(void) //－－读操作中断调用函数

{ //－－硬盘读命令hd_out()结束时引发的硬盘中断过程中被调用

if (win_result()) {

bad_rw_intr();

do_hd_request();

return;

}

port_read(HD_DATA,CURRENT->buffer,256); //－－读数据到请求结构缓冲区

CURRENT->errors = 0;

CURRENT->buffer += 512;

CURRENT->sector++;

if (--CURRENT->nr_sectors) {

SET_INTR(&read_intr);

return;

}

end_request(1);

do_hd_request();

}

static void write_intr(void) //－－写扇区中断调用函数

{

if (win_result()) {

bad_rw_intr();

do_hd_request();

return;

}

if (--CURRENT->nr_sectors) {

CURRENT->sector++;

CURRENT->buffer += 512;

SET_INTR(&write_intr);

port_write(HD_DATA,CURRENT->buffer,256);

return;

}

end_request(1);

do_hd_request();

}

static void recal_intr(void) //－－硬盘重新校正中断函数

{

if (win_result())

bad_rw_intr();

do_hd_request();

}

void hd_times_out(void) //－－硬盘操作超时处理

{ //－－在kernel/sched.c line340中被调用

if (!CURRENT)

return;

printk("HD timeout");

if (++CURRENT->errors >= MAX_ERRORS)

end_request(0);

SET_INTR(NULL);

reset = 1;

do_hd_request();

}

void do_hd_request(void) //－－执行硬盘读写请求操作

{

int i,r;

unsigned int block,dev;

unsigned int sec,head,cyl;

unsigned int nsect;

INIT_REQUEST;

dev = MINOR(CURRENT->dev); //－－检测请求的合法性

block = CURRENT->sector;

if (dev >= 5*NR_HD || block+2 > hd[dev].nr_sects) {

end_request(0);

goto repeat;

}

block += hd[dev].start_sect;

dev /= 5; //－－根据求得的绝对扇区号block和硬盘号dev，计算磁道中的扇区号sec,柱面号syl,磁头号head.

__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;

if (reset) { //－－向硬盘控制器发送i/o操作信息

recalibrate = 1;

reset_hd();

return;

}

if (recalibrate) {

recalibrate = 0;

hd_out(dev,hd_info[CURRENT_DEV].sect,0,0,0,

WIN_RESTORE,&recal_intr);

return;

}

if (CURRENT->cmd == WRITE) {

hd_out(dev,nsect,sec,head,cyl,WIN_WRITE,&write_intr);

for(i=0 ; i<10000 && !(r=inb_p(HD_STATUS)&DRQ_STAT) ; i++)

/* nothing */ ;

if (!r) {

bad_rw_intr();

goto repeat;

}

port_write(HD_DATA,CURRENT->buffer,256);

} else if (CURRENT->cmd == READ) {

hd_out(dev,nsect,sec,head,cyl,WIN_READ,&read_intr);

} else

panic("unknown hd-command");

}

void hd_init(void) //－－硬盘系统初始化

{

blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;

set_intr_gate(0x2E,&hd_interrupt);

outb_p(inb_p(0x21)&0xfb,0x21);

outb(inb_p(0xA1)&0xbf,0xA1);

}

|xGv00|fcc8d4de8197f69fde70263fb4d52380

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/191958