static u64* dma_buf_virt_core_addr_ptr;
static dma_addr_t  dma_bus_addr_for_fpga;

#ifndef VM_RESERVED
#define VM_RESERVED    (VM_DONTEXPAND | VM_DONTDUMP)
#endif

struct mmap_info
{
    uint64_t* data;
    int reference;
};

void mmap_open(struct vm_area_struct* vma)
{
    struct mmap_info* info = (struct mmap_info*)vma->vm_private_data;
    info->reference++;
}

void mmap_close(struct vm_area_struct* vma)
{
    struct mmap_info* info = (struct mmap_info*)vma->vm_private_data;
    info->reference--;
}

static int mmap_fault(struct vm_area_struct* vma, struct vm_fault* vmf)
{
    // если в user space был отмаплен буфер с помощью функции mmap, в которую передали размер буфера 65536,
    // то здесь (vma->vm_end - vma->vm_start) как раз будет равно 65536,
    // то есть делаю вывод, что vma соотносится с созданным буфером в user space.
    struct page* page;
    struct mmap_info* info;

    info = (struct mmap_info*)vma->vm_private_data;
    if (!info->data)
    {
        printk( KERN_INFO "[ag_pcie_driver]:[mmap_fault]: no data");
        return 0;
    }
    
    //get the page
    page = virt_to_page(info->data);
    // increment the reference count of this page
    get_page(page);
    
    vmf->page = page;
    return 0;
}

struct vm_operations_struct mmap_vm_ops =
{
    .open = mmap_open,
    .close = mmap_close,
    .fault = mmap_fault,
};

int mmapfop_mmap(struct file* filp, struct vm_area_struct* vma)
{
    vma->vm_ops = &mmap_vm_ops;
    vma->vm_flags |= VM_RESERVED;
    vma->vm_private_data = filp->private_data;
    mmap_open(vma);
    return 0;
}

int mmapfop_close(struct inode* inode, struct file* filp)
{
    filp->private_data = NULL;
    return 0;
}

int mmapfop_open(struct inode* inode, struct file* filp)
{
    struct mmap_info* info = kmalloc(sizeof(struct mmap_info),GFP_KERNEL);
    info->data = dma_buf_virt_core_addr_ptr;
    filp->private_data = info;
    return 0;
}

static const struct file_operations mmap_fops =
{
    .owner = THIS_MODULE,
    .open = mmapfop_open,
    .release = mmapfop_close,
    .mmap = mmapfop_mmap
};

static struct miscdevice ag_user_struct_miscdevice3 =
{
    MISC_DYNAMIC_MINOR,
    "ag_pcie_driver3",
    &mmap_fops
};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static int ag_pciedr_probe( struct pci_dev *dev, const struct pci_device_id *id )
{
   ....
   // выделяю буфер в пространстве ядра
   dma_buf_virt_core_addr_ptr = pci_alloc_consistent( dev, 4194304, &dma_bus_addr_for_fpga);
  
   // передаю в ПЛИС шинный адрес
   iowrite32( (u32)((dma_bus_addr_for_fpga))               ,  0x10);    //low
   iowrite32( (u32)((dma_bus_addr_for_fpga>>32)&0xffffffff), 0x14);    //high
   ....
}


........

ssize_t g_file_fid3 = open ("/dev/ag_pcie_driver3", O_RDWR);

char* g_ptr_mmap3 = (char*)mmap( NULL, 65536, PROT_READ | PROT_WRITE, MAP_SHARED, g_file_fid3, 0);

uint32_t* ptr = (uint32_t*)g_ptr_mmap3;  // для удобства

#define AG_DEF_DMA_SIZE 4194304

static u64* dma_buf_virt_core_addr_ptr;
static dma_addr_t  dma_bus_addr_for_fpga;

//////////////////////////////////////////////////////////////////////////////////////////////////////
// Мапинг буфера, созданного в виртуальном пространстве ядра с помощью функции dma_alloc_coherent(),
// в виртуальное пространство пользователя
static int kernel_buf_mmap(struct file *file, struct vm_area_struct *vma)
{
    if (remap_pfn_range( vma, vma->vm_start, virt_to_phys((void *)dma_buf_virt_core_addr_ptr) >> PAGE_SHIFT, vma->vm_end - vma->vm_start, vma->vm_page_prot))
    {
        return -EAGAIN;
    }
    return 0;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////
int kernel_buf_open(struct inode *inode, struct file *file)
{
    printk( KERN_INFO "[ag_pcie_driver]:[kernel_buf_open]: kernel_buf_open success");
    return 0;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////
static const struct file_operations kernel_buf_fops =
{
    .owner          = THIS_MODULE,
    .open            = kernel_buf_open,
    .mmap            = kernel_buf_mmap

};

//////////////////////////////////////////////////////////////////////////////////////////////////////
static struct miscdevice ag_user_struct_miscdevice_kernel_buf =
{
    MISC_DYNAMIC_MINOR,
    "ag_pcie_driver_kernel_buf",
    &kernel_buf_fops
};


//********************************************************************//
// Зондирующая функция в драйвере PCI
static int ag_pciedr_probe( struct pci_dev *dev, const struct pci_device_id *id )
{
    .......
    dma_buf_virt_core_addr_ptr = dma_alloc_coherent( &dev->dev, AG_DEF_DMA_SIZE, &dma_bus_addr_for_fpga, GFP_KERNEL);
    .......
}


//********************************************************************//
static int __init ag_pcie_driver_init(void)
{
    ..........
    res = misc_register(&ag_user_struct_miscdevice_kernel_buf);
    ..........
}
    
//*********************************************************************//
static void __exit ag_pcie_driver_exit(void)
{
    ..........
    misc_deregister(&ag_user_struct_miscdevice_kernel_buf);
    ..........
}

zcat /proc/config.gz | grep CMA