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 'char-misc-6.3-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc

Pull char/misc driver fixes from Greg KH:
"Here are a few small char/misc/other driver subsystem patches to
resolve reported problems for 6.3-rc3.

Included in here are:

- Interconnect driver fixes for reported problems

- Memory driver fixes for reported problems

- nvmem core fix

- firmware driver fix for reported problem

All of these have been in linux-next for a while with no reported
issues"

* tag 'char-misc-6.3-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc: (23 commits)
memory: tegra30-emc: fix interconnect registration race
memory: tegra20-emc: fix interconnect registration race
memory: tegra124-emc: fix interconnect registration race
memory: tegra: fix interconnect registration race
interconnect: exynos: drop redundant link destroy
interconnect: exynos: fix registration race
interconnect: exynos: fix node leak in probe PM QoS error path
interconnect: qcom: msm8974: fix registration race
interconnect: qcom: rpmh: fix registration race
interconnect: qcom: rpmh: fix probe child-node error handling
interconnect: qcom: rpm: fix registration race
nvmem: core: return -ENOENT if nvmem cell is not found
firmware: xilinx: don't make a sleepable memory allocation from an atomic context
interconnect: qcom: rpm: fix probe child-node error handling
interconnect: qcom: osm-l3: fix registration race
interconnect: imx: fix registration race
interconnect: fix provider registration API
interconnect: fix icc_provider_del() error handling
interconnect: fix mem leak when freeing nodes
interconnect: qcom: qcm2290: Fix MASTER_SNOC_BIMC_NRT
...

Linus Torvalds ce86beb4 c46a7d04

+161 -323
+1 -1
drivers/firmware/xilinx/zynqmp.c
··· 206 206 } 207 207 208 208 /* Add new entry if not present */ 209 - feature_data = kmalloc(sizeof(*feature_data), GFP_KERNEL); 209 + feature_data = kmalloc(sizeof(*feature_data), GFP_ATOMIC); 210 210 if (!feature_data) 211 211 return -ENOMEM; 212 212
+43 -25
drivers/interconnect/core.c
··· 850 850 851 851 mutex_unlock(&icc_lock); 852 852 853 + if (!node) 854 + return; 855 + 856 + kfree(node->links); 853 857 kfree(node); 854 858 } 855 859 EXPORT_SYMBOL_GPL(icc_node_destroy); ··· 1033 1029 EXPORT_SYMBOL_GPL(icc_nodes_remove); 1034 1030 1035 1031 /** 1036 - * icc_provider_add() - add a new interconnect provider 1037 - * @provider: the interconnect provider that will be added into topology 1032 + * icc_provider_init() - initialize a new interconnect provider 1033 + * @provider: the interconnect provider to initialize 1034 + * 1035 + * Must be called before adding nodes to the provider. 1036 + */ 1037 + void icc_provider_init(struct icc_provider *provider) 1038 + { 1039 + WARN_ON(!provider->set); 1040 + 1041 + INIT_LIST_HEAD(&provider->nodes); 1042 + } 1043 + EXPORT_SYMBOL_GPL(icc_provider_init); 1044 + 1045 + /** 1046 + * icc_provider_register() - register a new interconnect provider 1047 + * @provider: the interconnect provider to register 1038 1048 * 1039 1049 * Return: 0 on success, or an error code otherwise 1040 1050 */ 1041 - int icc_provider_add(struct icc_provider *provider) 1051 + int icc_provider_register(struct icc_provider *provider) 1042 1052 { 1043 - if (WARN_ON(!provider->set)) 1044 - return -EINVAL; 1045 1053 if (WARN_ON(!provider->xlate && !provider->xlate_extended)) 1046 1054 return -EINVAL; 1047 1055 1048 1056 mutex_lock(&icc_lock); 1049 - 1050 - INIT_LIST_HEAD(&provider->nodes); 1051 1057 list_add_tail(&provider->provider_list, &icc_providers); 1052 - 1053 1058 mutex_unlock(&icc_lock); 1054 1059 1055 - dev_dbg(provider->dev, "interconnect provider added to topology\n"); 1060 + dev_dbg(provider->dev, "interconnect provider registered\n"); 1056 1061 1057 1062 return 0; 1058 1063 } 1059 - EXPORT_SYMBOL_GPL(icc_provider_add); 1064 + EXPORT_SYMBOL_GPL(icc_provider_register); 1060 1065 1061 1066 /** 1062 - * icc_provider_del() - delete previously added interconnect provider 1063 - * @provider: the interconnect provider that will be removed from topology 1067 + * icc_provider_deregister() - deregister an interconnect provider 1068 + * @provider: the interconnect provider to deregister 1064 1069 */ 1065 - void icc_provider_del(struct icc_provider *provider) 1070 + void icc_provider_deregister(struct icc_provider *provider) 1066 1071 { 1067 1072 mutex_lock(&icc_lock); 1068 - if (provider->users) { 1069 - pr_warn("interconnect provider still has %d users\n", 1070 - provider->users); 1071 - mutex_unlock(&icc_lock); 1072 - return; 1073 - } 1074 - 1075 - if (!list_empty(&provider->nodes)) { 1076 - pr_warn("interconnect provider still has nodes\n"); 1077 - mutex_unlock(&icc_lock); 1078 - return; 1079 - } 1073 + WARN_ON(provider->users); 1080 1074 1081 1075 list_del(&provider->provider_list); 1082 1076 mutex_unlock(&icc_lock); 1077 + } 1078 + EXPORT_SYMBOL_GPL(icc_provider_deregister); 1079 + 1080 + int icc_provider_add(struct icc_provider *provider) 1081 + { 1082 + icc_provider_init(provider); 1083 + 1084 + return icc_provider_register(provider); 1085 + } 1086 + EXPORT_SYMBOL_GPL(icc_provider_add); 1087 + 1088 + void icc_provider_del(struct icc_provider *provider) 1089 + { 1090 + WARN_ON(!list_empty(&provider->nodes)); 1091 + 1092 + icc_provider_deregister(provider); 1083 1093 } 1084 1094 EXPORT_SYMBOL_GPL(icc_provider_del); 1085 1095
+11 -11
drivers/interconnect/imx/imx.c
··· 295 295 provider->xlate = of_icc_xlate_onecell; 296 296 provider->data = data; 297 297 provider->dev = dev->parent; 298 + 299 + icc_provider_init(provider); 300 + 298 301 platform_set_drvdata(pdev, imx_provider); 299 302 300 303 if (settings) { ··· 309 306 } 310 307 } 311 308 312 - ret = icc_provider_add(provider); 313 - if (ret) { 314 - dev_err(dev, "error adding interconnect provider: %d\n", ret); 315 - return ret; 316 - } 317 - 318 309 ret = imx_icc_register_nodes(imx_provider, nodes, nodes_count, settings); 319 310 if (ret) 320 - goto provider_del; 311 + return ret; 312 + 313 + ret = icc_provider_register(provider); 314 + if (ret) 315 + goto err_unregister_nodes; 321 316 322 317 return 0; 323 318 324 - provider_del: 325 - icc_provider_del(provider); 319 + err_unregister_nodes: 320 + imx_icc_unregister_nodes(&imx_provider->provider); 326 321 return ret; 327 322 } 328 323 EXPORT_SYMBOL_GPL(imx_icc_register); ··· 329 328 { 330 329 struct imx_icc_provider *imx_provider = platform_get_drvdata(pdev); 331 330 331 + icc_provider_deregister(&imx_provider->provider); 332 332 imx_icc_unregister_nodes(&imx_provider->provider); 333 - 334 - icc_provider_del(&imx_provider->provider); 335 333 } 336 334 EXPORT_SYMBOL_GPL(imx_icc_unregister); 337 335
+16 -13
drivers/interconnect/qcom/icc-rpm.c
··· 503 503 } 504 504 505 505 provider = &qp->provider; 506 - INIT_LIST_HEAD(&provider->nodes); 507 506 provider->dev = dev; 508 507 provider->set = qcom_icc_set; 509 508 provider->pre_aggregate = qcom_icc_pre_bw_aggregate; ··· 510 511 provider->xlate_extended = qcom_icc_xlate_extended; 511 512 provider->data = data; 512 513 513 - ret = icc_provider_add(provider); 514 - if (ret) { 515 - dev_err(dev, "error adding interconnect provider: %d\n", ret); 516 - clk_bulk_disable_unprepare(qp->num_clks, qp->bus_clks); 517 - return ret; 518 - } 514 + icc_provider_init(provider); 519 515 520 516 for (i = 0; i < num_nodes; i++) { 521 517 size_t j; ··· 518 524 node = icc_node_create(qnodes[i]->id); 519 525 if (IS_ERR(node)) { 520 526 ret = PTR_ERR(node); 521 - goto err; 527 + goto err_remove_nodes; 522 528 } 523 529 524 530 node->name = qnodes[i]->name; ··· 532 538 } 533 539 data->num_nodes = num_nodes; 534 540 541 + ret = icc_provider_register(provider); 542 + if (ret) 543 + goto err_remove_nodes; 544 + 535 545 platform_set_drvdata(pdev, qp); 536 546 537 547 /* Populate child NoC devices if any */ 538 - if (of_get_child_count(dev->of_node) > 0) 539 - return of_platform_populate(dev->of_node, NULL, NULL, dev); 548 + if (of_get_child_count(dev->of_node) > 0) { 549 + ret = of_platform_populate(dev->of_node, NULL, NULL, dev); 550 + if (ret) 551 + goto err_deregister_provider; 552 + } 540 553 541 554 return 0; 542 - err: 555 + 556 + err_deregister_provider: 557 + icc_provider_deregister(provider); 558 + err_remove_nodes: 543 559 icc_nodes_remove(provider); 544 560 clk_bulk_disable_unprepare(qp->num_clks, qp->bus_clks); 545 - icc_provider_del(provider); 546 561 547 562 return ret; 548 563 } ··· 561 558 { 562 559 struct qcom_icc_provider *qp = platform_get_drvdata(pdev); 563 560 561 + icc_provider_deregister(&qp->provider); 564 562 icc_nodes_remove(&qp->provider); 565 563 clk_bulk_disable_unprepare(qp->num_clks, qp->bus_clks); 566 - icc_provider_del(&qp->provider); 567 564 568 565 return 0; 569 566 }
+19 -11
drivers/interconnect/qcom/icc-rpmh.c
··· 192 192 provider->pre_aggregate = qcom_icc_pre_aggregate; 193 193 provider->aggregate = qcom_icc_aggregate; 194 194 provider->xlate_extended = qcom_icc_xlate_extended; 195 - INIT_LIST_HEAD(&provider->nodes); 196 195 provider->data = data; 196 + 197 + icc_provider_init(provider); 197 198 198 199 qp->dev = dev; 199 200 qp->bcms = desc->bcms; ··· 203 202 qp->voter = of_bcm_voter_get(qp->dev, NULL); 204 203 if (IS_ERR(qp->voter)) 205 204 return PTR_ERR(qp->voter); 206 - 207 - ret = icc_provider_add(provider); 208 - if (ret) 209 - return ret; 210 205 211 206 for (i = 0; i < qp->num_bcms; i++) 212 207 qcom_icc_bcm_init(qp->bcms[i], dev); ··· 215 218 node = icc_node_create(qn->id); 216 219 if (IS_ERR(node)) { 217 220 ret = PTR_ERR(node); 218 - goto err; 221 + goto err_remove_nodes; 219 222 } 220 223 221 224 node->name = qn->name; ··· 229 232 } 230 233 231 234 data->num_nodes = num_nodes; 235 + 236 + ret = icc_provider_register(provider); 237 + if (ret) 238 + goto err_remove_nodes; 239 + 232 240 platform_set_drvdata(pdev, qp); 233 241 234 242 /* Populate child NoC devices if any */ 235 - if (of_get_child_count(dev->of_node) > 0) 236 - return of_platform_populate(dev->of_node, NULL, NULL, dev); 243 + if (of_get_child_count(dev->of_node) > 0) { 244 + ret = of_platform_populate(dev->of_node, NULL, NULL, dev); 245 + if (ret) 246 + goto err_deregister_provider; 247 + } 237 248 238 249 return 0; 239 - err: 250 + 251 + err_deregister_provider: 252 + icc_provider_deregister(provider); 253 + err_remove_nodes: 240 254 icc_nodes_remove(provider); 241 - icc_provider_del(provider); 255 + 242 256 return ret; 243 257 } 244 258 EXPORT_SYMBOL_GPL(qcom_icc_rpmh_probe); ··· 258 250 { 259 251 struct qcom_icc_provider *qp = platform_get_drvdata(pdev); 260 252 253 + icc_provider_deregister(&qp->provider); 261 254 icc_nodes_remove(&qp->provider); 262 - icc_provider_del(&qp->provider); 263 255 264 256 return 0; 265 257 }
+8 -12
drivers/interconnect/qcom/msm8974.c
··· 692 692 return ret; 693 693 694 694 provider = &qp->provider; 695 - INIT_LIST_HEAD(&provider->nodes); 696 695 provider->dev = dev; 697 696 provider->set = msm8974_icc_set; 698 697 provider->aggregate = icc_std_aggregate; ··· 699 700 provider->data = data; 700 701 provider->get_bw = msm8974_get_bw; 701 702 702 - ret = icc_provider_add(provider); 703 - if (ret) { 704 - dev_err(dev, "error adding interconnect provider: %d\n", ret); 705 - goto err_disable_clks; 706 - } 703 + icc_provider_init(provider); 707 704 708 705 for (i = 0; i < num_nodes; i++) { 709 706 size_t j; ··· 707 712 node = icc_node_create(qnodes[i]->id); 708 713 if (IS_ERR(node)) { 709 714 ret = PTR_ERR(node); 710 - goto err_del_icc; 715 + goto err_remove_nodes; 711 716 } 712 717 713 718 node->name = qnodes[i]->name; ··· 724 729 } 725 730 data->num_nodes = num_nodes; 726 731 732 + ret = icc_provider_register(provider); 733 + if (ret) 734 + goto err_remove_nodes; 735 + 727 736 platform_set_drvdata(pdev, qp); 728 737 729 738 return 0; 730 739 731 - err_del_icc: 740 + err_remove_nodes: 732 741 icc_nodes_remove(provider); 733 - icc_provider_del(provider); 734 - 735 - err_disable_clks: 736 742 clk_bulk_disable_unprepare(qp->num_clks, qp->bus_clks); 737 743 738 744 return ret; ··· 743 747 { 744 748 struct msm8974_icc_provider *qp = platform_get_drvdata(pdev); 745 749 750 + icc_provider_deregister(&qp->provider); 746 751 icc_nodes_remove(&qp->provider); 747 752 clk_bulk_disable_unprepare(qp->num_clks, qp->bus_clks); 748 - icc_provider_del(&qp->provider); 749 753 750 754 return 0; 751 755 }
+7 -9
drivers/interconnect/qcom/osm-l3.c
··· 158 158 { 159 159 struct qcom_osm_l3_icc_provider *qp = platform_get_drvdata(pdev); 160 160 161 + icc_provider_deregister(&qp->provider); 161 162 icc_nodes_remove(&qp->provider); 162 - icc_provider_del(&qp->provider); 163 163 164 164 return 0; 165 165 } ··· 236 236 qnodes = desc->nodes; 237 237 num_nodes = desc->num_nodes; 238 238 239 - data = devm_kcalloc(&pdev->dev, num_nodes, sizeof(*node), GFP_KERNEL); 239 + data = devm_kzalloc(&pdev->dev, struct_size(data, nodes, num_nodes), GFP_KERNEL); 240 240 if (!data) 241 241 return -ENOMEM; 242 242 ··· 245 245 provider->set = qcom_osm_l3_set; 246 246 provider->aggregate = icc_std_aggregate; 247 247 provider->xlate = of_icc_xlate_onecell; 248 - INIT_LIST_HEAD(&provider->nodes); 249 248 provider->data = data; 250 249 251 - ret = icc_provider_add(provider); 252 - if (ret) { 253 - dev_err(&pdev->dev, "error adding interconnect provider\n"); 254 - return ret; 255 - } 250 + icc_provider_init(provider); 256 251 257 252 for (i = 0; i < num_nodes; i++) { 258 253 size_t j; ··· 270 275 } 271 276 data->num_nodes = num_nodes; 272 277 278 + ret = icc_provider_register(provider); 279 + if (ret) 280 + goto err; 281 + 273 282 platform_set_drvdata(pdev, qp); 274 283 275 284 return 0; 276 285 err: 277 286 icc_nodes_remove(provider); 278 - icc_provider_del(provider); 279 287 280 288 return ret; 281 289 }
+2 -2
drivers/interconnect/qcom/qcm2290.c
··· 147 147 .name = "mas_snoc_bimc_nrt", 148 148 .buswidth = 16, 149 149 .qos.ap_owned = true, 150 - .qos.qos_port = 2, 150 + .qos.qos_port = 3, 151 151 .qos.qos_mode = NOC_QOS_MODE_BYPASS, 152 - .mas_rpm_id = 163, 152 + .mas_rpm_id = 164, 153 153 .slv_rpm_id = -1, 154 154 .num_links = ARRAY_SIZE(mas_snoc_bimc_nrt_links), 155 155 .links = mas_snoc_bimc_nrt_links,
+2 -96
drivers/interconnect/qcom/sm8450.c
··· 1844 1844 .num_bcms = ARRAY_SIZE(system_noc_bcms), 1845 1845 }; 1846 1846 1847 - static int qnoc_probe(struct platform_device *pdev) 1848 - { 1849 - const struct qcom_icc_desc *desc; 1850 - struct icc_onecell_data *data; 1851 - struct icc_provider *provider; 1852 - struct qcom_icc_node * const *qnodes; 1853 - struct qcom_icc_provider *qp; 1854 - struct icc_node *node; 1855 - size_t num_nodes, i; 1856 - int ret; 1857 - 1858 - desc = device_get_match_data(&pdev->dev); 1859 - if (!desc) 1860 - return -EINVAL; 1861 - 1862 - qnodes = desc->nodes; 1863 - num_nodes = desc->num_nodes; 1864 - 1865 - qp = devm_kzalloc(&pdev->dev, sizeof(*qp), GFP_KERNEL); 1866 - if (!qp) 1867 - return -ENOMEM; 1868 - 1869 - data = devm_kcalloc(&pdev->dev, num_nodes, sizeof(*node), GFP_KERNEL); 1870 - if (!data) 1871 - return -ENOMEM; 1872 - 1873 - provider = &qp->provider; 1874 - provider->dev = &pdev->dev; 1875 - provider->set = qcom_icc_set; 1876 - provider->pre_aggregate = qcom_icc_pre_aggregate; 1877 - provider->aggregate = qcom_icc_aggregate; 1878 - provider->xlate_extended = qcom_icc_xlate_extended; 1879 - INIT_LIST_HEAD(&provider->nodes); 1880 - provider->data = data; 1881 - 1882 - qp->dev = &pdev->dev; 1883 - qp->bcms = desc->bcms; 1884 - qp->num_bcms = desc->num_bcms; 1885 - 1886 - qp->voter = of_bcm_voter_get(qp->dev, NULL); 1887 - if (IS_ERR(qp->voter)) 1888 - return PTR_ERR(qp->voter); 1889 - 1890 - ret = icc_provider_add(provider); 1891 - if (ret) { 1892 - dev_err(&pdev->dev, "error adding interconnect provider\n"); 1893 - return ret; 1894 - } 1895 - 1896 - for (i = 0; i < qp->num_bcms; i++) 1897 - qcom_icc_bcm_init(qp->bcms[i], &pdev->dev); 1898 - 1899 - for (i = 0; i < num_nodes; i++) { 1900 - size_t j; 1901 - 1902 - if (!qnodes[i]) 1903 - continue; 1904 - 1905 - node = icc_node_create(qnodes[i]->id); 1906 - if (IS_ERR(node)) { 1907 - ret = PTR_ERR(node); 1908 - goto err; 1909 - } 1910 - 1911 - node->name = qnodes[i]->name; 1912 - node->data = qnodes[i]; 1913 - icc_node_add(node, provider); 1914 - 1915 - for (j = 0; j < qnodes[i]->num_links; j++) 1916 - icc_link_create(node, qnodes[i]->links[j]); 1917 - 1918 - data->nodes[i] = node; 1919 - } 1920 - data->num_nodes = num_nodes; 1921 - 1922 - platform_set_drvdata(pdev, qp); 1923 - 1924 - return 0; 1925 - err: 1926 - icc_nodes_remove(provider); 1927 - icc_provider_del(provider); 1928 - return ret; 1929 - } 1930 - 1931 - static int qnoc_remove(struct platform_device *pdev) 1932 - { 1933 - struct qcom_icc_provider *qp = platform_get_drvdata(pdev); 1934 - 1935 - icc_nodes_remove(&qp->provider); 1936 - icc_provider_del(&qp->provider); 1937 - 1938 - return 0; 1939 - } 1940 - 1941 1847 static const struct of_device_id qnoc_of_match[] = { 1942 1848 { .compatible = "qcom,sm8450-aggre1-noc", 1943 1849 .data = &sm8450_aggre1_noc}, ··· 1872 1966 MODULE_DEVICE_TABLE(of, qnoc_of_match); 1873 1967 1874 1968 static struct platform_driver qnoc_driver = { 1875 - .probe = qnoc_probe, 1876 - .remove = qnoc_remove, 1969 + .probe = qcom_icc_rpmh_probe, 1970 + .remove = qcom_icc_rpmh_remove, 1877 1971 .driver = { 1878 1972 .name = "qnoc-sm8450", 1879 1973 .of_match_table = qnoc_of_match,
+2 -97
drivers/interconnect/qcom/sm8550.c
··· 2165 2165 .num_bcms = ARRAY_SIZE(system_noc_bcms), 2166 2166 }; 2167 2167 2168 - static int qnoc_probe(struct platform_device *pdev) 2169 - { 2170 - const struct qcom_icc_desc *desc; 2171 - struct icc_onecell_data *data; 2172 - struct icc_provider *provider; 2173 - struct qcom_icc_node * const *qnodes; 2174 - struct qcom_icc_provider *qp; 2175 - struct icc_node *node; 2176 - size_t num_nodes, i; 2177 - int ret; 2178 - 2179 - desc = device_get_match_data(&pdev->dev); 2180 - if (!desc) 2181 - return -EINVAL; 2182 - 2183 - qnodes = desc->nodes; 2184 - num_nodes = desc->num_nodes; 2185 - 2186 - qp = devm_kzalloc(&pdev->dev, sizeof(*qp), GFP_KERNEL); 2187 - if (!qp) 2188 - return -ENOMEM; 2189 - 2190 - data = devm_kcalloc(&pdev->dev, num_nodes, sizeof(*node), GFP_KERNEL); 2191 - if (!data) 2192 - return -ENOMEM; 2193 - 2194 - provider = &qp->provider; 2195 - provider->dev = &pdev->dev; 2196 - provider->set = qcom_icc_set; 2197 - provider->pre_aggregate = qcom_icc_pre_aggregate; 2198 - provider->aggregate = qcom_icc_aggregate; 2199 - provider->xlate_extended = qcom_icc_xlate_extended; 2200 - INIT_LIST_HEAD(&provider->nodes); 2201 - provider->data = data; 2202 - 2203 - qp->dev = &pdev->dev; 2204 - qp->bcms = desc->bcms; 2205 - qp->num_bcms = desc->num_bcms; 2206 - 2207 - qp->voter = of_bcm_voter_get(qp->dev, NULL); 2208 - if (IS_ERR(qp->voter)) 2209 - return PTR_ERR(qp->voter); 2210 - 2211 - ret = icc_provider_add(provider); 2212 - if (ret) { 2213 - dev_err_probe(&pdev->dev, ret, 2214 - "error adding interconnect provider\n"); 2215 - return ret; 2216 - } 2217 - 2218 - for (i = 0; i < qp->num_bcms; i++) 2219 - qcom_icc_bcm_init(qp->bcms[i], &pdev->dev); 2220 - 2221 - for (i = 0; i < num_nodes; i++) { 2222 - size_t j; 2223 - 2224 - if (!qnodes[i]) 2225 - continue; 2226 - 2227 - node = icc_node_create(qnodes[i]->id); 2228 - if (IS_ERR(node)) { 2229 - ret = PTR_ERR(node); 2230 - goto err; 2231 - } 2232 - 2233 - node->name = qnodes[i]->name; 2234 - node->data = qnodes[i]; 2235 - icc_node_add(node, provider); 2236 - 2237 - for (j = 0; j < qnodes[i]->num_links; j++) 2238 - icc_link_create(node, qnodes[i]->links[j]); 2239 - 2240 - data->nodes[i] = node; 2241 - } 2242 - data->num_nodes = num_nodes; 2243 - 2244 - platform_set_drvdata(pdev, qp); 2245 - 2246 - return 0; 2247 - err: 2248 - icc_nodes_remove(provider); 2249 - icc_provider_del(provider); 2250 - return ret; 2251 - } 2252 - 2253 - static int qnoc_remove(struct platform_device *pdev) 2254 - { 2255 - struct qcom_icc_provider *qp = platform_get_drvdata(pdev); 2256 - 2257 - icc_nodes_remove(&qp->provider); 2258 - icc_provider_del(&qp->provider); 2259 - 2260 - return 0; 2261 - } 2262 - 2263 2168 static const struct of_device_id qnoc_of_match[] = { 2264 2169 { .compatible = "qcom,sm8550-aggre1-noc", 2265 2170 .data = &sm8550_aggre1_noc}, ··· 2199 2294 MODULE_DEVICE_TABLE(of, qnoc_of_match); 2200 2295 2201 2296 static struct platform_driver qnoc_driver = { 2202 - .probe = qnoc_probe, 2203 - .remove = qnoc_remove, 2297 + .probe = qcom_icc_rpmh_probe, 2298 + .remove = qcom_icc_rpmh_remove, 2204 2299 .driver = { 2205 2300 .name = "qnoc-sm8550", 2206 2301 .of_match_table = qnoc_of_match,
+12 -18
drivers/interconnect/samsung/exynos.c
··· 96 96 static int exynos_generic_icc_remove(struct platform_device *pdev) 97 97 { 98 98 struct exynos_icc_priv *priv = platform_get_drvdata(pdev); 99 - struct icc_node *parent_node, *node = priv->node; 100 99 101 - parent_node = exynos_icc_get_parent(priv->dev->parent->of_node); 102 - if (parent_node && !IS_ERR(parent_node)) 103 - icc_link_destroy(node, parent_node); 104 - 100 + icc_provider_deregister(&priv->provider); 105 101 icc_nodes_remove(&priv->provider); 106 - icc_provider_del(&priv->provider); 107 102 108 103 return 0; 109 104 } ··· 127 132 provider->inter_set = true; 128 133 provider->data = priv; 129 134 130 - ret = icc_provider_add(provider); 131 - if (ret < 0) 132 - return ret; 135 + icc_provider_init(provider); 133 136 134 137 icc_node = icc_node_create(pdev->id); 135 - if (IS_ERR(icc_node)) { 136 - ret = PTR_ERR(icc_node); 137 - goto err_prov_del; 138 - } 138 + if (IS_ERR(icc_node)) 139 + return PTR_ERR(icc_node); 139 140 140 141 priv->node = icc_node; 141 142 icc_node->name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "%pOFn", ··· 140 149 &priv->bus_clk_ratio)) 141 150 priv->bus_clk_ratio = EXYNOS_ICC_DEFAULT_BUS_CLK_RATIO; 142 151 152 + icc_node->data = priv; 153 + icc_node_add(icc_node, provider); 154 + 143 155 /* 144 156 * Register a PM QoS request for the parent (devfreq) device. 145 157 */ ··· 150 156 DEV_PM_QOS_MIN_FREQUENCY, 0); 151 157 if (ret < 0) 152 158 goto err_node_del; 153 - 154 - icc_node->data = priv; 155 - icc_node_add(icc_node, provider); 156 159 157 160 icc_parent_node = exynos_icc_get_parent(bus_dev->of_node); 158 161 if (IS_ERR(icc_parent_node)) { ··· 162 171 goto err_pmqos_del; 163 172 } 164 173 174 + ret = icc_provider_register(provider); 175 + if (ret < 0) 176 + goto err_pmqos_del; 177 + 165 178 return 0; 166 179 167 180 err_pmqos_del: 168 181 dev_pm_qos_remove_request(&priv->qos_req); 169 182 err_node_del: 170 183 icc_nodes_remove(provider); 171 - err_prov_del: 172 - icc_provider_del(provider); 184 + 173 185 return ret; 174 186 } 175 187
+7 -9
drivers/memory/tegra/mc.c
··· 794 794 mc->provider.aggregate = mc->soc->icc_ops->aggregate; 795 795 mc->provider.xlate_extended = mc->soc->icc_ops->xlate_extended; 796 796 797 - err = icc_provider_add(&mc->provider); 798 - if (err) 799 - return err; 797 + icc_provider_init(&mc->provider); 800 798 801 799 /* create Memory Controller node */ 802 800 node = icc_node_create(TEGRA_ICC_MC); 803 - if (IS_ERR(node)) { 804 - err = PTR_ERR(node); 805 - goto del_provider; 806 - } 801 + if (IS_ERR(node)) 802 + return PTR_ERR(node); 807 803 808 804 node->name = "Memory Controller"; 809 805 icc_node_add(node, &mc->provider); ··· 826 830 goto remove_nodes; 827 831 } 828 832 833 + err = icc_provider_register(&mc->provider); 834 + if (err) 835 + goto remove_nodes; 836 + 829 837 return 0; 830 838 831 839 remove_nodes: 832 840 icc_nodes_remove(&mc->provider); 833 - del_provider: 834 - icc_provider_del(&mc->provider); 835 841 836 842 return err; 837 843 }
+6 -6
drivers/memory/tegra/tegra124-emc.c
··· 1351 1351 emc->provider.aggregate = soc->icc_ops->aggregate; 1352 1352 emc->provider.xlate_extended = emc_of_icc_xlate_extended; 1353 1353 1354 - err = icc_provider_add(&emc->provider); 1355 - if (err) 1356 - goto err_msg; 1354 + icc_provider_init(&emc->provider); 1357 1355 1358 1356 /* create External Memory Controller node */ 1359 1357 node = icc_node_create(TEGRA_ICC_EMC); 1360 1358 if (IS_ERR(node)) { 1361 1359 err = PTR_ERR(node); 1362 - goto del_provider; 1360 + goto err_msg; 1363 1361 } 1364 1362 1365 1363 node->name = "External Memory Controller"; ··· 1378 1380 node->name = "External Memory (DRAM)"; 1379 1381 icc_node_add(node, &emc->provider); 1380 1382 1383 + err = icc_provider_register(&emc->provider); 1384 + if (err) 1385 + goto remove_nodes; 1386 + 1381 1387 return 0; 1382 1388 1383 1389 remove_nodes: 1384 1390 icc_nodes_remove(&emc->provider); 1385 - del_provider: 1386 - icc_provider_del(&emc->provider); 1387 1391 err_msg: 1388 1392 dev_err(emc->dev, "failed to initialize ICC: %d\n", err); 1389 1393
+6 -6
drivers/memory/tegra/tegra20-emc.c
··· 1021 1021 emc->provider.aggregate = soc->icc_ops->aggregate; 1022 1022 emc->provider.xlate_extended = emc_of_icc_xlate_extended; 1023 1023 1024 - err = icc_provider_add(&emc->provider); 1025 - if (err) 1026 - goto err_msg; 1024 + icc_provider_init(&emc->provider); 1027 1025 1028 1026 /* create External Memory Controller node */ 1029 1027 node = icc_node_create(TEGRA_ICC_EMC); 1030 1028 if (IS_ERR(node)) { 1031 1029 err = PTR_ERR(node); 1032 - goto del_provider; 1030 + goto err_msg; 1033 1031 } 1034 1032 1035 1033 node->name = "External Memory Controller"; ··· 1048 1050 node->name = "External Memory (DRAM)"; 1049 1051 icc_node_add(node, &emc->provider); 1050 1052 1053 + err = icc_provider_register(&emc->provider); 1054 + if (err) 1055 + goto remove_nodes; 1056 + 1051 1057 return 0; 1052 1058 1053 1059 remove_nodes: 1054 1060 icc_nodes_remove(&emc->provider); 1055 - del_provider: 1056 - icc_provider_del(&emc->provider); 1057 1061 err_msg: 1058 1062 dev_err(emc->dev, "failed to initialize ICC: %d\n", err); 1059 1063
+6 -6
drivers/memory/tegra/tegra30-emc.c
··· 1533 1533 emc->provider.aggregate = soc->icc_ops->aggregate; 1534 1534 emc->provider.xlate_extended = emc_of_icc_xlate_extended; 1535 1535 1536 - err = icc_provider_add(&emc->provider); 1537 - if (err) 1538 - goto err_msg; 1536 + icc_provider_init(&emc->provider); 1539 1537 1540 1538 /* create External Memory Controller node */ 1541 1539 node = icc_node_create(TEGRA_ICC_EMC); 1542 1540 if (IS_ERR(node)) { 1543 1541 err = PTR_ERR(node); 1544 - goto del_provider; 1542 + goto err_msg; 1545 1543 } 1546 1544 1547 1545 node->name = "External Memory Controller"; ··· 1560 1562 node->name = "External Memory (DRAM)"; 1561 1563 icc_node_add(node, &emc->provider); 1562 1564 1565 + err = icc_provider_register(&emc->provider); 1566 + if (err) 1567 + goto remove_nodes; 1568 + 1563 1569 return 0; 1564 1570 1565 1571 remove_nodes: 1566 1572 icc_nodes_remove(&emc->provider); 1567 - del_provider: 1568 - icc_provider_del(&emc->provider); 1569 1573 err_msg: 1570 1574 dev_err(emc->dev, "failed to initialize ICC: %d\n", err); 1571 1575
+1 -1
drivers/nvmem/core.c
··· 1231 1231 "#nvmem-cell-cells", 1232 1232 index, &cell_spec); 1233 1233 if (ret) 1234 - return ERR_PTR(ret); 1234 + return ERR_PTR(-ENOENT); 1235 1235 1236 1236 if (cell_spec.args_count > 1) 1237 1237 return ERR_PTR(-EINVAL);
+12
include/linux/interconnect-provider.h
··· 122 122 void icc_node_add(struct icc_node *node, struct icc_provider *provider); 123 123 void icc_node_del(struct icc_node *node); 124 124 int icc_nodes_remove(struct icc_provider *provider); 125 + void icc_provider_init(struct icc_provider *provider); 126 + int icc_provider_register(struct icc_provider *provider); 127 + void icc_provider_deregister(struct icc_provider *provider); 125 128 int icc_provider_add(struct icc_provider *provider); 126 129 void icc_provider_del(struct icc_provider *provider); 127 130 struct icc_node_data *of_icc_get_from_provider(struct of_phandle_args *spec); ··· 169 166 { 170 167 return -ENOTSUPP; 171 168 } 169 + 170 + static inline void icc_provider_init(struct icc_provider *provider) { } 171 + 172 + static inline int icc_provider_register(struct icc_provider *provider) 173 + { 174 + return -ENOTSUPP; 175 + } 176 + 177 + static inline void icc_provider_deregister(struct icc_provider *provider) { } 172 178 173 179 static inline int icc_provider_add(struct icc_provider *provider) 174 180 {