c语言－遍历pci设备（2）mmio访问

前言

今天其实我在公司也没有做什么，但是昨天就把pcie遍历的mmio形式做了出来，赞扬公司的台湾服务器，至少我可以使用google来去搜索我想要的资料和答案，有一位大神在台湾的论坛上发布了一片博文，针对dos环境下的mmio的方法，在国内通过百度等等方法是无法访问到的，当然最让人失望的是，如果我不开代理，直接输入网址也是无法进入的，可能有很多人觉得你遍历pcie干吗？嘿嘿，那就是告诉你如何通过代码去访问我门电脑里面最底层的设备，这是一种极其需要能力的。好了，不扯皮了，小编带你通过c语言与汇编的模式进入dos环境访问以及Linux系统的各类方法。

mmio

可能有很多人对mmio的访问模式有一定的疑问，那么现在小编就给大家普及一下，当然有很多资料都是来自于网络，小编参考了太多的资料，在这里便不一一道谢了。说到mmio，小编会给大家普及一些概念，特别时4gb地址空间的一些概念，这些概念有助于各位去理解。

MMIO(Memory mapping I/O)即内存映射I/O，它是PCI规范的一部分，I/O设备被放置在内存空间而不是I/O空间。从处理器的角度看，内存映射I/O后系统设备访问起来和内存一样。这样访问AGP/PCI-E显卡上的帧缓存，BIOS，PCI设备就可以使用读写内存一样的汇编指令完成，简化了程序设计的难度和接口的复杂性。I/O作为CPU和外设交流的一个渠道，主要分为两种，一种是Port I/O，一种是MMIO(Memory mapping I/O)。

那么说到这些必须得提到内存映射，内存映射的机制在我们想访问pci-e的机制中是非常有用的。

内存映射，简而言之就是将用户空间的一段内存区域映射到内核空间，映射成功后，用户对这段内存区域的修改可以直接反映到内核空间，同样，内核空间对这段区域的修改也直接反映用户空间。那么对于内核空间<—->用户空间两者之间需要大量数据传输等操作的话效率是非常高的。

dos环境的mmio方式遍历pci-e

在dos环境下，你需要打开保护机制，进行访问32位的数据格式，在dos是16位访问的，然后通过相应的汇编及机器码进行，进行相关的操作，小编对此也不是非常了解，大家不妨去参考台湾那个大神的博客，我也是参考他的博客做出的dos系统下的编程。

#include<stdio.h>
#include<dos.h>
#define BaseAddr 0xF8000000
typedef unsigned long DWORD;
//open
void openA20()
{ while(inp(0x64) & 2); outp(0x64,0xd1);
while(inp(0x64) & 2); outp(0x60,0xdf);
while(inp(0x64) & 2); outp(0x64,0xff);
}
unsigned long GDT_def[]={0,0,0x0000FFFF,0x008F9200};
unsigned char GDT_Addr[6]={0};
void set4gb()
{ asm{
    cli
    push ds ; push es
    mov word ptr GDT_Addr[0], (2*8-1)
    mov eax,ds
    shl eax,4
    xor ebx,ebx
    mov bx,offset GDT_def
    add eax,ebx
    mov dword ptr GDT_Addr[2],eax
    lgdt fword ptr GDT_Addr
    mov bx,8
    mov eax,cr0
    or al,1
    mov cr0,eax
    jmp flush1
    }
    flush1: asm{
    mov ds,bx
    mov es,bx
    and al,0feh
    mov cr0,eax
    jmp flush2
    }
    flush2: asm{
    pop es ; pop ds
    sti
    }
}
DWORD ReadMemByPM(DWORD addr)
{
    DWORD result;
    _asm{
    push ds;
    mov ax,0;
    mov ds,ax;
    mov esi,addr;
    mov eax,[esi];
    mov result,eax;
    pop ds;
    }
    return result;
}

DWORD ReadMem(DWORD mAddr)
{
    #ifdef DEBUG
    printf("this Memory is 0x%llX\n",mAddr);
    #endif
    DWORD result=0;
    _asm{
        push eax;
        mov eax,[mAddr];
        mov result,eax;
        pop eax;
    }
    return result;
}
int main(){
    DWORD busNum,devNum,funNum,result=0,addr,CabID,mOffset,DevPortType;
    DWORD vendorID,deviceID,LinkWidth,LinkSpeed;
    char* PortType[]={"PCI-E Endpoint","Leg PCIE Endpoint"," Root Complex","Upstream PCI-E Switch","Downstream PCI-E Switch","PCI-E to PCI Bridge","PCI to PCI-E Bridge","Igrd Endpoint","Event Collector","null"},TypeIndex;
    char* SpeedType[]={"2.5G/S","2.5G/S OR 5G/S","2.5G/S OR 5G/S OR 8G/S","NO Speed"},SpeedIndex;
    openA20();
    set4gb();
    printf("busNum devNum  funNum\t vendorID  deviceID  type\tWidth\tSpeed\n");
    for(busNum=0;busNum<16;busNum++)
        for(devNum=0x0;devNum<32;devNum++)
            for(funNum=0;funNum<8;funNum++)
            {
                addr=(0xF8000000)|(busNum<<20)|(devNum<<15)|(funNum<<12);
                result=ReadMemByPM(addr);
                if(result!=0xffffffff)
                {
                    result=ReadMemByPM(addr|0x34);
                    mOffset=result&0x000000ff;
                    LinkWidth=0;
                    LinkSpeed=0;
                    while(1)
                    {
                        result=ReadMemByPM(addr|mOffset);
                        CabID=result&0x000000ff;
                        if(CabID == 0x00000010){
                            result=ReadMemByPM(addr);
                            vendorID=result&0x0000ffff;
                            deviceID=(result&0xffff0000)>>16;
                            result=ReadMemByPM(addr|mOffset);
                            DevPortType=(result&0x00f00000)>>20;
                            switch(DevPortType)
                            {
                                case 0x0:TypeIndex = 0;break;
                                case 0x1:TypeIndex = 1;break;
                                case 0x4:TypeIndex = 2;break;
                                case 0x5:TypeIndex = 3;break;
                                case 0x6:TypeIndex = 4;break;
                                case 0x7:TypeIndex = 5;break;
                                case 0x8:TypeIndex = 6;break;
                                case 0x9:TypeIndex = 7;break;
                                case 0xa:TypeIndex = 8;break;
                                default:TypeIndex = 9;break;
                            }
                            result=ReadMemByPM(addr+mOffset+0x0C);
                            LinkSpeed=(result&0x0000000f);
                            switch(LinkSpeed){
                                case 0x1:SpeedIndex = 0;break;
                                case 0x2:SpeedIndex = 1;break;
                                case 0x3:SpeedIndex = 2;break;
                                default:SpeedIndex = 3;break;
                            }
                            LinkWidth=(result&0x000003f0)>>4;
                            printf("%2.2llx \t%2.2llx\t  %2.2llx\t %4.4llx\t     %4.4llx %s   X%2lu  %s\n",busNum,devNum,funNum,vendorID,deviceID,PortType[TypeIndex],LinkWidth,SpeedType[SpeedIndex]);
                            break;
                        }else{
                        mOffset=(result&0x0000ff00)>>8;
                        if(mOffset==0x00000000)
                         break;
                         }
                    }
                }
            }
  return 0;
}

在这里需要注意的是你的电脑的基地址并非是0xF8000000。

linux环境下

提到linux就不得不说Linux下的一个api，mmap.

mmap系统调用

mmap将一个文件或者其它对象映射进内存。文件被映射到多个页上，如果文件的大小不是所有页的大小之和，最后一个页不被使用的空间将会清零。munmap执行相反的操作，删除特定地址区域的对象映射。

当使用mmap映射文件到进程后,就可以直接操作这段虚拟地址进行文件的读写等操作,不必再调用read,write等系统调用.但需注意,直接对该段内存写时不会写入超过当前文件大小的内容.

采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝。对于像管道和消息队列等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次数据：一次从输入文件到共享内存区，另一次从共享内存区到输出文件。实际上，进程之间在共享内存时，并不总是读写少量数据后就解除映射，有新的通信时，再重新建立共享内存区域。而是保持共享区域，直到通信完毕为止，这样，数据内容一直保存在共享内存中，并没有写回文件。共享内存中的内容往往是在解除映射时才写回文件的。因此，采用共享内存的通信方式效率是非常高的。

基于文件的映射，在mmap和munmap执行过程的任何时刻，被映射文件的st_atime可能被更新。如果st_atime字段在前述的情况下没有得到更新，首次对映射区的第一个页索引时会更新该字段的值。用PROT_WRITE 和 MAP_SHARED标志建立起来的文件映射，其st_ctime 和 st_mtime在对映射区写入之后，但在msync()通过MS_SYNC 和 MS_ASYNC两个标志调用之前会被更新。

用法:

void *mmap(void *start, size_t length, int prot, int flags,int fd, off_t offset);

int munmap(void *start, size_t length);

返回说明：

成功执行时，mmap()返回被映射区的指针，munmap()返回0。失败时，mmap()返回MAP_FAILED[其值为(void *)-1]，munmap返回-1。errno被设为以下的某个值

  • EACCES：访问出错
  • EAGAIN：文件已被锁定，或者太多的内存已被锁定
  • EBADF：fd不是有效的文件描述词
  • EINVAL：一个或者多个参数无效
  • ENFILE：已达到系统对打开文件的限制
  • ENODEV：指定文件所在的文件系统不支持内存映射
  • ENOMEM：内存不足，或者进程已超出最大内存映射数量
  • EPERM：权能不足，操作不允许
  • ETXTBSY：已写的方式打开文件，同时指定MAP_DENYWRITE标志
  • SIGSEGV：试着向只读区写入
  • SIGBUS：试着访问不属于进程的内存区

    参数：

  • start：映射区的开始地址。
  • length：映射区的长度。
  • prot：期望的内存保护标志，不能与文件的打开模式冲突。是以下的某个值，可以通过or运算合理地组合在一起

>

* PROT_EXEC //页内容可以被执行

* PROT_READ //页内容可以被读取

* PROT_WRITE //页可以被写入

* PROT_NONE //页不可访问

  • flags：指定映射对象的类型，映射选项和映射页是否可以共享。它的值可以是一个或者多个以下位的组合体
  • MAP_FIXED //使用指定的映射起始地址，如果由start和len参数指定的内存区重叠于现存的映射空间，重叠部分将会被丢弃。如果指定的起始地址不可用，操作将会失败。并且起始地址必须落在页的边界上。
  • MAP_SHARED //与其它所有映射这个对象的进程共享映射空间。对共享区的写入，相当于输出到文件。直到msync()或者munmap()被调用，文件实际上不会被更新。
  • MAP_PRIVATE //建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件。这个标志和以上标志是互斥的，只能使用其中一个。
  • MAP_DENYWRITE //这个标志被忽略。
  • MAP_EXECUTABLE //同上
  • MAP_NORESERVE //不要为这个映射保留交换空间。当交换空间被保留，对映射区修改的可能会得到保证。当交换空间不被保留，同时内存不足，对映射区的修改会引起段违例信号。
  • MAP_LOCKED //锁定映射区的页面，从而防止页面被交换出内存。
  • MAP_GROWSDOWN //用于堆栈，告诉内核VM系统，映射区可以向下扩展。
  • MAP_ANONYMOUS //匿名映射，映射区不与任何文件关联。
  • MAP_ANON //MAP_ANONYMOUS的别称，不再被使用。
  • MAP_FILE //兼容标志，被忽略。
  • MAP_32BIT //将映射区放在进程地址空间的低2GB，MAP_FIXED指定时会被忽略。当前这个标志只在x86-64平台上得到支持。
  • MAP_POPULATE //为文件映射通过预读的方式准备好页表。随后对映射区的访问不会被页违例阻塞。
  • MAP_NONBLOCK //仅和MAP_POPULATE一起使用时才有意义。不执行预读，只为已存在于内存中的页面建立页表入口。
  • fd：有效的文件描述词。如果MAP_ANONYMOUS被设定，为了兼容问题，其值应为-1。

offset：被映射对象内容的起点。

系统调用munmap()

int munmap( void * addr, size_t len )

该调用在进程地址空间中解除一个映射关系，addr是调用mmap()时返回的地址，len是映射区的大小。当映射关系解除后，对原来映射地址的访问将导致段错误发生。

系统调用msync()

int msync ( void * addr , size_t len, int flags)

一般说来，进程在映射空间的对共享内容的改变并不直接写回到磁盘文件中，往往在调用munmap（）后才执行该操作。可以通过调用msync()实现磁盘上文件内容与共享内存区的内容一致。

系统调用mmap()用于共享内存的两种方式：

（1）使用普通文件提供的内存映射：适用于任何进程之间；此时，需要打开或创建一个文件，然后再调用mmap()；典型调用代码如下：

fd=open(name, flag, mode);

if(fd<0)

…

ptr=mmap(NULL, len , PROT_READ|PROT_WRITE, MAP_SHARED , fd , 0);

通过mmap()实现共享内存的通信方式有许多特点和要注意的地方

（2）使用特殊文件提供匿名内存映射：适用于具有亲缘关系的进程之间；由于父子进程特殊的亲缘关系，在父进程中先调用mmap()，然后调用fork()。那么在调用fork()之后，子进程继承父进程匿名映射后的地址空间，同样也继承mmap()返回的地址，这样，父子进程就可以通过映射区域进行通信了。注意，这里不是一般的继承关系。一般来说，子进程单独维护从父进程继承下来的一些变量。而mmap()返回的地址，却由父子进程共同维护。

对于具有亲缘关系的进程实现共享内存最好的方式应该是采用匿名内存映射的方式。此时，不必指定具体的文件，只要设置相应的标志即可.

mmap进行内存映射的原理

mmap系统调用的最终目的是将,设备或文件映射到用户进程的虚拟地址空间,实现用户进程对文件的直接读写,这个任务可以分为以下三步:

在用户虚拟地址空间中寻找空闲的满足要求的一段连续的虚拟地址空间,为映射做准备(由内核mmap系统调用完成)每个进程拥有3G字节的用户虚存空间。但是，这并不意味着用户进程在这3G的范围内可以任意使用，因为虚存空间最终得映射到某个物理存储空间（内存或磁盘空间），才真正可以使用。

那么，内核怎样管理每个进程3G的虚存空间呢？概括地说，用户进程经过编译、链接后形成的映象文件有一个代码段和数据段（包括data段和bss段），其中代码段在下，数据段在上。数据段中包括了所有静态分配的数据空间，即全局变量和所有申明为static的局部变量，这些空间是进程所必需的基本要求，这些空间是在建立一个进程的运行映像时就分配好的。除此之外，堆栈使用的空间也属于基本要求，所以也是在建立进程时就分配好的.

在内核中,这样每个区域用一个结构struct vm_area_struct 来表示.它描述的是一段连续的、具有相同访问属性的虚存空间，该虚存空间的大小为物理内存页面的整数倍。可以使用 cat /proc//maps来查看一个进程的内存使用情况,pid是进程号.其中显示的每一行对应进程的一个vm_area_struct结构.

下面是struct vm_area_struct结构体的定义：

#include <linux/mm_types.h>

/* This struct defines a memory VMM memory area. */

struct vm_area_struct {
struct mm_struct * vm_mm; /* VM area parameters */
unsigned long vm_start;
unsigned long vm_end;

/* linked list of VM areas per task, sorted by address */
struct vm_area_struct *vm_next;
pgprot_t vm_page_prot;
unsigned long vm_flags;

/* AVL tree of VM areas per task, sorted by address */
short vm_avl_height;
struct vm_area_struct * vm_avl_left;
struct vm_area_struct * vm_avl_right;

/* For areas with an address space and backing store,
vm_area_struct *vm_next_share;
struct vm_area_struct **vm_pprev_share;
struct vm_operations_struct * vm_ops;
unsigned long vm_pgoff; /* offset in PAGE_SIZE units, *not* PAGE_CACHE_SIZE */
struct file * vm_file;
unsigned long vm_raend;
void * vm_private_data; /* was vm_pte (shared mem) */
};

通常，进程所使用到的虚存空间不连续，且各部分虚存空间的访问属性也可能不同。所以一个进程的虚存空间需要多个vm_area_struct结构来描述。在vm_area_struct结构的数目较少的时候，各个vm_area_struct按照升序排序，以单链表的形式组织数据（通过vm_next指针指向下一个vm_area_struct结构）。但是当vm_area_struct结构的数据较多的时候，仍然采用链表组织的化，势必会影响到它的搜索速度。针对这个问题，vm_area_struct还添加了vm_avl_hight（树高）、vm_avl_left（左子节点）、vm_avl_right（右子节点）三个成员来实现AVL树，以提高vm_area_struct的搜索速度。

　　假如该vm_area_struct描述的是一个文件映射的虚存空间，成员vm_file便指向被映射的文件的file结构，vm_pgoff是该虚存空间起始地址在vm_file文件里面的文件偏移，单位为物理页面。

因此,mmap系统调用所完成的工作就是准备这样一段虚存空间,并建立vm_area_struct结构体,将其传给具体的设备驱动程序.

下面分享的是我写的linux的mmio遍历。

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/mman.h>
//#include<linux/pci.h>

//#define DEBUG1

#define PCI_MAX_BUS 2
#define PCI_MAX_DEV 31
#define PCI_MAX_FUN 7
#define PCI_BASE_ADDR 0xfc000000L
#define LEN_SIZE sizeof(unsigned long)
#define SIZE 4096

typedef unsigned int WORD;
typedef unsigned long DWORD;
typedef unsigned char BYTE;

void typeshow(BYTE Type){
    switch(Type){
      case 0x0f:{
               printf("endpoint\t");
               break;
                 }
      case 0x1f:{
             printf("legacy endpoint\t");
                 break;
               }
      case 0x4f:{
             printf("root complex\t");
                break;
              }
      case 0x5f:{
             printf("upstream pci-e switch\t");
             break;
                }
      case 0x6f:{
             printf("downstream pci-e switch\t");
             break;
             }
      case 0x7f:{
            printf("pci-e to pci bridge\t");
             break;
              }
      case 0x8f:{
             printf("pci to pci-e bridge\t");
             break;
              }
     case 0x9f:{
             printf("root co inte endpoint\t");
             break;
               }
     case 0xaf:{
             printf("root co event endpoint\t");
             break;
                }
     defult:{
             printf("b\t");
             break;
            }
      }

}

void speedshow(int speed){
    if(speed == 0x0){
            printf("speed is 2.5G/s\t");
         }
    else if(speed == 0x2){
            printf("speed is 5G/s\t");
         }
    else if(speed == 0x4){
            printf("speed is 8G/s\t");
         }
    else{
           printf("no speed!\t");
        }
}
void linkspeedshow(int flag){
     switch(flag){
         case 0x1:{
            printf("link speed 0\t");
            break;
              }
         case 0x2:{
            printf("link speed 1\t");
            break;
              }
         case 0x3:{
            printf("link speed 2\t");
            break;
              }
         case 0x4:{
            printf("link speed 3\t");
            break;
              }
         case 0x5:{
            printf("link speed 4\t");
            break;
              }
         case 0x6:{
            printf("link speed 5\t");
            break;
              }
         case 0x7:{
            printf("link speed 6\t");
            break;
              }
         default:
               {
             printf("no speed!\t");
              break;
              }
     }
}
void linkwidthshow(int flag){
    printf("linkwidth:");
    switch(flag){
           case 0x00:{
                   printf("reserved\t");
                   break;
                 }
           case 0x01:{
                   printf("x1\t");
                   break;
                 }
           case 0x02:{
                   printf("x2\t");
                   break;
                 }
           case 0x04:{
                   printf("x4\t");
                   break;
                 }
           case 0x08:{
                   printf("x8\t");
                   break;
                 }
           case 0x0c:{
                   printf("x12\t");
                   break;
                 }
           case 0x10:{
                   printf("x16\t");
                   break;
                 }
           case 0x20:{
                   printf("x32\t");
                   break;
                 }
           default:{
                    printf("null\t");
                 }
  }
}

int main()
{
    DWORD addr = 0;
    WORD bus,dev,fun;
    WORD* DATA;
    WORD* dwDATA;
    BYTE nextPoint;
    int fd,i = 1;
    fd = open("/dev/mem",O_RDWR);
    if(fd < 0)
    {
      printf("can‘t open port!\n");
    }
#ifdef DEBUG
    printf("fd = %d\n",fd);
#endif
     for(bus = 0; bus <= PCI_MAX_BUS; bus++)
        for(dev = 0; dev <= PCI_MAX_DEV; dev++)
           for(fun = 0; fun <= PCI_MAX_FUN; fun++)
              {
                 addr = 0;
                 addr = PCI_BASE_ADDR|(bus<<20)|(dev<<15)|(fun<<12);
                 DATA = mmap(NULL,LEN_SIZE,PROT_READ|PROT_WRITE,MAP_SHARED,fd,addr);
                 if(DATA == (void *)-1)
                 {
                     munmap(DATA,LEN_SIZE);
                     break;
                 }
                 if(*DATA != 0xffffffff)
                 {
                    nextPoint = (BYTE)(*(DATA+0x34/4));
                    dwDATA = DATA+nextPoint/4;
                     #ifdef DEBUG1
                    printf("nextpoint = %x\n",nextPoint);
                    printf("addr1=%x\n",*dwDATA);
                     #endif
                 while(1){
                    if((BYTE)*(dwDATA)==0x10)
                     {        

                             printf("PCI-E:");
                             printf("bus# = %x,dev# = %x,fun# = %x\t",bus,dev,fun);
                             printf("vender id:%.4x\t",*DATA&0xffff);
                             printf("device id:%.4x\t",((*DATA)>>8)&0XFFFF);
                             printf("\ntype:");
                             typeshow((BYTE)((*dwDATA)>>8)|0x0f);
                             speedshow(*(dwDATA+0x2c/4)>>1&0xf);
                          //   linkspeedshow(*(dwDATA+0x0c/4)&0xf);
                             linkwidthshow((*(dwDATA+0x0c/4)>>4)&0x3f);
                             printf("\n");
                             break;
                     }
                     dwDATA = DATA+((*(dwDATA)>>8)&0xff)/4;
                     #ifdef DEBUG1
                     printf("dwDATA = %x\n",*dwDATA);
                     #endif

                     if((BYTE)(*(dwDATA)) == 0x00)
                     break;
                     }
                 #ifdef DEBUG
                    printf("bus = %x,dev = %x,fun = %x\n",bus,dev,fun);
                    for(i = 0; i < 0;i++)
                    {
                        printf("data%d:%x\n",i,*(DATA+i));
                    }
                   printf(" next Point:%x\n",nextPoint);
                   printf("data:%x\n",(BYTE)*(DATA+nextPoint/4));
                 #endif

                 }
                  munmap(DATA,LEN_SIZE);
              }
    close(fd);
    return 0;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-11-03 21:13:08

c语言－遍历pci设备（2）mmio访问的相关文章

系统虚拟化学习笔记——PCI设备

内容摘自<系统虚拟化:原理与实现> PCI 总线架构 PCI总线是典型的树结构.把北桥中host-PCI桥看做根,总线中其他PCI-PCI桥,PCI-ISA桥(ISA总线转PCI总线桥)等桥设备和 直接连PCI总线的设备看做节点,整个PCI架构可以概括成下图: 通过桥,PCI可以很容易被扩展,并且与其他总线相互挂接,构成整个系统的总线网络.与HOST-PCI桥相连的总线称为总线0, 其他层次总线的编号,是在BIOS(或者操作系统)枚举设备时确定的. 设备标识符 设备标识符可以看做设备在PCI总

PCI 设备详解一

2016-10-09 其实之前是简单学习过PCI设备的相关知识,但是总感觉 自己的理解很函数,很多东西说不清楚,正好今天接着写这篇文章自己重新梳理一下,文章想要分为三部分,首先介绍PCI设备硬件相关的知识,然后介绍LINux内核中对PCI设备的支持.本节讲第一部分. PCI总线在目前计算机总线系统中占据举足轻重的地位,其良好的扩展性,地址统一分配和总线竞争的处理相对于其他总线而言都具有绝对优势. 扩展性: 先说其扩展性,PCI总线上存在若干PCI设备插槽,当PCI插槽无法满足需求,就可以通过PC

pci设备学习笔记

水平有限,错误难免 ^_^ 参考资料: 1) <Linux内核源代码情景分析> 2)  Linux内核源代码(2.6.32). 本文只讨论比较简单的软硬件配置场景. 系统中的第一条PCI总线(即主PCI总线),挂在"宿主-PCI桥"上. CPU通过"宿主--PCI桥"就可以访问主PCI总线了. PC机中通常只有一个"宿主-PCI桥".但是,通过引入其他类型的PCI桥,可以将更多的总线(可以是PCI总线,也可以是ISA总线)连接到主PC

Linux下PCI设备驱动程序开发 --- PCI驱动程序实现（三）

三.PCI驱动程序实现 1. 关键数据结构 PCI设备上有三种地址空间:PCI的I/O空间.PCI的存储空间和PCI的配置空间.CPU可以访问PCI设备上的所有地址空间,其中I/O空间和存储空间提供给设备驱动程序使用,而配置空间则由Linux内核中的PCI初始化代码使用.内核在启动时负责对所有PCI设备进行初始化,配置好所有的PCI设备,包括中断号以及I/O基址,并在文件/proc/pci中列出所有找到的PCI设备,以及这些设备的参数和属性. Linux驱动程序通常使用结构(struct)来表示

C语言遍历文件和目录——————【Badboy】

[cpp] #include #include #include #include #include #include #include #define MAX_PATH_LENGTH 512 #define MAX_FILE_EXTENSION 9 unsigned long visit_dirs = 0; unsigned long visit_files = 0; void listdir(char *path){ DIR *ptr_dir; struct dirent *dir_entr

PCI设备内存操作函数总结

1．  ExAllocatePool() 函数说明: ExAllocatePool allocates pool memory of the specified type and returns a pointer to the allocated block. 函数定义: PVOID ExAllocatePool( __in  POOL_TYPE PoolType, __in  SIZE_T NumberOfBytes ); 代码中用来分配设备描述DMA adepter设备的特性(DEVICE

利用 PlxSdk 工具包开发 Linux 下 PCI 设备驱动

最近实验室需要做一个 Linux 与 FPGA 之间的快速接口,考虑高速的特性,选择了 PCI 接口实现. FPGA 选择 altera 的 EP2C20F484C8 PCI 接口芯片选择 PLX8311 操作系统选择 ubuntu10.04 1.Linux 检测 PCI 将板卡插入到主机 PCI 插槽内,开机,通过 lspci 命令可以检测到当前系统下所有的 PCI 设备. 02:00.0 PCI bridge: PLX Technology, Inc. PEX 8111 PCI Expres

Mac OS X下的USB设备连接与访问

由于COM协议的广泛使用,很多设备虽然接口改为了USB,但内部数据通讯协议仍然使用的是COM(即传统的RS232串口协议,新的使用TTL).很多设备使用了PL2302/CH340/FTDI等芯片来通过USB模拟出串口协议,如Arduino/NodeMCU等都采用类似的机制. 在Windows下,安装驱动程序后可以直接在"设备管理器"找到模拟的COM设备(找不到的话,可能驱动有问题了,有时候重新启动或重新安装能解决).在Linux下可以通过lsusb和dmesg列出USB端口和所模拟的C

wdmWin10下遍历PCI配置空间

图右边是引用驱动开发技术详解书中的代码:3环只增加了个死循环 驱动没变 #include <windows.h> #include <stdio.h> //使用CTL_CODE必须加入winioctl.h #include <winioctl.h> #include "Ioctls.h" DWORD In_32(HANDLE hDevice, USHORT port) { DWORD dwOutput; DWORD inputBuffer[2] =