remap PCI memory в user-space

static int my_mmap(struct file *filp, struct vm_area_struct *vma)
{
        struct my_dev *dev = (struct my_dev *)filp->private_data;
        resource_size_t addr;
        unsigned long len, pfn;
        int bar = vma->vm_pgoff;

        if (bar >= PCI_BARS_NUM)
                return -EINVAL;

        len = pci_resource_len(dev->pdev, bar);
        if (!len)
                return -EINVAL;

        if (PAGE_ALIGN(len) != PAGE_ALIGN(vma->vm_end - vma->vm_start))
                return -EINVAL;

        addr = pci_resource_start(dev->pdev, bar);
        pfn  = virt_to_phys(bus_to_virt(addr)) >> PAGE_SHIFT;

        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
        vma->vm_flags |= VM_IO;

        if (io_remap_pfn_range(vma, vma->vm_start, pfn,
                               len, vma->vm_page_prot)) {
                printk(KERN_ERR "mmap: io_remap_pfn_range failed\n");
                return -EAGAIN;
        }

        printk("mmap: bar=%d, offset=%llx\n", bar, addr & (~PAGE_MASK));
        return 0;
}

static int uni_mmap(struct file *file, struct vm_area_struct *vma)
{
    unsigned int minor = MINOR(file->f_dentry->d_inode->i_rdev);
    image_desc_t *p;


    file->private_data =  pciBase;//&image[minor];
   // p = file->private_data;



printk("\n\runi_mmap minor:%i phys_start:0x%X",minor,pciBase);


if (minor < MAX_IMAGE) {                     // master image
        
	if (vma->vm_end - vma->vm_start > 0x10000){ //p->size) {
            printk ("Uni mmap: INVALID, start at 0x%08lx end 0x%08lx,pstart 0x%08x, pend 0x%08x\n", vma->vm_start,vma->vm_end, pciBase, pciBase+0x10000);//p->phys_start, p->phys_end);
            return -EINVAL;
        }

        vma->vm_pgoff = virt_to_phys(bus_to_virt(pciBase)) >> PAGE_SHIFT; //p->phys_start >> PAGE_SHIFT;
	printk("\n\r\t\t pg_off:0x%X ",vma->vm_pgoff);
	//vma->vm_pgoff << PAGE_SHIFT
    }


    if ((minor == CONTROL_MINOR) || (minor > MAX_MINOR))
        return -EBADF;

         vma->vm_flags |= VM_IO;
         vma->vm_flags |= VM_RESERVED;

	 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

    if (io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
                        vma->vm_end - vma->vm_start, vma->vm_page_prot) != 0) {
        printk("Uni mmap: remap_pfn_range failed !\n");
        return (-EAGAIN);
    }

    vma->vm_file = file;

       
   


return 0;


}

...
pciBase=getPciBase(0x1000);
...

static u32 getPciBaseAddr(u32 size)
{
    #define MEM_START 0x40000000
    #define MEM_STOP  0xF0000000
    u32 pciAddr, stepping = 0x01000000;

    for (pciAddr = MEM_START; pciAddr < MEM_STOP; pciAddr += stepping)
        if (check_mem_region(pciAddr, size) == 0)
            break;

    if (pciAddr >= MEM_STOP) {
        printk(" \n\r mem request stepping /= 10 \n");
        stepping /= 10;
        for (pciAddr = MEM_START; pciAddr < MEM_STOP; pciAddr += stepping)
            if (check_mem_region(pciAddr, size) == 0)
                break;
    }

    if (pciAddr >= MEM_STOP)
        {
	printk("\n\rerror mem request");
	return 0;
	}
	printk("\n\rZulu: request_mem_region ok!; pciAddr:0x%X size:0x%X  \n",pciAddr,size);
    request_mem_region(pciAddr, size, "uni");

    return pciAddr;

}

 uni_dev = pci_get_device(0x10e3,0x0000, uni_dev);
    if (!uni_dev) {
        printk("Uni device not found!\n");
        return -1;
    }

    pci_write_config_dword(uni_dev, PCI_MISC0, 0); // Turn latency off

    printk("Uni found at bus %x device %x\n",
           uni_dev->bus->number, uni_dev->devfn);
//---------------------------------------------------------------------------------zulu-------------------------------------
    pci_read_config_dword(uni_dev, PCI_CSR, &status);
    printk(" Vendor = %04X Device = %04X Status = %08X",
           uni_dev->vendor, uni_dev->device, status);
    printk("  Class = %08X\n", uni_dev->class);

    pci_read_config_dword(uni_dev, PCI_MISC0, &temp);
    printk("  Misc0 = %08X\n", temp);

    // Setup Universe Config Space
    // This is a 4k wide memory area that needs to be mapped into the
    // kernel virtual memory space so we can access it.

    pci_write_config_dword(uni_dev, PCI_BS, CONFIG_REG_SPACE); //zulu #define CONFIG_REG_SPACE 0xA0000000

    pci_read_config_dword(uni_dev, PCI_BS, &ba);
    baseaddr = (void __iomem *) ioremap_nocache(ba, 4096);