Aprendendo PCI-e: drivers e DMA
Resumo do item anterior
- No item anterior, foi implementado um dispositivo PCI-e simples e abordado como ler e escrever 32 bits por vez usando manualmente o endereço (
0xfe000000).
- Para obter esse endereço programaticamente, é necessário solicitar os detalhes de mapeamento de memória ao subsistema PCI.
Criação da estrutura do driver
- É necessário criar uma
struct pci_driver, e ela precisa de uma tabela de dispositivos suportados e de uma função probe.
- A tabela de dispositivos suportados é composta por um array de pares de ID de dispositivo/fornecedor.
static struct pci_device_id gpu_id_tbl[] = {
{ PCI_DEVICE(0x1234, 0x1337) },
{ 0, },
};
- A função
probe é chamada quando o ID de dispositivo/fornecedor corresponde, e deve atualizar o estado do driver para referenciar a região de memória do dispositivo.
typedef struct GpuState {
struct pci_dev *pdev;
u8 __iomem *hwmem;
} GpuState;
Implementação da função probe
- Ativa o dispositivo e armazena uma referência para
pci_dev.
static int gpu_probe(struct pci_dev *pdev, const struct pci_device_id *id) {
int bars;
unsigned long mmio_start, mmio_len;
GpuState* gpu = kmalloc(sizeof(struct GpuState), GFP_KERNEL);
gpu->pdev = pdev;
pci_enable_device_mem(pdev);
bars = pci_select_bars(pdev, IORESOURCE_MEM);
pci_request_region(pdev, bars, "gpu-pci");
mmio_start = pci_resource_start(pdev, 0);
mmio_len = pci_resource_len(pdev, 0);
gpu->hwmem = ioremap(mmio_start, mmio_len);
return 0;
}
Expondo a placa ao espaço do usuário
- Agora que o driver do kernel mapeou o espaço de endereços BAR0, é possível criar um dispositivo de caractere para que aplicações em espaço do usuário interajam com o dispositivo PCIe por meio de operações de arquivo.
- É necessário implementar as funções
open, read e write.
static int gpu_open(struct inode *inode, struct file *file);
static ssize_t gpu_read(struct file *file, char __user *buf, size_t count, loff_t *offset);
static ssize_t gpu_write(struct file *file, const char __user *buf, size_t count, loff_t *offset);
Uso de DMA
- Em vez de a CPU copiar um DWORD de dados por vez, é possível usar DMA para que a placa copie os dados por conta própria.
- Definição da interface de “chamada de função” do DMA:
- A CPU informa à placa os dados a serem copiados (endereço de origem, tamanho), o endereço de destino e a direção do fluxo de dados (leitura ou escrita).
- A CPU informa à placa que está pronta para iniciar a cópia.
- A placa informa à CPU que a transferência foi concluída.
#define REG_DMA_DIR 0
#define REG_DMA_ADDR_SRC 1
#define REG_DMA_ADDR_DST 2
#define REG_DMA_LEN 3
#define CMD_ADDR_BASE 0xf00
#define CMD_DMA_START (CMD_ADDR_BASE + 0)
static void write_reg(GpuState* gpu, u32 val, u32 reg) {
iowrite32(val, gpu->hwmem + (reg * sizeof(u32)));
}
void execute_dma(GpuState* gpu, u8 dir, u32 src, u32 dst, u32 len) {
write_reg(gpu, dir, REG_DMA_DIR);
write_reg(gpu, src, REG_DMA_ADDR_SRC);
write_reg(gpu, dst, REG_DMA_ADDR_DST);
write_reg(gpu, len, REG_DMA_LEN);
write_reg(gpu, 1, CMD_DMA_START);
}
Configuração de MSI-X
- Como a execução de DMA é assíncrona, é melhor bloquear até que
write seja concluído.
- A placa PCI-e pode sinalizar a CPU por meio de interrupções sinalizadas por mensagem (MSI).
- Para configurar MSI-X, é necessário alocar espaço para armazenar o espaço de configuração de cada interrupção (tabela MSI-X) e um bitmap das interrupções pendentes (PBA).
#define IRQ_COUNT 1
#define IRQ_DMA_DONE_NR 0
#define MSIX_ADDR_BASE 0x1000
#define PBA_ADDR_BASE 0x3000
static irqreturn_t irq_handler(int irq, void *data) {
pr_info("IRQ %d received\n", irq);
return IRQ_HANDLED;
}
static int setup_msi(GpuState* gpu) {
int msi_vecs;
int irq_num;
msi_vecs = pci_alloc_irq_vectors(gpu->pdev, IRQ_COUNT, IRQ_COUNT, PCI_IRQ_MSIX | PCI_IRQ_MSI);
irq_num = pci_irq_vector(gpu->pdev, IRQ_DMA_DONE_NR);
request_threaded_irq(irq_num, irq_handler, NULL, 0, "GPU-Dma0", gpu);
return 0;
}
Escrita realmente bloqueante
- É possível usar uma fila de espera para fazer
write bloquear usando o mecanismo de interrupção.
wait_queue_head_t wq;
volatile int irq_fired = 0;
static irqreturn_t irq_handler(int irq, void *data) {
irq_fired = 1;
wake_up_interruptible(&wq);
return IRQ_HANDLED;
}
static ssize_t gpu_fb_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) {
GpuState *gpu = (GpuState*) file->private_data;
dma_addr_t dma_addr;
u8* kbuf = kmalloc(count, GFP_KERNEL);
copy_from_user(kbuf, buf, count);
dma_addr = dma_map_single(&gpu->pdev->dev, kbuf, count, DMA_TO_DEVICE);
execute_dma(gpu, DIR_HOST_TO_GPU, dma_addr, *offset, count);
if (wait_event_interruptible(wq, irq_fired != 0)) {
pr_info("interrupted");
return -ERESTARTSYS;
}
kfree(kbuf);
return count;
}
Exibição na tela
- Agora existe um “framebuffer” que pode passar dados do espaço do usuário para o dispositivo PCI-e por meio de
write(2).
- É possível conectar o buffer da placa à saída do console do QEMU para que ela pareça uma GPU em funcionamento.
struct GpuState {
PCIDevice pdev;
MemoryRegion mem;
QemuConsole* con;
uint32_t registers[0x100000 / 32];
uint32_t framebuffer[0x200000];
};
static void pci_gpu_realize(PCIDevice *pdev, Error **errp) {
gpu->con = graphic_console_init(DEVICE(pdev), 0, &ghwops, gpu);
DisplaySurface *surface = qemu_console_surface(gpu->con);
for(int i = 0; i<640*480; i++) {
((uint32_t*)surface_data(surface))[i] = i;
}
}
static void vga_update_display(void *opaque) {
GpuState* gpu = opaque;
DisplaySurface *surface = qemu_console_surface(gpu->con);
for(int i = 0; i<640*480; i++) {
((uint32_t*)surface_data(surface))[i] = gpu->framebuffer[i % 0x200000 ];
}
dpy_gfx_update(gpu->con, 0, 0, 640, 480);
}
static const GraphicHwOps ghwops = {
.gfx_update = vga_update_display,
};
Resumo do GN⁺
- Este artigo aborda drivers de dispositivo PCI-e e DMA, explicando como permitir que aplicações em espaço do usuário interajam com um dispositivo PCIe por meio de um driver de kernel.
- Mostra como usar DMA para reduzir a carga da CPU e aumentar a velocidade de transferência de dados.
- Explica como usar MSI-X para sinalizar a CPU quando a transferência DMA for concluída.
- Aborda como simular e testar uma GPU em um ambiente virtual usando QEMU.
- Projetos com funcionalidade semelhante incluem
pciemu e Linux Kernel Labs - Device Drivers.
1 comentários
Comentário no Hacker News
O objetivo final é criar um adaptador de vídeo usando FPGA
Gosto muito da progressão destes artigos
Parece uma excelente introdução a drivers de dispositivos PCIe no Linux
Muito obrigado por escrever este artigo