如何检测到IDE设备及其参数！

我参照PCI规范,从PCI配置空间里面得到了本机上的PCI
设备例如显卡,网卡,声卡和一些桥的信息,但是没有搜索到硬盘和光驱.
我的程序用的是穷举法.现在我想请问的是,硬盘和光驱这些IDE设备的信息 (Drive model,Firmware revision,
Drive serial number)以我的电脑为例,就是:
Drive model: Maxtor 31536H2;
Firmware rvision: BAC51KJO
Drive serial number: N211HH2C
这些信息如何取得到? 是不是PCI配置空间可以搜索得到.(因为规范里,基本类01H
是海量存储控制器).但是为什么搜索不到IDE设备呢? 是不是我的程序有问题? 该用其他的方法吗?
然后,就算能够访问IDE设备的PCI配置空间,里面有没有我上述的三个参数?
就像BIOS开机自检得到的结果一样.

另外一个问题就是主板BIOS名称\\主板BIOS版权,这些信息一般存放在什么地方?该如何取到?

硬盘和光驱不能作为PCI设备被发现。它们的总线接在南桥上，就像USB的总线一般。如同你也不可能通过PCI的规范搜索到USB设备一样。
另，规范中说的基本类01H（海量存储控制器）指的是通过PCI槽外挂的PCI卡设备。不是你所指的意思。 :P :)

那如何访问呢IDE设备呢?

IDE设备好象用ISA总线形式访问，我看到过

IDE设备专门提供“驱动器确认命令”（EC）来干这事。

能举个例子吗?
不胜感激!

介绍一种方法：可采用Max+plusII软件中的Option->license setup->System Info 就可以看到硬盘的Drive serial number，这就是例子

As easy as pie.
Parts of source code:


#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>

#include \"globle.h\"

#include \"cmddef.h\"
#include \"portdef.h\"
#include \"funcdef.h\"
#include \"utils.h\"
#include \"cardmng.h\"
#include \"int.h\"
#include \"piorw.h\"


unsigned char buffer[BUFFER_SIZE];
void *SearchCommand(unsigned char command);
int scanpara(char *fmt, ...);

unsigned short io_base;
unsigned char device_no;
unsigned char pcc_irq_no;
unsigned char mode;
unsigned char command;
unsigned short int_poll;

unsigned char hd_controler;


extern struct FuncEntry    FuncTab[COMMANDNUM];

void main(int argc, char *argv[])
{
int (*p)();
int result;
ShowTitle();

if(argc != 4)
{
printf(\"Usage: ata device mode poll\\n\");
printf(\"device: p0, p1, s0, s1, pcc. (p0: Primary 0 etc. s0: Secondary 0 etc.)\\n\");
printf(\"mode: CHS, LBA\\n\");
return;
}

if(!strcmp(argv[1], \"p0\"))
{
io_base = 0x1F0;
device_no = 0;
hd_controler = PRIMARY_CONTROLER;
}
else if(!strcmp(argv[1], \"p1\"))
{
io_base = 0x1F0;
device_no = 1;
hd_controler = PRIMARY_CONTROLER;
}
else if(!strcmp(argv[1], \"s0\"))
{
io_base = 0x170;
device_no = 0;
hd_controler = SECONDARY_CONTRLER;
}
else if(!strcmp(argv[1], \"s1\"))
{
io_base = 0x170;
device_no = 1;
hd_controler = SECONDARY_CONTRLER;
}
else if(!strcmp(argv[1], \"pcc\"))
{
/* printf(\"Config PC Card IO Base: \");
scanf(\"%x\\n\", &io_base);
printf(\"Config PC Card IRQ NO: \");
scanf(\"%x\\n\", &pcc_irq_no);
device_no = 0;*/
// here:
io_base = 0x110;
device_no = 0;
pccard_main();
// getch();
// goto here;


}
else
{
printf(\"Usage: ata device mode\\n\");
printf(\"device: p0, p1, s0, s1, pcc. (p0: Primary 0 etc. s0: Secondary 0 etc.)\\n\");
printf(\"mode: CHS, LBA\\n\");
return;
}

if(!strcmp(argv[2], \"chs\") || !strcmp(argv[2], \"CHS\"))
{
mode = CHS;
}
else if(!strcmp(argv[2], \"lba\") || !strcmp(argv[2], \"LBA\"))
{
mode = LBA;
}
else
{
printf(\"Usage: ata device mode\\n\");
printf(\"device: p0, p1, s0, s1, pcc. (p0: Primary 0 etc. s0: Secondary 0 etc.)\\n\");
printf(\"mode: CHS, LBA\\n\");
return;
}

if(!strcmp(argv[3], \"int\"))
{
int_poll = INT_MODE;
}
else if(!strcmp(argv[3], \"poll\"))
{
int_poll = POLL_MODE;
}
else
{
printf(\"Usage: ata device mode\\n\");
printf(\"device: p0, p1, s0, s1, pcc. (p0: Primary 0 etc. s0: Secondary 0 etc.)\\n\");
printf(\"mode: CHS, LBA\\n\");
return;
}

    for(;;)
    {
        printf(\"Input ATA command: \");
        scanf(\"%x\", &command);
        fflush(stdin);
        if(command == 0xff)
         break;
        if(!(p = SearchCommand(command)))
        {
         printf(\"Invalid ATA command\\n\");
         continue;
        }
/*call command function*/
print_command(command);
replace_vect(hd_controler);
        (*p)();
        restore_vect(hd_controler);
        enable_hdd_int();
    }
}

/*return value not 0: found
  0: not found*/
void *SearchCommand(unsigned char command)
{
struct FuncEntry *p;
int i;
for(p = FuncTab, i = 0; i < COMMANDNUM ; i ++, p++)
{
if(p->cmd == command)
return p->func;
}
return 0;
}

/***************************/

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <dos.h>

#include \"globle.h\"
#include \"cmddef.h\"
#include \"portdef.h\"
#include \"utils.h\"
#include \"piorw.h\"
#include \"pci.h\"
#include \"dma.h\"
#include \"int.h\"
#include \"funcdef.h\"

extern unsigned char command;
extern unsigned char buffer[BUFFER_SIZE];
extern unsigned short io_base;
extern unsigned char device_no;
extern unsigned char mode;
extern unsigned short int_poll;
extern int interrupt_flag;

unsigned short g_feature;
unsigned short g_cylinder_no;
unsigned short g_head_no;
unsigned short g_sector_no;
unsigned short g_count;
unsigned long g_lba_addr;
unsigned short g_sectors_per_track;
unsigned short g_max_head_no;
unsigned short g_sectors_per_block;


unsigned char table[64];

struct prd_entry far *tblp;
unsigned char bus_master_status;


struct FuncEntry    FuncTab[COMMANDNUM] =
{
    {CMD_NOP             , do_non_data_command  ,   \"NOP\"},
{CMD_CFA_REQUEST_EXTENDED_ERROR_CODE , do_non_data_command , \"CFA REQUEST EXTENDED ERROR CODE\" },
    {CMD_READ_SECTORS_R , do_pio_data_in_command,   \"READ SECTORS R\" },
    {CMD_READ_SECTORS_N     , do_pio_data_in_command , \"READ SECTORS N\"},
    {CMD_DEVICE_RESET , do_device_reset_command , \"DEVICE RESET\"},
    {CMD_WRITE_SECTORS_R     , do_pio_data_out_command,      \"WRITE SECTORS R\"},
    {CMD_WRITE_SECTORS_N     , do_pio_data_out_command ,    \"WRITE SECTORS N\" },
    {CMD_CFA_WRITE_SECTORS_WITHOUT_ERASE , do_pio_data_out_command , \"CFA WRITE SECTORS WITHOUT ERASE\"},
    {CMD_READ_VERIFY_SECTORS_R     , do_non_data_command   ,   \"READ VERIFY SECTORS R\"},
    {CMD_READ_VERIFY_SECTORS_N     , do_non_data_command ,   \"READ VERIFY SECTORS N\"},
    {CMD_SEEK   , do_non_data_command  ,   \"SEEK\"},
    {CMD_CFA_TRANSLATE_SECTOR     , do_pio_data_in_command  ,   \"CFA TRANSLATE SECTOR\"},
    {CMD_EXECUTE_DEVICE_DIAGNOSTIC       , do_device_diagnose_command    ,   \"EXECUTE DEVICE DIAGNOSTIC\"},
    {CMD_INITIALIZE_DEVICE_PARAMETERS       , do_non_data_command,   \"INITIALIZE DEVICE PARAMETERS\"},      
    {CMD_DOWNLOAD_MICROCODE         , do_pio_data_out_command      ,   \"DOWNLOAD MICROCODE\"},
    {CMD_PACKET     , do_packet_command ,   \"PACKET\"},
    {CMD_IDENTIFY_PACKET_DEVICE     , do_pio_data_in_command ,   \"IDENTIFY PACKET DEVICE\"},
    {CMD_SERVICE         , do_packet_command      ,   \"SERVICE\"},
    {CMD_SMART         , do_smart_command      ,   \"SMART\"},
    {CMD_CFA_ERASE_SECTORS           , do_non_data_command        ,   \"CFA ERASE SECTORS\"},
    {CMD_READ_MULTIPLE           , do_pio_data_in_command,   \"READ MULTIPLE\"},
    {CMD_WRITE_MULTIPLE     , do_pio_data_out_command,   \"WRITE MULTIPLE\"},
    {CMD_SET_MULTIPLE_MODE     , do_non_data_command  ,   \"SET MULTIPLE MODE\"},
    {CMD_READ_DMA_QUEUE       , do_read_write_dma_queued_command  ,   \"READ DMA QUEUE\"},
    {CMD_READ_DMA_R           , do_dma_command,   \"READ DMA R\"},
    {CMD_READ_DMA_N           , do_dma_command,   \"READ DMA N\"},
    {CMD_WRITE_DMA_R     , do_dma_command  ,   \"WRITE DMA R\"},
    {CMD_WRITE_DMA_N         , do_dma_command      ,   \"WRITE DMA N\"},
    {CMD_WRITE_DMA_QUEUED         , do_read_write_dma_queued_command      ,   \"WRITE DMA QUEUED\"},
    {CMD_CFA_WRITE_MULTIPLE_WITHOUT_ERASE   , do_pio_data_out_command      ,   \"CFA WRITE MULTIPLE WITHOUT ERASE\"},
    {CMD_GET_MEDIA_STATUS         , do_non_data_command      ,   \"GET MEDIA STATUS\"},
    {CMD_MEDIA_LOCK   , do_non_data_command,  \"MEDIA LOCK \"},
    {CMD_MEDIA_UNLOCK , do_non_data_command, \"MEDIA UNLOCK\"},
    {CMD_STANDBY_IMMEDIATE   , do_non_data_command,  \"STANDBY IMMEDIATE\"},
    {CMD_IDLE_IMMEDIATE       , do_non_data_command, \"IDLE IMMEDIATE\"},
    {CMD_STANDBY     , do_non_data_command   , \"STANDBY\"},
    {CMD_IDLE           , do_non_data_command  ,  \"IDLE\"},
    {CMD_READ_BUFFER           , do_pio_data_in_command, \"READ BUFFER\"},
    {CMD_CHECK_POWER_MODE           , do_non_data_command,  \"CHECK POWER MODE\"},
    {CMD_SLEEP         , do_non_data_command,  \"SLEEP\"},
    {CMD_FLUSH_CACHE       , do_non_data_command     ,  \"FLUSH CACHE\"},
    {CMD_WRITE_BUFFER     , do_pio_data_out_command,  \"WRITE BUFFER\"},
    {CMD_IDENTIFY_DEVICE     , do_pio_data_in_command  ,  \"IDENTIFY DEVICE\"},  
    {CMD_MEDIA_EJECT         , do_non_data_command,  \"MEDIA EJECT\"},    
    {CMD_SET_FEATURES     , do_non_data_command   ,  \"SET FEATURES\"},
    {CMD_SECURITY_SET_PASSWORD     , do_pio_data_out_command   ,  \"SECURITY SET PASSWORD\"},
    {CMD_SECURITY_UNLOCK   , do_pio_data_out_command ,  \"SECURITY UNLOCK\"},
    {CMD_SECURITY_ERASE_PREPARE   , do_non_data_command ,  \"SECURITY ERASE PREPARE\"},
    {CMD_SECURITY_ERASE_UNIT       , do_pio_data_out_command     ,  \"SECURITY ERASE UNIT\"},
    {CMD_SECURITY_FREEZE_LOCK     , do_non_data_command  ,  \"SECURITY FREEZE LOCK\"},
    {CMD_SECURITY_DISABLE_PASSWORD , do_pio_data_out_command  , \"SECURITY DISABLE PASSWORD\"},
    {CMD_READ_NATIVE_MAX_ADDRESS , do_non_data_command  , \"READ NATIVE MAX ADDRESS\"},
    {CMD_SET_MAX_ADDRESS , do_non_data_command  , \"SET MAX ADDRESS\"}
};

/*
int scanpara(char *fmt, ...);

int scanpara(char *fmt, ...)
{
        int count;
        va_list arglist;
        va_start(arglist, fmt);
        count = vscanf(fmt, arglist);
        va_end(arglist);
        return count;
}
*/

int do_non_data_command(void)
{
if(wait_not_busy())
return 1;
scan_set_para(mode);
set_int_poll(int_poll);
send_ata_cmd(command);
wait_not_busy_alternate();
if(int_poll == INT_MODE)
wait_int_assert();
check_status();
if(check_error())
return 1;
return 0;
}

int do_smart_command(void)
{
if(wait_not_busy())
return 1;        
scan_set_para(mode);
set_int_poll(int_poll);
send_ata_cmd(command);
if(check_error())
return 1;
if(!int_poll)
while(1)
if(interrupt_flag == 1)
goto __end;
__end:
return 0;
}


int do_pio_data_in_command(void)
{
if(wait_not_busy())
return 1;        
scan_set_para(mode);
set_int_poll(int_poll);
    send_ata_cmd(command);
if(int_poll == INT_MODE)
{
if(wait_int_assert())
return 1;
check_status();
if(check_error())
return 1;
}
else
{
wait_not_busy_alternate();
check_status();
if(check_error())
return 1;
if(wait_data_request_ready())
return 1;
}

pio_rep_readw(io_base + HD_DATA, (unsigned char far *)buffer, 256 * g_count);
    display(buffer, 512 * g_count);
return 0;
}


int do_pio_data_out_command(void)
{
if(wait_not_busy())
return 1;        

scan_set_para(mode);
set_int_poll(int_poll);
    send_ata_cmd(command);
if(wait_not_busy())
return 1;
if(wait_data_request_ready())
return 1;
fill_buffer(buffer, 512 * g_count);
pio_rep_writew(io_base + HD_DATA, (unsigned char far *)buffer, 256 * g_count);

if(int_poll == INT_MODE)
{
if(wait_int_assert())
return 1;
check_status();
if(check_error())
return 1;
}
else
{
wait_not_busy_alternate();
check_status();
if(check_error())
return 1;
}
    display(buffer, 512 * g_count);
return 0;
}

int do_packet_command(void)
{
printf(\"Not Implemented\\n\");
return 0;
}

int do_dma_command(void)
{
    unsigned long lba_addr;
    unsigned long dst_addr;
unsigned long tbl_addr;
struct pci_device pcid;

unsigned short ata_bus_master_regs_base;

clean_buffer();

if(!find_device(0x0101, &pcid))
{
printf(\"Can not find PCI IDE Bus Master Controler!!!\\n\");
release_device_list(first_pci_device);
return 1;
}

if(wait_not_busy())
return 1;

scan_set_para(mode);
enable_hdd_int();

dst_addr = align_to_word(buffer);
        if((command == CMD_WRITE_DMA_R) || (command == CMD_WRITE_DMA_N))
            fill_buffer_far((unsigned char far *)MK_FP((unsigned short)(dst_addr >> 4), (unsigned short)(dst_addr & 0x0000000FL)), 512 * g_count);
tbl_addr = align_to_dword(table);
tbl_addr = setup_prd(dst_addr, tbl_addr, g_count);

ata_bus_master_regs_base = ((struct func_config_space *)(pcid.config_space))->base_addr_4;
ata_bus_master_regs_base &= 0xFFFE;

if(!check_dma_capable(ata_bus_master_regs_base))
{
release_device_list(first_pci_device);
return 1;
}

if((command == CMD_READ_DMA_R) || (command == CMD_READ_DMA_N))
                setup_xfr(ata_bus_master_regs_base, tbl_addr, 1);
else if((command == CMD_WRITE_DMA_R) || (command == CMD_WRITE_DMA_N))
                setup_xfr(ata_bus_master_regs_base, tbl_addr, 0);

send_ata_cmd(command);

enable_channel(ata_bus_master_regs_base);

if(check_error())
{
release_device_list(first_pci_device);
return 1;
}

    check_int_assert(ata_bus_master_regs_base);

disable_channel(ata_bus_master_regs_base);

display_far((unsigned char far *)MK_FP((unsigned short)(dst_addr >> 4), (unsigned short)(dst_addr & 0x0000000FL)), 512 * g_count);
release_device_list(first_pci_device);
return 0;
}

int do_read_write_dma_queued_command(void)
{
printf(\"Not Implemented\\n\");
return 0;
}

int do_device_reset_command(void)
{
printf(\"Not Implemented\\n\");
return 0;
}

int do_device_diagnose_command(void)
{
printf(\"Not Implemented\\n\");
return 0;
}
/*****************************/
#ifndef _PORTDEF_H_
#define _PORTDEF_H_

#define HD_DATA 0x00 /* I/O */
#define HD_ERRREG 0x01 /* I */
#define HD_FEATURE 0x01 /* O */
#define HD_SECCNT 0x02 /* I/O */
#define HD_SECNO 0x03 /* I/O */
#define HD_CYLNOLO 0x04 /* I/O */
#define HD_CYLNOHI 0x05 /* I/O */

#define HD_DRVHEAD 0x06 /* I/O */
/*
CHS mode
bit 7 r/w 1
bit 6 r/w mode
0 CHS
bit 5 r/w 1
bit 4 r/w device
0 master
1 slave
bit 3~5 r/w head

LBA mode
bit 7 r/w 1
bit 6 r/w mode
1 LBA
bit 5 r/w 1
bit 4 r/w device
0 master
1 slave
bit 5~3 r/w LBA address bit 27~24
*/



#define HD_STATUS 0x07 /* I */
#define HD_COMMAND 0x07 /* O */
#define HD_SUBSTAT 0x206 /* I */
#define HD_ADPTREG 0x206 /* O */
#define HD_DRVADDRREG 0x207 /* I */


#define HD_LBA_7_0 0x03
#define HD_LBA_15_8 0x04
#define HD_LBA_23_16 0x05
#define HD_LBA_28_24 0x06



#endif

kelvin9230兄,我比较的菜，你能不能把你写的东东稍微详细解释一下阿。