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 'i2c-for-6.16-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/wsa/linux

Pull i2c fixes from Wolfram Sang:

- subsystem: convert drivers to use recent callbacks of struct
i2c_algorithm A typical after-rc1 cleanup, which I couldn't send in
time for rc2

- tegra: fix YAML conversion of device tree bindings

- k1: re-add a check which got lost during upstreaming

* tag 'i2c-for-6.16-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/wsa/linux:
i2c: k1: check for transfer error
i2c: use inclusive callbacks in struct i2c_algorithm
dt-bindings: i2c: nvidia,tegra20-i2c: Specify the required properties

Linus Torvalds b67ec639 5c00eca9

+125 -103
+23 -1
Documentation/devicetree/bindings/i2c/nvidia,tegra20-i2c.yaml
··· 97 97 98 98 resets: 99 99 items: 100 - - description: module reset 100 + - description: 101 + Module reset. This property is optional for controllers in Tegra194, 102 + Tegra234 etc where an internal software reset is available as an 103 + alternative. 101 104 102 105 reset-names: 103 106 items: ··· 118 115 items: 119 116 - const: rx 120 117 - const: tx 118 + 119 + required: 120 + - compatible 121 + - reg 122 + - interrupts 123 + - clocks 124 + - clock-names 121 125 122 126 allOf: 123 127 - $ref: /schemas/i2c/i2c-controller.yaml ··· 178 168 else: 179 169 properties: 180 170 power-domains: false 171 + 172 + - if: 173 + not: 174 + properties: 175 + compatible: 176 + contains: 177 + enum: 178 + - nvidia,tegra194-i2c 179 + then: 180 + required: 181 + - resets 182 + - reset-names 181 183 182 184 unevaluatedProperties: false 183 185
+2 -2
drivers/i2c/algos/i2c-algo-bit.c
··· 619 619 /* -----exported algorithm data: ------------------------------------- */ 620 620 621 621 const struct i2c_algorithm i2c_bit_algo = { 622 - .master_xfer = bit_xfer, 623 - .master_xfer_atomic = bit_xfer_atomic, 622 + .xfer = bit_xfer, 623 + .xfer_atomic = bit_xfer_atomic, 624 624 .functionality = bit_func, 625 625 }; 626 626 EXPORT_SYMBOL(i2c_bit_algo);
+2 -2
drivers/i2c/algos/i2c-algo-pca.c
··· 361 361 } 362 362 363 363 static const struct i2c_algorithm pca_algo = { 364 - .master_xfer = pca_xfer, 365 - .functionality = pca_func, 364 + .xfer = pca_xfer, 365 + .functionality = pca_func, 366 366 }; 367 367 368 368 static unsigned int pca_probe_chip(struct i2c_adapter *adap)
+2 -2
drivers/i2c/algos/i2c-algo-pcf.c
··· 389 389 390 390 /* exported algorithm data: */ 391 391 static const struct i2c_algorithm pcf_algo = { 392 - .master_xfer = pcf_xfer, 393 - .functionality = pcf_func, 392 + .xfer = pcf_xfer, 393 + .functionality = pcf_func, 394 394 }; 395 395 396 396 /*
+1 -1
drivers/i2c/busses/i2c-amd-mp2-plat.c
··· 179 179 } 180 180 181 181 static const struct i2c_algorithm i2c_amd_algorithm = { 182 - .master_xfer = i2c_amd_xfer, 182 + .xfer = i2c_amd_xfer, 183 183 .functionality = i2c_amd_func, 184 184 }; 185 185
+4 -4
drivers/i2c/busses/i2c-aspeed.c
··· 814 814 #endif /* CONFIG_I2C_SLAVE */ 815 815 816 816 static const struct i2c_algorithm aspeed_i2c_algo = { 817 - .master_xfer = aspeed_i2c_master_xfer, 818 - .functionality = aspeed_i2c_functionality, 817 + .xfer = aspeed_i2c_master_xfer, 818 + .functionality = aspeed_i2c_functionality, 819 819 #if IS_ENABLED(CONFIG_I2C_SLAVE) 820 - .reg_slave = aspeed_i2c_reg_slave, 821 - .unreg_slave = aspeed_i2c_unreg_slave, 820 + .reg_slave = aspeed_i2c_reg_slave, 821 + .unreg_slave = aspeed_i2c_unreg_slave, 822 822 #endif /* CONFIG_I2C_SLAVE */ 823 823 }; 824 824
+2 -2
drivers/i2c/busses/i2c-at91-master.c
··· 739 739 } 740 740 741 741 static const struct i2c_algorithm at91_twi_algorithm = { 742 - .master_xfer = at91_twi_xfer, 743 - .functionality = at91_twi_func, 742 + .xfer = at91_twi_xfer, 743 + .functionality = at91_twi_func, 744 744 }; 745 745 746 746 static int at91_twi_configure_dma(struct at91_twi_dev *dev, u32 phy_addr)
+1 -1
drivers/i2c/busses/i2c-axxia.c
··· 706 706 } 707 707 708 708 static const struct i2c_algorithm axxia_i2c_algo = { 709 - .master_xfer = axxia_i2c_xfer, 709 + .xfer = axxia_i2c_xfer, 710 710 .functionality = axxia_i2c_func, 711 711 .reg_slave = axxia_i2c_reg_slave, 712 712 .unreg_slave = axxia_i2c_unreg_slave,
+1 -1
drivers/i2c/busses/i2c-bcm-iproc.c
··· 1041 1041 } 1042 1042 1043 1043 static struct i2c_algorithm bcm_iproc_algo = { 1044 - .master_xfer = bcm_iproc_i2c_xfer, 1044 + .xfer = bcm_iproc_i2c_xfer, 1045 1045 .functionality = bcm_iproc_i2c_functionality, 1046 1046 .reg_slave = bcm_iproc_i2c_reg_slave, 1047 1047 .unreg_slave = bcm_iproc_i2c_unreg_slave,
+5 -5
drivers/i2c/busses/i2c-cadence.c
··· 1231 1231 #endif 1232 1232 1233 1233 static const struct i2c_algorithm cdns_i2c_algo = { 1234 - .master_xfer = cdns_i2c_master_xfer, 1235 - .master_xfer_atomic = cdns_i2c_master_xfer_atomic, 1236 - .functionality = cdns_i2c_func, 1234 + .xfer = cdns_i2c_master_xfer, 1235 + .xfer_atomic = cdns_i2c_master_xfer_atomic, 1236 + .functionality = cdns_i2c_func, 1237 1237 #if IS_ENABLED(CONFIG_I2C_SLAVE) 1238 - .reg_slave = cdns_reg_slave, 1239 - .unreg_slave = cdns_unreg_slave, 1238 + .reg_slave = cdns_reg_slave, 1239 + .unreg_slave = cdns_unreg_slave, 1240 1240 #endif 1241 1241 }; 1242 1242
+2 -2
drivers/i2c/busses/i2c-cgbc.c
··· 331 331 } 332 332 333 333 static const struct i2c_algorithm cgbc_i2c_algorithm = { 334 - .master_xfer = cgbc_i2c_xfer, 335 - .functionality = cgbc_i2c_func, 334 + .xfer = cgbc_i2c_xfer, 335 + .functionality = cgbc_i2c_func, 336 336 }; 337 337 338 338 static struct i2c_algo_cgbc_data cgbc_i2c_algo_data[] = {
+1 -1
drivers/i2c/busses/i2c-eg20t.c
··· 690 690 } 691 691 692 692 static const struct i2c_algorithm pch_algorithm = { 693 - .master_xfer = pch_i2c_xfer, 693 + .xfer = pch_i2c_xfer, 694 694 .functionality = pch_i2c_func 695 695 }; 696 696
+3 -3
drivers/i2c/busses/i2c-emev2.c
··· 351 351 } 352 352 353 353 static const struct i2c_algorithm em_i2c_algo = { 354 - .master_xfer = em_i2c_xfer, 354 + .xfer = em_i2c_xfer, 355 355 .functionality = em_i2c_func, 356 - .reg_slave = em_i2c_reg_slave, 357 - .unreg_slave = em_i2c_unreg_slave, 356 + .reg_slave = em_i2c_reg_slave, 357 + .unreg_slave = em_i2c_unreg_slave, 358 358 }; 359 359 360 360 static int em_i2c_probe(struct platform_device *pdev)
+3 -3
drivers/i2c/busses/i2c-exynos5.c
··· 879 879 } 880 880 881 881 static const struct i2c_algorithm exynos5_i2c_algorithm = { 882 - .master_xfer = exynos5_i2c_xfer, 883 - .master_xfer_atomic = exynos5_i2c_xfer_atomic, 884 - .functionality = exynos5_i2c_func, 882 + .xfer = exynos5_i2c_xfer, 883 + .xfer_atomic = exynos5_i2c_xfer_atomic, 884 + .functionality = exynos5_i2c_func, 885 885 }; 886 886 887 887 static int exynos5_i2c_probe(struct platform_device *pdev)
+3 -3
drivers/i2c/busses/i2c-gxp.c
··· 184 184 #endif 185 185 186 186 static const struct i2c_algorithm gxp_i2c_algo = { 187 - .master_xfer = gxp_i2c_master_xfer, 187 + .xfer = gxp_i2c_master_xfer, 188 188 .functionality = gxp_i2c_func, 189 189 #if IS_ENABLED(CONFIG_I2C_SLAVE) 190 - .reg_slave = gxp_i2c_reg_slave, 191 - .unreg_slave = gxp_i2c_unreg_slave, 190 + .reg_slave = gxp_i2c_reg_slave, 191 + .unreg_slave = gxp_i2c_unreg_slave, 192 192 #endif 193 193 }; 194 194
+1 -1
drivers/i2c/busses/i2c-img-scb.c
··· 1143 1143 } 1144 1144 1145 1145 static const struct i2c_algorithm img_i2c_algo = { 1146 - .master_xfer = img_i2c_xfer, 1146 + .xfer = img_i2c_xfer, 1147 1147 .functionality = img_i2c_func, 1148 1148 }; 1149 1149
+4 -4
drivers/i2c/busses/i2c-imx-lpi2c.c
··· 1268 1268 } 1269 1269 1270 1270 static const struct i2c_algorithm lpi2c_imx_algo = { 1271 - .master_xfer = lpi2c_imx_xfer, 1272 - .functionality = lpi2c_imx_func, 1273 - .reg_target = lpi2c_imx_register_target, 1274 - .unreg_target = lpi2c_imx_unregister_target, 1271 + .xfer = lpi2c_imx_xfer, 1272 + .functionality = lpi2c_imx_func, 1273 + .reg_target = lpi2c_imx_register_target, 1274 + .unreg_target = lpi2c_imx_unregister_target, 1275 1275 }; 1276 1276 1277 1277 static const struct of_device_id lpi2c_imx_of_match[] = {
+4 -4
drivers/i2c/busses/i2c-imx.c
··· 1692 1692 } 1693 1693 1694 1694 static const struct i2c_algorithm i2c_imx_algo = { 1695 - .master_xfer = i2c_imx_xfer, 1696 - .master_xfer_atomic = i2c_imx_xfer_atomic, 1695 + .xfer = i2c_imx_xfer, 1696 + .xfer_atomic = i2c_imx_xfer_atomic, 1697 1697 .functionality = i2c_imx_func, 1698 - .reg_slave = i2c_imx_reg_slave, 1699 - .unreg_slave = i2c_imx_unreg_slave, 1698 + .reg_slave = i2c_imx_reg_slave, 1699 + .unreg_slave = i2c_imx_unreg_slave, 1700 1700 }; 1701 1701 1702 1702 static int i2c_imx_probe(struct platform_device *pdev)
+1 -1
drivers/i2c/busses/i2c-k1.c
··· 477 477 478 478 ret = spacemit_i2c_wait_bus_idle(i2c); 479 479 if (!ret) 480 - spacemit_i2c_xfer_msg(i2c); 480 + ret = spacemit_i2c_xfer_msg(i2c); 481 481 else if (ret < 0) 482 482 dev_dbg(i2c->dev, "i2c transfer error: %d\n", ret); 483 483 else
+1 -1
drivers/i2c/busses/i2c-keba.c
··· 500 500 } 501 501 502 502 static const struct i2c_algorithm ki2c_algo = { 503 - .master_xfer = ki2c_xfer, 503 + .xfer = ki2c_xfer, 504 504 .functionality = ki2c_func, 505 505 }; 506 506
+1 -1
drivers/i2c/busses/i2c-mchp-pci1xxxx.c
··· 1048 1048 } 1049 1049 1050 1050 static const struct i2c_algorithm pci1xxxx_i2c_algo = { 1051 - .master_xfer = pci1xxxx_i2c_xfer, 1051 + .xfer = pci1xxxx_i2c_xfer, 1052 1052 .functionality = pci1xxxx_i2c_get_funcs, 1053 1053 }; 1054 1054
+2 -2
drivers/i2c/busses/i2c-meson.c
··· 448 448 } 449 449 450 450 static const struct i2c_algorithm meson_i2c_algorithm = { 451 - .master_xfer = meson_i2c_xfer, 452 - .master_xfer_atomic = meson_i2c_xfer_atomic, 451 + .xfer = meson_i2c_xfer, 452 + .xfer_atomic = meson_i2c_xfer_atomic, 453 453 .functionality = meson_i2c_func, 454 454 }; 455 455
+1 -1
drivers/i2c/busses/i2c-microchip-corei2c.c
··· 526 526 } 527 527 528 528 static const struct i2c_algorithm mchp_corei2c_algo = { 529 - .master_xfer = mchp_corei2c_xfer, 529 + .xfer = mchp_corei2c_xfer, 530 530 .functionality = mchp_corei2c_func, 531 531 .smbus_xfer = mchp_corei2c_smbus_xfer, 532 532 };
+1 -1
drivers/i2c/busses/i2c-mt65xx.c
··· 1342 1342 } 1343 1343 1344 1344 static const struct i2c_algorithm mtk_i2c_algorithm = { 1345 - .master_xfer = mtk_i2c_transfer, 1345 + .xfer = mtk_i2c_transfer, 1346 1346 .functionality = mtk_i2c_functionality, 1347 1347 }; 1348 1348
+1 -1
drivers/i2c/busses/i2c-mxs.c
··· 687 687 } 688 688 689 689 static const struct i2c_algorithm mxs_i2c_algo = { 690 - .master_xfer = mxs_i2c_xfer, 690 + .xfer = mxs_i2c_xfer, 691 691 .functionality = mxs_i2c_func, 692 692 }; 693 693
+2 -2
drivers/i2c/busses/i2c-nomadik.c
··· 996 996 } 997 997 998 998 static const struct i2c_algorithm nmk_i2c_algo = { 999 - .master_xfer = nmk_i2c_xfer, 1000 - .functionality = nmk_i2c_functionality 999 + .xfer = nmk_i2c_xfer, 1000 + .functionality = nmk_i2c_functionality 1001 1001 }; 1002 1002 1003 1003 static void nmk_i2c_of_probe(struct device_node *np,
+3 -3
drivers/i2c/busses/i2c-npcm7xx.c
··· 2470 2470 }; 2471 2471 2472 2472 static const struct i2c_algorithm npcm_i2c_algo = { 2473 - .master_xfer = npcm_i2c_master_xfer, 2473 + .xfer = npcm_i2c_master_xfer, 2474 2474 .functionality = npcm_i2c_functionality, 2475 2475 #if IS_ENABLED(CONFIG_I2C_SLAVE) 2476 - .reg_slave = npcm_i2c_reg_slave, 2477 - .unreg_slave = npcm_i2c_unreg_slave, 2476 + .reg_slave = npcm_i2c_reg_slave, 2477 + .unreg_slave = npcm_i2c_unreg_slave, 2478 2478 #endif 2479 2479 }; 2480 2480
+3 -3
drivers/i2c/busses/i2c-omap.c
··· 1201 1201 } 1202 1202 1203 1203 static const struct i2c_algorithm omap_i2c_algo = { 1204 - .master_xfer = omap_i2c_xfer_irq, 1205 - .master_xfer_atomic = omap_i2c_xfer_polling, 1206 - .functionality = omap_i2c_func, 1204 + .xfer = omap_i2c_xfer_irq, 1205 + .xfer_atomic = omap_i2c_xfer_polling, 1206 + .functionality = omap_i2c_func, 1207 1207 }; 1208 1208 1209 1209 static const struct i2c_adapter_quirks omap_i2c_quirks = {
+1 -1
drivers/i2c/busses/i2c-pnx.c
··· 580 580 } 581 581 582 582 static const struct i2c_algorithm pnx_algorithm = { 583 - .master_xfer = i2c_pnx_xfer, 583 + .xfer = i2c_pnx_xfer, 584 584 .functionality = i2c_pnx_func, 585 585 }; 586 586
+8 -8
drivers/i2c/busses/i2c-pxa.c
··· 1154 1154 } 1155 1155 1156 1156 static const struct i2c_algorithm i2c_pxa_algorithm = { 1157 - .master_xfer = i2c_pxa_xfer, 1158 - .functionality = i2c_pxa_functionality, 1157 + .xfer = i2c_pxa_xfer, 1158 + .functionality = i2c_pxa_functionality, 1159 1159 #ifdef CONFIG_I2C_PXA_SLAVE 1160 - .reg_slave = i2c_pxa_slave_reg, 1161 - .unreg_slave = i2c_pxa_slave_unreg, 1160 + .reg_slave = i2c_pxa_slave_reg, 1161 + .unreg_slave = i2c_pxa_slave_unreg, 1162 1162 #endif 1163 1163 }; 1164 1164 ··· 1244 1244 } 1245 1245 1246 1246 static const struct i2c_algorithm i2c_pxa_pio_algorithm = { 1247 - .master_xfer = i2c_pxa_pio_xfer, 1248 - .functionality = i2c_pxa_functionality, 1247 + .xfer = i2c_pxa_pio_xfer, 1248 + .functionality = i2c_pxa_functionality, 1249 1249 #ifdef CONFIG_I2C_PXA_SLAVE 1250 - .reg_slave = i2c_pxa_slave_reg, 1251 - .unreg_slave = i2c_pxa_slave_unreg, 1250 + .reg_slave = i2c_pxa_slave_reg, 1251 + .unreg_slave = i2c_pxa_slave_unreg, 1252 1252 #endif 1253 1253 }; 1254 1254
+2 -2
drivers/i2c/busses/i2c-qcom-cci.c
··· 462 462 } 463 463 464 464 static const struct i2c_algorithm cci_algo = { 465 - .master_xfer = cci_xfer, 466 - .functionality = cci_func, 465 + .xfer = cci_xfer, 466 + .functionality = cci_func, 467 467 }; 468 468 469 469 static int cci_enable_clocks(struct cci *cci)
+2 -2
drivers/i2c/busses/i2c-qcom-geni.c
··· 727 727 } 728 728 729 729 static const struct i2c_algorithm geni_i2c_algo = { 730 - .master_xfer = geni_i2c_xfer, 731 - .functionality = geni_i2c_func, 730 + .xfer = geni_i2c_xfer, 731 + .functionality = geni_i2c_func, 732 732 }; 733 733 734 734 #ifdef CONFIG_ACPI
+4 -4
drivers/i2c/busses/i2c-qup.c
··· 1634 1634 } 1635 1635 1636 1636 static const struct i2c_algorithm qup_i2c_algo = { 1637 - .master_xfer = qup_i2c_xfer, 1638 - .functionality = qup_i2c_func, 1637 + .xfer = qup_i2c_xfer, 1638 + .functionality = qup_i2c_func, 1639 1639 }; 1640 1640 1641 1641 static const struct i2c_algorithm qup_i2c_algo_v2 = { 1642 - .master_xfer = qup_i2c_xfer_v2, 1643 - .functionality = qup_i2c_func, 1642 + .xfer = qup_i2c_xfer_v2, 1643 + .functionality = qup_i2c_func, 1644 1644 }; 1645 1645 1646 1646 /*
+5 -5
drivers/i2c/busses/i2c-rcar.c
··· 1084 1084 } 1085 1085 1086 1086 static const struct i2c_algorithm rcar_i2c_algo = { 1087 - .master_xfer = rcar_i2c_master_xfer, 1088 - .master_xfer_atomic = rcar_i2c_master_xfer_atomic, 1089 - .functionality = rcar_i2c_func, 1090 - .reg_slave = rcar_reg_slave, 1091 - .unreg_slave = rcar_unreg_slave, 1087 + .xfer = rcar_i2c_master_xfer, 1088 + .xfer_atomic = rcar_i2c_master_xfer_atomic, 1089 + .functionality = rcar_i2c_func, 1090 + .reg_slave = rcar_reg_slave, 1091 + .unreg_slave = rcar_unreg_slave, 1092 1092 }; 1093 1093 1094 1094 static const struct i2c_adapter_quirks rcar_i2c_quirks = {
+3 -3
drivers/i2c/busses/i2c-s3c2410.c
··· 800 800 801 801 /* i2c bus registration info */ 802 802 static const struct i2c_algorithm s3c24xx_i2c_algorithm = { 803 - .master_xfer = s3c24xx_i2c_xfer, 804 - .master_xfer_atomic = s3c24xx_i2c_xfer_atomic, 805 - .functionality = s3c24xx_i2c_func, 803 + .xfer = s3c24xx_i2c_xfer, 804 + .xfer_atomic = s3c24xx_i2c_xfer_atomic, 805 + .functionality = s3c24xx_i2c_func, 806 806 }; 807 807 808 808 /*
+2 -2
drivers/i2c/busses/i2c-sh7760.c
··· 379 379 } 380 380 381 381 static const struct i2c_algorithm sh7760_i2c_algo = { 382 - .master_xfer = sh7760_i2c_master_xfer, 383 - .functionality = sh7760_i2c_func, 382 + .xfer = sh7760_i2c_master_xfer, 383 + .functionality = sh7760_i2c_func, 384 384 }; 385 385 386 386 /* calculate CCR register setting for a desired scl clock. SCL clock is
+2 -2
drivers/i2c/busses/i2c-sh_mobile.c
··· 740 740 741 741 static const struct i2c_algorithm sh_mobile_i2c_algorithm = { 742 742 .functionality = sh_mobile_i2c_func, 743 - .master_xfer = sh_mobile_i2c_xfer, 744 - .master_xfer_atomic = sh_mobile_i2c_xfer_atomic, 743 + .xfer = sh_mobile_i2c_xfer, 744 + .xfer_atomic = sh_mobile_i2c_xfer_atomic, 745 745 }; 746 746 747 747 static const struct i2c_adapter_quirks sh_mobile_i2c_quirks = {
+2 -2
drivers/i2c/busses/i2c-stm32f7.c
··· 2151 2151 } 2152 2152 2153 2153 static const struct i2c_algorithm stm32f7_i2c_algo = { 2154 - .master_xfer = stm32f7_i2c_xfer, 2155 - .master_xfer_atomic = stm32f7_i2c_xfer_atomic, 2154 + .xfer = stm32f7_i2c_xfer, 2155 + .xfer_atomic = stm32f7_i2c_xfer_atomic, 2156 2156 .smbus_xfer = stm32f7_i2c_smbus_xfer, 2157 2157 .functionality = stm32f7_i2c_func, 2158 2158 .reg_slave = stm32f7_i2c_reg_slave,
+2 -2
drivers/i2c/busses/i2c-synquacer.c
··· 520 520 } 521 521 522 522 static const struct i2c_algorithm synquacer_i2c_algo = { 523 - .master_xfer = synquacer_i2c_xfer, 524 - .functionality = synquacer_i2c_functionality, 523 + .xfer = synquacer_i2c_xfer, 524 + .functionality = synquacer_i2c_functionality, 525 525 }; 526 526 527 527 static const struct i2c_adapter synquacer_i2c_ops = {
+3 -3
drivers/i2c/busses/i2c-tegra.c
··· 1440 1440 } 1441 1441 1442 1442 static const struct i2c_algorithm tegra_i2c_algo = { 1443 - .master_xfer = tegra_i2c_xfer, 1444 - .master_xfer_atomic = tegra_i2c_xfer_atomic, 1445 - .functionality = tegra_i2c_func, 1443 + .xfer = tegra_i2c_xfer, 1444 + .xfer_atomic = tegra_i2c_xfer_atomic, 1445 + .functionality = tegra_i2c_func, 1446 1446 }; 1447 1447 1448 1448 /* payload size is only 12 bit */
+2 -2
drivers/i2c/busses/i2c-xiic.c
··· 1398 1398 } 1399 1399 1400 1400 static const struct i2c_algorithm xiic_algorithm = { 1401 - .master_xfer = xiic_xfer, 1402 - .master_xfer_atomic = xiic_xfer_atomic, 1401 + .xfer = xiic_xfer, 1402 + .xfer_atomic = xiic_xfer_atomic, 1403 1403 .functionality = xiic_func, 1404 1404 }; 1405 1405
+1 -1
drivers/i2c/busses/i2c-xlp9xx.c
··· 452 452 } 453 453 454 454 static const struct i2c_algorithm xlp9xx_i2c_algo = { 455 - .master_xfer = xlp9xx_i2c_xfer, 455 + .xfer = xlp9xx_i2c_xfer, 456 456 .functionality = xlp9xx_i2c_functionality, 457 457 }; 458 458
+1 -1
drivers/i2c/i2c-atr.c
··· 738 738 atr->flags = flags; 739 739 740 740 if (parent->algo->master_xfer) 741 - atr->algo.master_xfer = i2c_atr_master_xfer; 741 + atr->algo.xfer = i2c_atr_master_xfer; 742 742 if (parent->algo->smbus_xfer) 743 743 atr->algo.smbus_xfer = i2c_atr_smbus_xfer; 744 744 atr->algo.functionality = i2c_atr_functionality;
+3 -3
drivers/i2c/i2c-mux.c
··· 293 293 */ 294 294 if (parent->algo->master_xfer) { 295 295 if (muxc->mux_locked) 296 - priv->algo.master_xfer = i2c_mux_master_xfer; 296 + priv->algo.xfer = i2c_mux_master_xfer; 297 297 else 298 - priv->algo.master_xfer = __i2c_mux_master_xfer; 298 + priv->algo.xfer = __i2c_mux_master_xfer; 299 299 } 300 300 if (parent->algo->master_xfer_atomic) 301 - priv->algo.master_xfer_atomic = priv->algo.master_xfer; 301 + priv->algo.xfer_atomic = priv->algo.master_xfer; 302 302 303 303 if (parent->algo->smbus_xfer) { 304 304 if (muxc->mux_locked)
+2 -2
drivers/i2c/muxes/i2c-demux-pinctrl.c
··· 95 95 priv->cur_chan = new_chan; 96 96 97 97 /* Now fill out current adapter structure. cur_chan must be up to date */ 98 - priv->algo.master_xfer = i2c_demux_master_xfer; 98 + priv->algo.xfer = i2c_demux_master_xfer; 99 99 if (adap->algo->master_xfer_atomic) 100 - priv->algo.master_xfer_atomic = i2c_demux_master_xfer; 100 + priv->algo.xfer_atomic = i2c_demux_master_xfer; 101 101 priv->algo.functionality = i2c_demux_functionality; 102 102 103 103 snprintf(priv->cur_adap.name, sizeof(priv->cur_adap.name),