tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'powerpc-6.8-5' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux

Pull powerpc fixes from Michael Ellerman:

- Fix IOMMU table initialisation when doing kdump over SR-IOV

- Fix incorrect RTAS function name for resetting TCE tables

- Fix fpu_signal selftest failures since a recent change

Thanks to Gaurav Batra and Nathan Lynch.

* tag 'powerpc-6.8-5' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux:
selftests/powerpc: Fix fpu_signal failures
powerpc/rtas: use correct function name for resetting TCE tables
powerpc/pseries/iommu: IOMMU table is not initialized for kdump over SR-IOV

Linus Torvalds e4f79000 73d35f83

+120 -65
+2 -2
arch/powerpc/include/asm/rtas.h
··· 69 69 RTAS_FNIDX__IBM_READ_SLOT_RESET_STATE, 70 70 RTAS_FNIDX__IBM_READ_SLOT_RESET_STATE2, 71 71 RTAS_FNIDX__IBM_REMOVE_PE_DMA_WINDOW, 72 - RTAS_FNIDX__IBM_RESET_PE_DMA_WINDOWS, 72 + RTAS_FNIDX__IBM_RESET_PE_DMA_WINDOW, 73 73 RTAS_FNIDX__IBM_SCAN_LOG_DUMP, 74 74 RTAS_FNIDX__IBM_SET_DYNAMIC_INDICATOR, 75 75 RTAS_FNIDX__IBM_SET_EEH_OPTION, ··· 164 164 #define RTAS_FN_IBM_READ_SLOT_RESET_STATE rtas_fn_handle(RTAS_FNIDX__IBM_READ_SLOT_RESET_STATE) 165 165 #define RTAS_FN_IBM_READ_SLOT_RESET_STATE2 rtas_fn_handle(RTAS_FNIDX__IBM_READ_SLOT_RESET_STATE2) 166 166 #define RTAS_FN_IBM_REMOVE_PE_DMA_WINDOW rtas_fn_handle(RTAS_FNIDX__IBM_REMOVE_PE_DMA_WINDOW) 167 - #define RTAS_FN_IBM_RESET_PE_DMA_WINDOWS rtas_fn_handle(RTAS_FNIDX__IBM_RESET_PE_DMA_WINDOWS) 167 + #define RTAS_FN_IBM_RESET_PE_DMA_WINDOW rtas_fn_handle(RTAS_FNIDX__IBM_RESET_PE_DMA_WINDOW) 168 168 #define RTAS_FN_IBM_SCAN_LOG_DUMP rtas_fn_handle(RTAS_FNIDX__IBM_SCAN_LOG_DUMP) 169 169 #define RTAS_FN_IBM_SET_DYNAMIC_INDICATOR rtas_fn_handle(RTAS_FNIDX__IBM_SET_DYNAMIC_INDICATOR) 170 170 #define RTAS_FN_IBM_SET_EEH_OPTION rtas_fn_handle(RTAS_FNIDX__IBM_SET_EEH_OPTION)
+7 -2
arch/powerpc/kernel/rtas.c
··· 375 375 [RTAS_FNIDX__IBM_REMOVE_PE_DMA_WINDOW] = { 376 376 .name = "ibm,remove-pe-dma-window", 377 377 }, 378 - [RTAS_FNIDX__IBM_RESET_PE_DMA_WINDOWS] = { 379 - .name = "ibm,reset-pe-dma-windows", 378 + [RTAS_FNIDX__IBM_RESET_PE_DMA_WINDOW] = { 379 + /* 380 + * Note: PAPR+ v2.13 7.3.31.4.1 spells this as 381 + * "ibm,reset-pe-dma-windows" (plural), but RTAS 382 + * implementations use the singular form in practice. 383 + */ 384 + .name = "ibm,reset-pe-dma-window", 380 385 }, 381 386 [RTAS_FNIDX__IBM_SCAN_LOG_DUMP] = { 382 387 .name = "ibm,scan-log-dump",
+105 -51
arch/powerpc/platforms/pseries/iommu.c
··· 574 574 575 575 struct iommu_table_ops iommu_table_lpar_multi_ops; 576 576 577 - /* 578 - * iommu_table_setparms_lpar 579 - * 580 - * Function: On pSeries LPAR systems, return TCE table info, given a pci bus. 581 - */ 582 - static void iommu_table_setparms_lpar(struct pci_controller *phb, 583 - struct device_node *dn, 584 - struct iommu_table *tbl, 585 - struct iommu_table_group *table_group, 586 - const __be32 *dma_window) 587 - { 588 - unsigned long offset, size, liobn; 589 - 590 - of_parse_dma_window(dn, dma_window, &liobn, &offset, &size); 591 - 592 - iommu_table_setparms_common(tbl, phb->bus->number, liobn, offset, size, IOMMU_PAGE_SHIFT_4K, NULL, 593 - &iommu_table_lpar_multi_ops); 594 - 595 - 596 - table_group->tce32_start = offset; 597 - table_group->tce32_size = size; 598 - } 599 - 600 577 struct iommu_table_ops iommu_table_pseries_ops = { 601 578 .set = tce_build_pSeries, 602 579 .clear = tce_free_pSeries, ··· 701 724 * dynamic 64bit DMA window, walking up the device tree. 702 725 */ 703 726 static struct device_node *pci_dma_find(struct device_node *dn, 704 - const __be32 **dma_window) 727 + struct dynamic_dma_window_prop *prop) 705 728 { 706 - const __be32 *dw = NULL; 729 + const __be32 *default_prop = NULL; 730 + const __be32 *ddw_prop = NULL; 731 + struct device_node *rdn = NULL; 732 + bool default_win = false, ddw_win = false; 707 733 708 734 for ( ; dn && PCI_DN(dn); dn = dn->parent) { 709 - dw = of_get_property(dn, "ibm,dma-window", NULL); 710 - if (dw) { 711 - if (dma_window) 712 - *dma_window = dw; 713 - return dn; 735 + default_prop = of_get_property(dn, "ibm,dma-window", NULL); 736 + if (default_prop) { 737 + rdn = dn; 738 + default_win = true; 714 739 } 715 - dw = of_get_property(dn, DIRECT64_PROPNAME, NULL); 716 - if (dw) 717 - return dn; 718 - dw = of_get_property(dn, DMA64_PROPNAME, NULL); 719 - if (dw) 720 - return dn; 740 + ddw_prop = of_get_property(dn, DIRECT64_PROPNAME, NULL); 741 + if (ddw_prop) { 742 + rdn = dn; 743 + ddw_win = true; 744 + break; 745 + } 746 + ddw_prop = of_get_property(dn, DMA64_PROPNAME, NULL); 747 + if (ddw_prop) { 748 + rdn = dn; 749 + ddw_win = true; 750 + break; 751 + } 752 + 753 + /* At least found default window, which is the case for normal boot */ 754 + if (default_win) 755 + break; 721 756 } 722 757 723 - return NULL; 758 + /* For PCI devices there will always be a DMA window, either on the device 759 + * or parent bus 760 + */ 761 + WARN_ON(!(default_win | ddw_win)); 762 + 763 + /* caller doesn't want to get DMA window property */ 764 + if (!prop) 765 + return rdn; 766 + 767 + /* parse DMA window property. During normal system boot, only default 768 + * DMA window is passed in OF. But, for kdump, a dedicated adapter might 769 + * have both default and DDW in FDT. In this scenario, DDW takes precedence 770 + * over default window. 771 + */ 772 + if (ddw_win) { 773 + struct dynamic_dma_window_prop *p; 774 + 775 + p = (struct dynamic_dma_window_prop *)ddw_prop; 776 + prop->liobn = p->liobn; 777 + prop->dma_base = p->dma_base; 778 + prop->tce_shift = p->tce_shift; 779 + prop->window_shift = p->window_shift; 780 + } else if (default_win) { 781 + unsigned long offset, size, liobn; 782 + 783 + of_parse_dma_window(rdn, default_prop, &liobn, &offset, &size); 784 + 785 + prop->liobn = cpu_to_be32((u32)liobn); 786 + prop->dma_base = cpu_to_be64(offset); 787 + prop->tce_shift = cpu_to_be32(IOMMU_PAGE_SHIFT_4K); 788 + prop->window_shift = cpu_to_be32(order_base_2(size)); 789 + } 790 + 791 + return rdn; 724 792 } 725 793 726 794 static void pci_dma_bus_setup_pSeriesLP(struct pci_bus *bus) ··· 773 751 struct iommu_table *tbl; 774 752 struct device_node *dn, *pdn; 775 753 struct pci_dn *ppci; 776 - const __be32 *dma_window = NULL; 754 + struct dynamic_dma_window_prop prop; 777 755 778 756 dn = pci_bus_to_OF_node(bus); 779 757 780 758 pr_debug("pci_dma_bus_setup_pSeriesLP: setting up bus %pOF\n", 781 759 dn); 782 760 783 - pdn = pci_dma_find(dn, &dma_window); 761 + pdn = pci_dma_find(dn, &prop); 784 762 785 - if (dma_window == NULL) 786 - pr_debug(" no ibm,dma-window property !\n"); 763 + /* In PPC architecture, there will always be DMA window on bus or one of the 764 + * parent bus. During reboot, there will be ibm,dma-window property to 765 + * define DMA window. For kdump, there will at least be default window or DDW 766 + * or both. 767 + */ 787 768 788 769 ppci = PCI_DN(pdn); 789 770 ··· 796 771 if (!ppci->table_group) { 797 772 ppci->table_group = iommu_pseries_alloc_group(ppci->phb->node); 798 773 tbl = ppci->table_group->tables[0]; 799 - if (dma_window) { 800 - iommu_table_setparms_lpar(ppci->phb, pdn, tbl, 801 - ppci->table_group, dma_window); 802 774 803 - if (!iommu_init_table(tbl, ppci->phb->node, 0, 0)) 804 - panic("Failed to initialize iommu table"); 805 - } 775 + iommu_table_setparms_common(tbl, ppci->phb->bus->number, 776 + be32_to_cpu(prop.liobn), 777 + be64_to_cpu(prop.dma_base), 778 + 1ULL << be32_to_cpu(prop.window_shift), 779 + be32_to_cpu(prop.tce_shift), NULL, 780 + &iommu_table_lpar_multi_ops); 781 + 782 + /* Only for normal boot with default window. Doesn't matter even 783 + * if we set these with DDW which is 64bit during kdump, since 784 + * these will not be used during kdump. 785 + */ 786 + ppci->table_group->tce32_start = be64_to_cpu(prop.dma_base); 787 + ppci->table_group->tce32_size = 1 << be32_to_cpu(prop.window_shift); 788 + 789 + if (!iommu_init_table(tbl, ppci->phb->node, 0, 0)) 790 + panic("Failed to initialize iommu table"); 791 + 806 792 iommu_register_group(ppci->table_group, 807 793 pci_domain_nr(bus), 0); 808 794 pr_debug(" created table: %p\n", ppci->table_group); ··· 1004 968 continue; 1005 969 } 1006 970 971 + /* If at the time of system initialization, there are DDWs in OF, 972 + * it means this is during kexec. DDW could be direct or dynamic. 973 + * We will just mark DDWs as "dynamic" since this is kdump path, 974 + * no need to worry about perforance. ddw_list_new_entry() will 975 + * set window->direct = false. 976 + */ 1007 977 window = ddw_list_new_entry(pdn, dma64); 1008 978 if (!window) { 1009 979 of_node_put(pdn); ··· 1566 1524 { 1567 1525 struct device_node *pdn, *dn; 1568 1526 struct iommu_table *tbl; 1569 - const __be32 *dma_window = NULL; 1570 1527 struct pci_dn *pci; 1528 + struct dynamic_dma_window_prop prop; 1571 1529 1572 1530 pr_debug("pci_dma_dev_setup_pSeriesLP: %s\n", pci_name(dev)); 1573 1531 ··· 1580 1538 dn = pci_device_to_OF_node(dev); 1581 1539 pr_debug(" node is %pOF\n", dn); 1582 1540 1583 - pdn = pci_dma_find(dn, &dma_window); 1541 + pdn = pci_dma_find(dn, &prop); 1584 1542 if (!pdn || !PCI_DN(pdn)) { 1585 1543 printk(KERN_WARNING "pci_dma_dev_setup_pSeriesLP: " 1586 1544 "no DMA window found for pci dev=%s dn=%pOF\n", ··· 1593 1551 if (!pci->table_group) { 1594 1552 pci->table_group = iommu_pseries_alloc_group(pci->phb->node); 1595 1553 tbl = pci->table_group->tables[0]; 1596 - iommu_table_setparms_lpar(pci->phb, pdn, tbl, 1597 - pci->table_group, dma_window); 1554 + 1555 + iommu_table_setparms_common(tbl, pci->phb->bus->number, 1556 + be32_to_cpu(prop.liobn), 1557 + be64_to_cpu(prop.dma_base), 1558 + 1ULL << be32_to_cpu(prop.window_shift), 1559 + be32_to_cpu(prop.tce_shift), NULL, 1560 + &iommu_table_lpar_multi_ops); 1561 + 1562 + /* Only for normal boot with default window. Doesn't matter even 1563 + * if we set these with DDW which is 64bit during kdump, since 1564 + * these will not be used during kdump. 1565 + */ 1566 + pci->table_group->tce32_start = be64_to_cpu(prop.dma_base); 1567 + pci->table_group->tce32_size = 1 << be32_to_cpu(prop.window_shift); 1598 1568 1599 1569 iommu_init_table(tbl, pci->phb->node, 0, 0); 1600 1570 iommu_register_group(pci->table_group,
+6 -10
tools/testing/selftests/powerpc/math/fpu_signal.c
··· 18 18 #include <pthread.h> 19 19 20 20 #include "utils.h" 21 + #include "fpu.h" 21 22 22 23 /* Number of times each thread should receive the signal */ 23 24 #define ITERATIONS 10 ··· 28 27 */ 29 28 #define THREAD_FACTOR 8 30 29 31 - __thread double darray[] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 32 - 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 33 - 2.1}; 30 + __thread double darray[32]; 34 31 35 32 bool bad_context; 36 33 int threads_starting; ··· 42 43 ucontext_t *uc = context; 43 44 mcontext_t *mc = &uc->uc_mcontext; 44 45 45 - /* Only the non volatiles were loaded up */ 46 - for (i = 14; i < 32; i++) { 47 - if (mc->fp_regs[i] != darray[i - 14]) { 46 + // Don't check f30/f31, they're used as scratches in check_all_fprs() 47 + for (i = 0; i < 30; i++) { 48 + if (mc->fp_regs[i] != darray[i]) { 48 49 bad_context = true; 49 50 break; 50 51 } ··· 53 54 54 55 void *signal_fpu_c(void *p) 55 56 { 56 - int i; 57 57 long rc; 58 58 struct sigaction act; 59 59 act.sa_sigaction = signal_fpu_sig; ··· 62 64 return p; 63 65 64 66 srand(pthread_self()); 65 - for (i = 0; i < 21; i++) 66 - darray[i] = rand(); 67 - 67 + randomise_darray(darray, ARRAY_SIZE(darray)); 68 68 rc = preempt_fpu(darray, &threads_starting, &running); 69 69 70 70 return (void *) rc;