Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
firewire: ohci: stop using page private to store DMA mapping address
There is a long discussion about the use of private field in page
structure between Linux kernel developers.
This commit stop using page private to store DMA mapping address for
AR context, to prepare for mm future change.
Link: https://lore.kernel.org/r/20260110013911.19160-9-o-takashi@sakamocchi.jp
Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
+16
-23
+16
-23
drivers/firewire/ohci.c
+16
-23
drivers/firewire/ohci.c
···
96
96
struct fw_ohci *ohci;
97
97
struct page *pages[AR_BUFFERS];
98
98
void *buffer;
99
+
dma_addr_t dma_addrs[AR_BUFFERS];
99
100
struct descriptor *descriptors;
100
101
dma_addr_t descriptors_bus;
101
102
void *pointer;
···
514
513
return update_phy_reg(ohci, addr, clear_bits, set_bits);
515
514
}
516
515
517
-
static inline dma_addr_t ar_buffer_bus(struct ar_context *ctx, unsigned int i)
518
-
{
519
-
return page_private(ctx->pages[i]);
520
-
}
521
-
522
516
static void ar_context_link_page(struct ar_context *ctx, unsigned int index)
523
517
{
524
518
struct descriptor *d;
···
540
544
return;
541
545
542
546
for (int i = 0; i < AR_BUFFERS; ++i) {
543
-
dma_addr_t dma_addr = page_private(ctx->pages[i]);
544
-
545
-
dma_unmap_page(dev, dma_addr, PAGE_SIZE, DMA_FROM_DEVICE);
546
-
set_page_private(ctx->pages[i], 0);
547
+
dma_addr_t dma_addr = ctx->dma_addrs[i];
548
+
if (dma_addr)
549
+
dma_unmap_page(dev, dma_addr, PAGE_SIZE, DMA_FROM_DEVICE);
547
550
}
551
+
memset(ctx->dma_addrs, 0, sizeof(ctx->dma_addrs));
548
552
549
553
vunmap(ctx->buffer);
550
554
ctx->buffer = NULL;
···
643
647
644
648
i = ar_first_buffer_index(ctx);
645
649
while (i != end_buffer_index) {
646
-
dma_sync_single_for_cpu(ctx->ohci->card.device,
647
-
ar_buffer_bus(ctx, i),
648
-
PAGE_SIZE, DMA_FROM_DEVICE);
650
+
dma_sync_single_for_cpu(ctx->ohci->card.device, ctx->dma_addrs[i], PAGE_SIZE,
651
+
DMA_FROM_DEVICE);
649
652
i = ar_next_buffer_index(i);
650
653
}
651
654
if (end_buffer_offset > 0)
652
-
dma_sync_single_for_cpu(ctx->ohci->card.device,
653
-
ar_buffer_bus(ctx, i),
655
+
dma_sync_single_for_cpu(ctx->ohci->card.device, ctx->dma_addrs[i],
654
656
end_buffer_offset, DMA_FROM_DEVICE);
655
657
}
656
658
···
789
795
790
796
i = ar_first_buffer_index(ctx);
791
797
while (i != end_buffer) {
792
-
dma_sync_single_for_device(ctx->ohci->card.device,
793
-
ar_buffer_bus(ctx, i),
794
-
PAGE_SIZE, DMA_FROM_DEVICE);
798
+
dma_sync_single_for_device(ctx->ohci->card.device, ctx->dma_addrs[i], PAGE_SIZE,
799
+
DMA_FROM_DEVICE);
795
800
ar_context_link_page(ctx, i);
796
801
i = ar_next_buffer_index(i);
797
802
}
···
843
850
struct device *dev = ohci->card.device;
844
851
unsigned int i;
845
852
struct page *pages[AR_BUFFERS + AR_WRAPAROUND_PAGES];
853
+
dma_addr_t dma_addrs[AR_BUFFERS];
846
854
void *vaddr;
847
855
struct descriptor *d;
848
856
···
879
885
dma_addr_t dma_addr = dma_map_page(dev, pages[i], 0, PAGE_SIZE, DMA_FROM_DEVICE);
880
886
if (dma_mapping_error(dev, dma_addr))
881
887
break;
882
-
set_page_private(pages[i], dma_addr);
888
+
dma_addrs[i] = dma_addr;
883
889
dma_sync_single_for_device(dev, dma_addr, PAGE_SIZE, DMA_FROM_DEVICE);
884
890
}
885
891
if (i < AR_BUFFERS) {
886
-
while (i-- > 0) {
887
-
dma_addr_t dma_addr = page_private(pages[i]);
888
-
dma_unmap_page(dev, dma_addr, PAGE_SIZE, DMA_FROM_DEVICE);
889
-
}
892
+
while (i-- > 0)
893
+
dma_unmap_page(dev, dma_addrs[i], PAGE_SIZE, DMA_FROM_DEVICE);
890
894
vunmap(vaddr);
891
895
release_pages(pages, nr_populated);
892
896
return -ENOMEM;
893
897
}
894
898
899
+
memcpy(ctx->dma_addrs, dma_addrs, sizeof(ctx->dma_addrs));
895
900
ctx->buffer = vaddr;
896
901
memcpy(ctx->pages, pages, sizeof(ctx->pages));
897
902
···
903
910
d->control = cpu_to_le16(DESCRIPTOR_INPUT_MORE |
904
911
DESCRIPTOR_STATUS |
905
912
DESCRIPTOR_BRANCH_ALWAYS);
906
-
d->data_address = cpu_to_le32(ar_buffer_bus(ctx, i));
913
+
d->data_address = cpu_to_le32(ctx->dma_addrs[i]);
907
914
d->branch_address = cpu_to_le32(ctx->descriptors_bus +
908
915
ar_next_buffer_index(i) * sizeof(struct descriptor));
909
916
}