Linux kernel device driver to DMA from a device into user-space memory

Básicamente tienes la idea correcta: en la versión 2.1, puedes hacer que el espacio de usuario asigne cualquier memoria antigua. Lo quieres alineado con la página, por lo que posix_memalign() es una API útil para usar.

Entonces haga pasar el espacio de usuario en la dirección virtual del espacio de usuario y el tamaño de este búfer de alguna manera; ioctl() es una buena forma rápida y sucia de hacer esto. En el núcleo, asignar una matriz de búfer de tamaño adecuado de struct page* -- user_buf_size/PAGE_SIZE entries entries y use get_user_pages() para obtener una lista de la página de estructura* para el búfer del espacio de usuario.

Una vez usted tiene que, usted puede asignar una matriz de struct scatterlist que es del mismo tamaño que su matriz de página y bucle a través de la lista de páginas haciendo sg_set_page(). Después de configurar la lista sg, lo hace dma_map_sg() en la matriz de scatterlist y luego puede obtener sg_dma_address y sg_dma_len para cada entrada en la lista de dispersión (tenga en cuenta que debe usar el valor devuelto de dma_map_sg() porque puede terminar con menos entradas asignadas porque las cosas pueden fusionarse con el código de asignación DMA).

Eso le da todas las direcciones de autobús para pasar a su dispositivo, y luego puede activar el DMA y esperar a que lo desee. El esquema basado en read () que tienes probablemente esté bien.

Puede hacer referencia a drivers/infiniband/core/umem.c, específicamente ib_umem_get(), para algún código que construye esta asignación, aunque la generalidad con la que ese código necesita lidiar puede hacerlo un poco confuso.

Alternativamente, si su dispositivo no maneja las listas de dispersión/recopilación demasiado bien y desea una memoria contigua, puede usar get_free_pages() para asigne un búfer físicamente contiguo y use dma_map_page() en eso. Para dar acceso en espacio de usuario a esa memoria, su controlador solo necesita implementar un método mmap en lugar del ioctl como se describió anteriormente.

En algún momento quise permitir que la aplicación de espacio de usuario asignara búferes DMA y lo mapeara al espacio de usuario y obtuviera la dirección física para poder controlar mi dispositivo y hacer transacciones DMA (dominio de bus) completamente desde el espacio de usuario, evitando totalmente el kernel de Linux. Sin embargo, he utilizado un enfoque un poco diferente. Primero comencé con un módulo de núcleo mínimo que inicializaba / probaba el dispositivo PCIe y creaba un dispositivo de caracteres. Ese controlador entonces permitió un espacio de usuario aplicación para hacer dos cosas:

1. Asigna la barra de E/S del dispositivo PCIe al espacio de usuario usando la función remap_pfn_range().
2. Asigne y libere buffers DMA, mapéelos al espacio de usuario y pase una dirección de bus física a la aplicación de espacio de usuario.

Básicamente, se reduce a una implementación personalizada de mmap() call (aunque file_operations). Uno para la barra de E/S es fácil:

struct vm_operations_struct a2gx_bar_vma_ops = {
};

static int a2gx_cdev_mmap_bar2(struct file *filp, struct vm_area_struct *vma)
{
    struct a2gx_dev *dev;
    size_t size;

    size = vma->vm_end - vma->vm_start;
    if (size != 134217728)
        return -EIO;

    dev = filp->private_data;
    vma->vm_ops = &a2gx_bar_vma_ops;
    vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
    vma->vm_private_data = dev;

    if (remap_pfn_range(vma, vma->vm_start,
                        vmalloc_to_pfn(dev->bar2),
                        size, vma->vm_page_prot))
    {
        return -EAGAIN;
    }

    return 0;
}

Y otro que asigna búferes DMA usando pci_alloc_consistent() es un poco más complicado:

static void a2gx_dma_vma_close(struct vm_area_struct *vma)
{
    struct a2gx_dma_buf *buf;
    struct a2gx_dev *dev;

    buf = vma->vm_private_data;
    dev = buf->priv_data;

    pci_free_consistent(dev->pci_dev, buf->size, buf->cpu_addr, buf->dma_addr);
    buf->cpu_addr = NULL; /* Mark this buffer data structure as unused/free */
}

struct vm_operations_struct a2gx_dma_vma_ops = {
    .close = a2gx_dma_vma_close
};

static int a2gx_cdev_mmap_dma(struct file *filp, struct vm_area_struct *vma)
{
    struct a2gx_dev *dev;
    struct a2gx_dma_buf *buf;
    size_t size;
    unsigned int i;

    /* Obtain a pointer to our device structure and calculate the size
       of the requested DMA buffer */
    dev = filp->private_data;
    size = vma->vm_end - vma->vm_start;

    if (size < sizeof(unsigned long))
        return -EINVAL; /* Something fishy is happening */

    /* Find a structure where we can store extra information about this
       buffer to be able to release it later. */
    for (i = 0; i < A2GX_DMA_BUF_MAX; ++i) {
        buf = &dev->dma_buf[i];
        if (buf->cpu_addr == NULL)
            break;
    }

    if (buf->cpu_addr != NULL)
        return -ENOBUFS; /* Oops, hit the limit of allowed number of
                            allocated buffers. Change A2GX_DMA_BUF_MAX and
                            recompile? */

    /* Allocate consistent memory that can be used for DMA transactions */
    buf->cpu_addr = pci_alloc_consistent(dev->pci_dev, size, &buf->dma_addr);
    if (buf->cpu_addr == NULL)
        return -ENOMEM; /* Out of juice */

    /* There is no way to pass extra information to the user. And I am too lazy
       to implement this mmap() call using ioctl(). So we simply tell the user
       the bus address of this buffer by copying it to the allocated buffer
       itself. Hacks, hacks everywhere. */
    memcpy(buf->cpu_addr, &buf->dma_addr, sizeof(buf->dma_addr));

    buf->size = size;
    buf->priv_data = dev;
    vma->vm_ops = &a2gx_dma_vma_ops;
    vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
    vma->vm_private_data = buf;

    /*
     * Map this DMA buffer into user space.
     */
    if (remap_pfn_range(vma, vma->vm_start,
                        vmalloc_to_pfn(buf->cpu_addr),
                        size, vma->vm_page_prot))
    {
        /* Out of luck, rollback... */
        pci_free_consistent(dev->pci_dev, buf->size, buf->cpu_addr,
                            buf->dma_addr);
        buf->cpu_addr = NULL;
        return -EAGAIN;
    }

    return 0; /* All good! */
}

Una vez que los están en su lugar, la aplicación de espacio de usuario puede prácticamente hacer todo: controlar el dispositivo leyendo/escribiendo desde/hacia registros de E / S, asignar y liberar búferes DMA de tamaño arbitrario y hacer que el dispositivo realice transacciones DMA. La única parte que falta es el manejo de interrupciones. Estaba haciendo encuestas en el espacio de usuario, quemando mi CPU y tenía interrupciones desactivadas.

Espero que ayude. ¡Buena suerte!

Me estoy confundiendo con la dirección a implementar. Quiero hacerlo...

Tenga en cuenta la aplicación al diseñar un controlador.
¿Cuál es la naturaleza del movimiento de datos, la frecuencia, el tamaño y qué más podría estar sucediendo en el sistema?

¿ Es suficiente la API de lectura/escritura tradicional? ¿Está bien la asignación directa del dispositivo al espacio de usuario? ¿Es deseable una memoria compartida reflexiva (semi-coherente)?

La manipulación manual de datos (lectura/escritura) es una opción bastante buena si el los datos se prestan a ser bien entendidos. El uso de VM de propósito general y lectura/escritura puede ser suficiente con una copia en línea. La asignación directa de accesos no accesibles al periférico es conveniente, pero puede ser torpe. Si el acceso es el movimiento relativamente poco frecuente de bloques grandes, puede tener sentido usar memoria regular, tener el pin de la unidad, traducir direcciones, DMA y liberar las páginas. Como una optimización, las páginas (tal vez enormes) pueden ser pre ancladas y traducidas; la unidad entonces puede reconozca la memoria preparada y evite las complejidades de la traducción dinámica. Si hay un montón de pequeñas operaciones de E/S, tener la unidad ejecutada asincrónicamente tiene sentido. Si la elegancia es importante, el indicador de página sucia de VM se puede usar para identificar automáticamente lo que se necesita mover y una llamada (meta_sync ()) se puede usar para vaciar las páginas. Tal vez una mezcla de las obras anteriores...

Con demasiada frecuencia la gente no mira el problema más grande, antes de profundizar en los detalles. A menudo el más simple las soluciones son suficientes. Un poco de esfuerzo para construir un modelo de comportamiento puede ayudar a guiar qué API es preferible.

first_page_offset = udata & PAGE_MASK; 

Parece incorrecto. Debe ser:

first_page_offset = udata & ~PAGE_MASK;

O

first_page_offset = udata & (PAGE_SIZE - 1)

Vale la pena mencionar que el controlador con soporte de DMA Scatter-Gather y la asignación de memoria de espacio de usuario es más eficiente y tiene el mayor rendimiento. Sin embargo, en caso de que no necesitemos un alto rendimiento o queramos desarrollar un controlador en algunas condiciones simplificadas podemos usar algunos trucos.

Renunciar a cero diseño de copia. Vale la pena considerar cuando el rendimiento de datos no es demasiado grande. En tal diseño los datos pueden copiarse al usuario por copy_to_user(user_buffer, kernel_dma_buffer, count); user_buffer podría ser, por ejemplo, un argumento de búfer en carácter implementación de llamada al sistema device read (). Todavía tenemos que ocuparnos de kernel_dma_buffer la asignación. Podría por memoria obtenida de dma_alloc_coherent() llamar por ejemplo.

El otro truco es limitar la memoria del sistema en el momento del arranque y luego usarla como un enorme búfer DMA contiguo. Es especialmente útil durante el desarrollo de controladores y controladores DMA FPGA y no se recomienda en entornos de producción. Digamos que la PC tiene 32 GB de RAM. Si añadimos mem=20GB a la lista de parámetros de arranque del kernel podemos usar 12GB como enorme buffer dma contiguo. Para asignar esta memoria al espacio de usuario simplemente implementa mmap () como

remap_pfn_range(vma,
    vma->vm_start,
    (0x500000000 >> PAGE_SHIFT) + vma->vm_pgoff, 
    vma->vm_end - vma->vm_start,
    vma->vm_page_prot)

Por supuesto, este 12GB es completamente omitido por el sistema operativo y solo puede ser utilizado por el proceso que lo ha asignado a su espacio de direcciones. Podemos intentar evitarlo usando el Asignador de Memoria Contiguo (CMA).

Una vez más los trucos anteriores no reemplazarán el controlador DMA full Scatter-Gather, zero copy, pero son útiles durante el tiempo de desarrollo o en algunas plataformas con menos rendimiento.