lael-labs/linux

Documentation/devicetree/bindings/i2c/brcm,bcm2835-i2c.txt+3−1

@@ -1,7 +1,9 @@
1	Broadcom BCM2835 I2C controller	1	Broadcom BCM2835 I2C controller
2		2
3	Required properties:	3	Required properties:
4	- compatible : Should be "brcm,bcm2835-i2c".	4	- compatible : Should be one of:
		5	"brcm,bcm2711-i2c"
		6	"brcm,bcm2835-i2c"
5	- reg: Should contain register location and length.	7	- reg: Should contain register location and length.
6	- interrupts: Should contain interrupt.	8	- interrupts: Should contain interrupt.
7	- clocks : The clock feeding the I2C controller.	9	- clocks : The clock feeding the I2C controller.

Documentation/devicetree/bindings/i2c/renesas,i2c.txtrenamed from Documentation/devicetree/bindings/i2c/i2c-rcar.txt+0−0

File renamed without changes.

Documentation/devicetree/bindings/i2c/renesas,iic-emev2.txtrenamed from Documentation/devicetree/bindings/i2c/i2c-emev2.txt+0−0

File renamed without changes.

Documentation/devicetree/bindings/i2c/renesas,iic.txtrenamed from Documentation/devicetree/bindings/i2c/i2c-sh_mobile.txt+0−0

File renamed without changes.

Documentation/devicetree/bindings/i2c/renesas,riic.txtrenamed from Documentation/devicetree/bindings/i2c/i2c-riic.txt+0−0

File renamed without changes.

MAINTAINERS+10−4

@@ -7865,6 +7865,12 @@ S: Maintained · 7864 unmodified lines
7865	F: drivers/mfd/lpc_ich.c	7865	F: drivers/mfd/lpc_ich.c
7866	F: drivers/gpio/gpio-ich.c	7866	F: drivers/gpio/gpio-ich.c
7867		7867
		7868	ICY I2C DRIVER
		7869	M: Max Staudt <max@enpas.org>
		7870	L: linux-i2c@vger.kernel.org
		7871	S: Maintained
		7872	F: drivers/i2c/busses/i2c-icy.c
		7873
7868	IDE SUBSYSTEM	7874	IDE SUBSYSTEM
7869	M: "David S. Miller" <davem@davemloft.net>	7875	M: "David S. Miller" <davem@davemloft.net>
7870	L: linux-ide@vger.kernel.org	7876	L: linux-ide@vger.kernel.org
@@ -13791,7 +13797,7 @@ F: drivers/clk/renesas/ · 5920 unmodified lines
13791	RENESAS EMEV2 I2C DRIVER	13797	RENESAS EMEV2 I2C DRIVER
13792	M: Wolfram Sang <wsa+renesas@sang-engineering.com>	13798	M: Wolfram Sang <wsa+renesas@sang-engineering.com>
13793	S: Supported	13799	S: Supported
13794	F: Documentation/devicetree/bindings/i2c/i2c-emev2.txt	13800	F: Documentation/devicetree/bindings/i2c/renesas,iic-emev2.txt
13795	F: drivers/i2c/busses/i2c-emev2.c	13801	F: drivers/i2c/busses/i2c-emev2.c
13796		13802
13797	RENESAS ETHERNET DRIVERS	13803	RENESAS ETHERNET DRIVERS
@@ -13813,15 +13819,15 @@ F: drivers/iio/adc/rcar-gyroadc.c · 15 unmodified lines
13813	RENESAS R-CAR I2C DRIVERS	13819	RENESAS R-CAR I2C DRIVERS
13814	M: Wolfram Sang <wsa+renesas@sang-engineering.com>	13820	M: Wolfram Sang <wsa+renesas@sang-engineering.com>
13815	S: Supported	13821	S: Supported
13816	F: Documentation/devicetree/bindings/i2c/i2c-rcar.txt	13822	F: Documentation/devicetree/bindings/i2c/renesas,i2c.txt
13817	F: Documentation/devicetree/bindings/i2c/i2c-sh_mobile.txt	13823	F: Documentation/devicetree/bindings/i2c/renesas,iic.txt
13818	F: drivers/i2c/busses/i2c-rcar.c	13824	F: drivers/i2c/busses/i2c-rcar.c
13819	F: drivers/i2c/busses/i2c-sh_mobile.c	13825	F: drivers/i2c/busses/i2c-sh_mobile.c
13820		13826
13821	RENESAS RIIC DRIVER	13827	RENESAS RIIC DRIVER
13822	M: Chris Brandt <chris.brandt@renesas.com>	13828	M: Chris Brandt <chris.brandt@renesas.com>
13823	S: Supported	13829	S: Supported
13824	F: Documentation/devicetree/bindings/i2c/i2c-riic.txt	13830	F: Documentation/devicetree/bindings/i2c/renesas,riic.txt
13825	F: drivers/i2c/busses/i2c-riic.c	13831	F: drivers/i2c/busses/i2c-riic.c
13826		13832
13827	RENESAS USB PHY DRIVER	13833	RENESAS USB PHY DRIVER

drivers/acpi/acpi_apd.c+7−0

 	.setup = acpi_apd_setup,
 	.fixed_clk_rate = 250000000,
 };
 static const struct apd_device_desc thunderx2_i2c_desc = {
 	.setup = acpi_apd_setup,
 	.fixed_clk_rate = 125000000,
 };
+static const struct apd_device_desc nxp_i2c_desc = {
+	.setup = acpi_apd_setup,
+	.fixed_clk_rate = 350000000,
+};
 static const struct apd_device_desc hip08_spi_desc = {
 	.setup = acpi_apd_setup,
 	.fixed_clk_rate = 250000000,
 	{ "HISI02A1", APD_ADDR(hip07_i2c_desc) },
 	{ "HISI02A2", APD_ADDR(hip08_i2c_desc) },
 	{ "HISI0173", APD_ADDR(hip08_spi_desc) },
+	{ "NXP0001", APD_ADDR(nxp_i2c_desc) },
 #endif
 	{ }
 };

drivers/gpu/drm/bridge/adv7511/adv7511_drv.c+9−9

@@ -978,10 +978,10 @@ static int adv7511_init_cec_regmap(struct adv7511 *adv) · 977 unmodified lines
978	{	978	{
979	int ret;	979	int ret;
980		980
981	adv->i2c_cec = i2c_new_secondary_device(adv->i2c_main, "cec",	981	adv->i2c_cec = i2c_new_ancillary_device(adv->i2c_main, "cec",
982	ADV7511_CEC_I2C_ADDR_DEFAULT);	982	ADV7511_CEC_I2C_ADDR_DEFAULT);
983	if (!adv->i2c_cec)	983	if (IS_ERR(adv->i2c_cec))
984	return -EINVAL;	984	return PTR_ERR(adv->i2c_cec);
985	i2c_set_clientdata(adv->i2c_cec, adv);	985	i2c_set_clientdata(adv->i2c_cec, adv);
986		986
987	adv->regmap_cec = devm_regmap_init_i2c(adv->i2c_cec,	987	adv->regmap_cec = devm_regmap_init_i2c(adv->i2c_cec,
@@ -1162,20 +1162,20 @@ static int adv7511_probe(struct i2c_client i2c, const struct i2c_device_id id) · 174 unmodified lines
1162		1162
1163	adv7511_packet_disable(adv7511, 0xffff);	1163	adv7511_packet_disable(adv7511, 0xffff);
1164		1164
1165	adv7511->i2c_edid = i2c_new_secondary_device(i2c, "edid",	1165	adv7511->i2c_edid = i2c_new_ancillary_device(i2c, "edid",
1166	ADV7511_EDID_I2C_ADDR_DEFAULT);	1166	ADV7511_EDID_I2C_ADDR_DEFAULT);
1167	if (!adv7511->i2c_edid) {	1167	if (IS_ERR(adv7511->i2c_edid)) {
1168	ret = -EINVAL;	1168	ret = PTR_ERR(adv7511->i2c_edid);
1169	goto uninit_regulators;	1169	goto uninit_regulators;
1170	}	1170	}
1171		1171
1172	regmap_write(adv7511->regmap, ADV7511_REG_EDID_I2C_ADDR,	1172	regmap_write(adv7511->regmap, ADV7511_REG_EDID_I2C_ADDR,
1173	adv7511->i2c_edid->addr << 1);	1173	adv7511->i2c_edid->addr << 1);
1174		1174
1175	adv7511->i2c_packet = i2c_new_secondary_device(i2c, "packet",	1175	adv7511->i2c_packet = i2c_new_ancillary_device(i2c, "packet",
1176	ADV7511_PACKET_I2C_ADDR_DEFAULT);	1176	ADV7511_PACKET_I2C_ADDR_DEFAULT);
1177	if (!adv7511->i2c_packet) {	1177	if (IS_ERR(adv7511->i2c_packet)) {
1178	ret = -EINVAL;	1178	ret = PTR_ERR(adv7511->i2c_packet);
1179	goto err_i2c_unregister_edid;	1179	goto err_i2c_unregister_edid;
1180	}	1180	}
1181		1181

drivers/i2c/busses/Kconfig+16−1

 	tristate "Axxia I2C controller"
 	depends on ARCH_AXXIA || COMPILE_TEST
 	default ARCH_AXXIA
+	select I2C_SLAVE
 	help
 	  Say yes if you want to support the I2C bus on Axxia platforms.
 	  will be called i2c-sirf.
 config I2C_SPRD
-	bool "Spreadtrum I2C interface"
+	tristate "Spreadtrum I2C interface"
 	depends on I2C=y && ARCH_SPRD
 	help
 	  If you say yes to this option, support will be included for the
 	  This support is also available as a module.  If so, the module
 	  will be called i2c-elektor.
+config I2C_ICY
+	tristate "ICY Zorro card"
+	depends on ZORRO
+	select I2C_ALGOPCF
+	help
+	  This supports the PCF8584 Zorro bus I2C adapter, known as ICY.
+	  Say Y if you own such an adapter.
+	  This support is also available as a module.  If so, the module
+	  will be called i2c-icy.
+	  If you have a 2019 edition board with an LTC2990 sensor at address
+	  0x4c, loading the module 'ltc2990' is sufficient to enable it.
 config I2C_MLXCPLD
 	tristate "Mellanox I2C driver"
 	depends on X86_64

drivers/i2c/busses/Makefile+1−0

@@ -140,6 +140,7 @@ obj-$(CONFIG_I2C_BCM_KONA) += i2c-bcm-kona.o · 139 unmodified lines
140	obj-$(CONFIG_I2C_BRCMSTB) += i2c-brcmstb.o	140	obj-$(CONFIG_I2C_BRCMSTB) += i2c-brcmstb.o
141	obj-$(CONFIG_I2C_CROS_EC_TUNNEL) += i2c-cros-ec-tunnel.o	141	obj-$(CONFIG_I2C_CROS_EC_TUNNEL) += i2c-cros-ec-tunnel.o
142	obj-$(CONFIG_I2C_ELEKTOR) += i2c-elektor.o	142	obj-$(CONFIG_I2C_ELEKTOR) += i2c-elektor.o
		143	obj-$(CONFIG_I2C_ICY) += i2c-icy.o
143	obj-$(CONFIG_I2C_MLXCPLD) += i2c-mlxcpld.o	144	obj-$(CONFIG_I2C_MLXCPLD) += i2c-mlxcpld.o
144	obj-$(CONFIG_I2C_OPAL) += i2c-opal.o	145	obj-$(CONFIG_I2C_OPAL) += i2c-opal.o
145	obj-$(CONFIG_I2C_PCA_ISA) += i2c-pca-isa.o	146	obj-$(CONFIG_I2C_PCA_ISA) += i2c-pca-isa.o

drivers/i2c/busses/i2c-axxia.c+144−8

@@ -77,6 +77,40 @@ · 76 unmodified lines
77	MST_STATUS_IP)	77	MST_STATUS_IP)
78	#define MST_TX_BYTES_XFRD 0x50	78	#define MST_TX_BYTES_XFRD 0x50
79	#define MST_RX_BYTES_XFRD 0x54	79	#define MST_RX_BYTES_XFRD 0x54
		80	#define SLV_ADDR_DEC_CTL 0x58
		81	#define SLV_ADDR_DEC_GCE BIT(0) /* ACK to General Call Address from own master (loopback) */
		82	#define SLV_ADDR_DEC_OGCE BIT(1) /* ACK to General Call Address from external masters */
		83	#define SLV_ADDR_DEC_SA1E BIT(2) /* ACK to addr_1 enabled */
		84	#define SLV_ADDR_DEC_SA1M BIT(3) /* 10-bit addressing for addr_1 enabled */
		85	#define SLV_ADDR_DEC_SA2E BIT(4) /* ACK to addr_2 enabled */
		86	#define SLV_ADDR_DEC_SA2M BIT(5) /* 10-bit addressing for addr_2 enabled */
		87	#define SLV_ADDR_1 0x5c
		88	#define SLV_ADDR_2 0x60
		89	#define SLV_RX_CTL 0x64
		90	#define SLV_RX_ACSA1 BIT(0) /* Generate ACK for writes to addr_1 */
		91	#define SLV_RX_ACSA2 BIT(1) /* Generate ACK for writes to addr_2 */
		92	#define SLV_RX_ACGCA BIT(2) /* ACK data phase transfers to General Call Address */
		93	#define SLV_DATA 0x68
		94	#define SLV_RX_FIFO 0x6c
		95	#define SLV_FIFO_DV1 BIT(0) /* Data Valid for addr_1 */
		96	#define SLV_FIFO_DV2 BIT(1) /* Data Valid for addr_2 */
		97	#define SLV_FIFO_AS BIT(2) /* (N)ACK Sent */
		98	#define SLV_FIFO_TNAK BIT(3) /* Timeout NACK */
		99	#define SLV_FIFO_STRC BIT(4) /* First byte after start condition received */
		100	#define SLV_FIFO_RSC BIT(5) /* Repeated Start Condition */
		101	#define SLV_FIFO_STPC BIT(6) /* Stop Condition */
		102	#define SLV_FIFO_DV (SLV_FIFO_DV1 \| SLV_FIFO_DV2)
		103	#define SLV_INT_ENABLE 0x70
		104	#define SLV_INT_STATUS 0x74
		105	#define SLV_STATUS_RFH BIT(0) /* FIFO service */
		106	#define SLV_STATUS_WTC BIT(1) /* Write transfer complete */
		107	#define SLV_STATUS_SRS1 BIT(2) /* Slave read from addr 1 */
		108	#define SLV_STATUS_SRRS1 BIT(3) /* Repeated start from addr 1 */
		109	#define SLV_STATUS_SRND1 BIT(4) /* Read request not following start condition */
		110	#define SLV_STATUS_SRC1 BIT(5) /* Read canceled */
		111	#define SLV_STATUS_SRAT1 BIT(6) /* Slave Read timed out */
		112	#define SLV_STATUS_SRDRE1 BIT(7) /* Data written after timed out */
		113	#define SLV_READ_DUMMY 0x78
80	#define SCL_HIGH_PERIOD 0x80	114	#define SCL_HIGH_PERIOD 0x80
81	#define SCL_LOW_PERIOD 0x84	115	#define SCL_LOW_PERIOD 0x84
82	#define SPIKE_FLTR_LEN 0x88	116	#define SPIKE_FLTR_LEN 0x88
@@ -111,6 +145,8 @@ struct axxia_i2c_dev { · 28 unmodified lines
111	struct clk *i2c_clk;	145	struct clk *i2c_clk;
112	u32 bus_clk_rate;	146	u32 bus_clk_rate;
113	bool last;	147	bool last;
		148	struct i2c_client *slave;
		149	int irq;
114	};	150	};
115		151
116	static void i2c_int_disable(struct axxia_i2c_dev *idev, u32 mask)	152	static void i2c_int_disable(struct axxia_i2c_dev *idev, u32 mask)
@@ -276,13 +312,65 @@ static int axxia_i2c_fill_tx_fifo(struct axxia_i2c_dev *idev) · 159 unmodified lines
276	return ret;	312	return ret;
277	}	313	}
278		314
		315	static void axxia_i2c_slv_fifo_event(struct axxia_i2c_dev *idev)
		316	{
		317	u32 fifo_status = readl(idev->base + SLV_RX_FIFO);
		318	u8 val;
		319
		320	dev_dbg(idev->dev, "slave irq fifo_status=0x%x\n", fifo_status);
		321
		322	if (fifo_status & SLV_FIFO_DV1) {
		323	if (fifo_status & SLV_FIFO_STRC)
		324	i2c_slave_event(idev->slave,
		325	I2C_SLAVE_WRITE_REQUESTED, &val);
		326
		327	val = readl(idev->base + SLV_DATA);
		328	i2c_slave_event(idev->slave, I2C_SLAVE_WRITE_RECEIVED, &val);
		329	}
		330	if (fifo_status & SLV_FIFO_STPC) {
		331	readl(idev->base + SLV_DATA); /* dummy read */
		332	i2c_slave_event(idev->slave, I2C_SLAVE_STOP, &val);
		333	}
		334	if (fifo_status & SLV_FIFO_RSC)
		335	readl(idev->base + SLV_DATA); /* dummy read */
		336	}
		337
		338	static irqreturn_t axxia_i2c_slv_isr(struct axxia_i2c_dev *idev)
		339	{
		340	u32 status = readl(idev->base + SLV_INT_STATUS);
		341	u8 val;
		342
		343	dev_dbg(idev->dev, "slave irq status=0x%x\n", status);
		344
		345	if (status & SLV_STATUS_RFH)
		346	axxia_i2c_slv_fifo_event(idev);
		347	if (status & SLV_STATUS_SRS1) {
		348	i2c_slave_event(idev->slave, I2C_SLAVE_READ_REQUESTED, &val);
		349	writel(val, idev->base + SLV_DATA);
		350	}
		351	if (status & SLV_STATUS_SRND1) {
		352	i2c_slave_event(idev->slave, I2C_SLAVE_READ_PROCESSED, &val);
		353	writel(val, idev->base + SLV_DATA);
		354	}
		355	if (status & SLV_STATUS_SRC1)
		356	i2c_slave_event(idev->slave, I2C_SLAVE_STOP, &val);
		357
		358	writel(INT_SLV, idev->base + INTERRUPT_STATUS);
		359	return IRQ_HANDLED;
		360	}
		361
279	static irqreturn_t axxia_i2c_isr(int irq, void *_dev)	362	static irqreturn_t axxia_i2c_isr(int irq, void *_dev)
280	{	363	{
281	struct axxia_i2c_dev *idev = _dev;	364	struct axxia_i2c_dev *idev = _dev;
		365	irqreturn_t ret = IRQ_NONE;
282	u32 status;	366	u32 status;
283		367
284	if (!(readl(idev->base + INTERRUPT_STATUS) & INT_MST))	368	status = readl(idev->base + INTERRUPT_STATUS);
285	return IRQ_NONE;	369
		370	if (status & INT_SLV)
		371	ret = axxia_i2c_slv_isr(idev);
		372	if (!(status & INT_MST))
		373	return ret;
286		374
287	/* Read interrupt status bits */	375	/* Read interrupt status bits */
288	status = readl(idev->base + MST_INT_STATUS);	376	status = readl(idev->base + MST_INT_STATUS);
@@ -583,9 +671,58 @@ static u32 axxia_i2c_func(struct i2c_adapter *adap) · 294 unmodified lines
583	return caps;	671	return caps;
584	}	672	}
585		673
		674	static int axxia_i2c_reg_slave(struct i2c_client *slave)
		675	{
		676	struct axxia_i2c_dev *idev = i2c_get_adapdata(slave->adapter);
		677	u32 slv_int_mask = SLV_STATUS_RFH;
		678	u32 dec_ctl;
		679
		680	if (idev->slave)
		681	return -EBUSY;
		682
		683	idev->slave = slave;
		684
		685	/* Enable slave mode as well */
		686	writel(GLOBAL_MST_EN \| GLOBAL_SLV_EN, idev->base + GLOBAL_CONTROL);
		687	writel(INT_MST \| INT_SLV, idev->base + INTERRUPT_ENABLE);
		688
		689	/* Set slave address */
		690	dec_ctl = SLV_ADDR_DEC_SA1E;
		691	if (slave->flags & I2C_CLIENT_TEN)
		692	dec_ctl \|= SLV_ADDR_DEC_SA1M;
		693
		694	writel(SLV_RX_ACSA1, idev->base + SLV_RX_CTL);
		695	writel(dec_ctl, idev->base + SLV_ADDR_DEC_CTL);
		696	writel(slave->addr, idev->base + SLV_ADDR_1);
		697
		698	/* Enable interrupts */
		699	slv_int_mask \|= SLV_STATUS_SRS1 \| SLV_STATUS_SRRS1 \| SLV_STATUS_SRND1;
		700	slv_int_mask \|= SLV_STATUS_SRC1;
		701	writel(slv_int_mask, idev->base + SLV_INT_ENABLE);
		702
		703	return 0;
		704	}
		705
		706	static int axxia_i2c_unreg_slave(struct i2c_client *slave)
		707	{
		708	struct axxia_i2c_dev *idev = i2c_get_adapdata(slave->adapter);
		709
		710	/* Disable slave mode */
		711	writel(GLOBAL_MST_EN, idev->base + GLOBAL_CONTROL);
		712	writel(INT_MST, idev->base + INTERRUPT_ENABLE);
		713
		714	synchronize_irq(idev->irq);
		715
		716	idev->slave = NULL;
		717
		718	return 0;
		719	}
		720
586	static const struct i2c_algorithm axxia_i2c_algo = {	721	static const struct i2c_algorithm axxia_i2c_algo = {
587	.master_xfer = axxia_i2c_xfer,	722	.master_xfer = axxia_i2c_xfer,
588	.functionality = axxia_i2c_func,	723	.functionality = axxia_i2c_func,
		724	.reg_slave = axxia_i2c_reg_slave,
		725	.unreg_slave = axxia_i2c_unreg_slave,
589	};	726	};
590		727
591	static const struct i2c_adapter_quirks axxia_i2c_quirks = {	728	static const struct i2c_adapter_quirks axxia_i2c_quirks = {
@@ -599,7 +736,6 @@ static int axxia_i2c_probe(struct platform_device *pdev) · 7 unmodified lines
599	struct axxia_i2c_dev *idev = NULL;	736	struct axxia_i2c_dev *idev = NULL;
600	struct resource *res;	737	struct resource *res;
601	void __iomem *base;	738	void __iomem *base;
602	int irq;
603	int ret = 0;	739	int ret = 0;
604		740
605	idev = devm_kzalloc(&pdev->dev, sizeof(*idev), GFP_KERNEL);	741	idev = devm_kzalloc(&pdev->dev, sizeof(*idev), GFP_KERNEL);
@@ -611,10 +747,10 @@ static int axxia_i2c_probe(struct platform_device *pdev) · 5 unmodified lines
611	if (IS_ERR(base))	747	if (IS_ERR(base))
612	return PTR_ERR(base);	748	return PTR_ERR(base);
613		749
614	irq = platform_get_irq(pdev, 0);	750	idev->irq = platform_get_irq(pdev, 0);
615	if (irq < 0) {	751	if (idev->irq < 0) {
616	dev_err(&pdev->dev, "missing interrupt resource\n");	752	dev_err(&pdev->dev, "missing interrupt resource\n");
617	return irq;	753	return idev->irq;
618	}	754	}
619		755
620	idev->i2c_clk = devm_clk_get(&pdev->dev, "i2c");	756	idev->i2c_clk = devm_clk_get(&pdev->dev, "i2c");
@@ -643,10 +779,10 @@ static int axxia_i2c_probe(struct platform_device *pdev) · 22 unmodified lines
643	goto error_disable_clk;	779	goto error_disable_clk;
644	}	780	}
645		781
646	ret = devm_request_irq(&pdev->dev, irq, axxia_i2c_isr, 0,	782	ret = devm_request_irq(&pdev->dev, idev->irq, axxia_i2c_isr, 0,
647	pdev->name, idev);	783	pdev->name, idev);
648	if (ret) {	784	if (ret) {
649	dev_err(&pdev->dev, "failed to claim IRQ%d\n", irq);	785	dev_err(&pdev->dev, "failed to claim IRQ%d\n", idev->irq);
650	goto error_disable_clk;	786	goto error_disable_clk;
651	}	787	}
652		788

drivers/i2c/busses/i2c-bcm-iproc.c+4−2

 	.unreg_slave = bcm_iproc_i2c_unreg_slave,
 };
-static struct i2c_adapter_quirks bcm_iproc_i2c_quirks = {
+static const struct i2c_adapter_quirks bcm_iproc_i2c_quirks = {
 	.max_read_len = M_RX_MAX_READ_LEN,
 };
 	adap = &iproc_i2c->adapter;
 	i2c_set_adapdata(adap, iproc_i2c);
-	strlcpy(adap->name, "Broadcom iProc I2C adapter", sizeof(adap->name));
+	snprintf(adap->name, sizeof(adap->name),
+		"Broadcom iProc (%s)",
+		of_node_full_name(iproc_i2c->device->of_node));
 	adap->algo = &bcm_iproc_algo;
 	adap->quirks = &bcm_iproc_i2c_quirks;
 	adap->dev.parent = &pdev->dev;

drivers/i2c/busses/i2c-bcm2835.c+7−4

 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/module.h>
+#include <linux/of_device.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 };
 /*
- * This HW was reported to have problems with clock stretching:
+ * The BCM2835 was reported to have problems with clock stretching:
  * http://www.advamation.com/knowhow/raspberrypi/rpi-i2c-bug.html
  * https://www.raspberrypi.org/forums/viewtopic.php?p=146272
  */
 	i2c_set_adapdata(adap, i2c_dev);
 	adap->owner = THIS_MODULE;
 	adap->class = I2C_CLASS_DEPRECATED;
-	strlcpy(adap->name, "bcm2835 I2C adapter", sizeof(adap->name));
+	snprintf(adap->name, sizeof(adap->name), "bcm2835 (%s)",
+		 of_node_full_name(pdev->dev.of_node));
 	adap->algo = &bcm2835_i2c_algo;
 	adap->dev.parent = &pdev->dev;
 	adap->dev.of_node = pdev->dev.of_node;
-	adap->quirks = &bcm2835_i2c_quirks;
+	adap->quirks = of_device_get_match_data(&pdev->dev);
 	bcm2835_i2c_writel(i2c_dev, BCM2835_I2C_C, 0);
 }
 static const struct of_device_id bcm2835_i2c_of_match[] = {
-	{ .compatible = "brcm,bcm2835-i2c" },
+	{ .compatible = "brcm,bcm2711-i2c" },
+	{ .compatible = "brcm,bcm2835-i2c", .data = &bcm2835_i2c_quirks },
 	{},
 };
 MODULE_DEVICE_TABLE(of, bcm2835_i2c_of_match);

drivers/i2c/busses/i2c-cht-wc.c+47−2

@@ -178,6 +178,51 @@ static const struct i2c_algorithm cht_wc_i2c_adap_algo = { · 177 unmodified lines
178	.smbus_xfer = cht_wc_i2c_adap_smbus_xfer,	178	.smbus_xfer = cht_wc_i2c_adap_smbus_xfer,
179	};	179	};
180		180
		181	/*
		182	* We are an i2c-adapter which itself is part of an i2c-client. This means that
		183	* transfers done through us take adapter->bus_lock twice, once for our parent
		184	* i2c-adapter and once to take our own bus_lock. Lockdep does not like this
		185	* nested locking, to make lockdep happy in the case of busses with muxes, the
		186	* i2c-core's i2c_adapter_lock_bus function calls:
		187	* rt_mutex_lock_nested(&adapter->bus_lock, i2c_adapter_depth(adapter));
		188	*
		189	* But i2c_adapter_depth only works when the direct parent of the adapter is
		190	* another adapter, as it is only meant for muxes. In our case there is an
		191	* i2c-client and MFD instantiated platform_device in the parent->child chain
		192	* between the 2 devices.
		193	*
		194	* So we override the default i2c_lock_operations and pass a hardcoded
		195	* depth of 1 to rt_mutex_lock_nested, to make lockdep happy.
		196	*
		197	* Note that if there were to be a mux attached to our adapter, this would
		198	* break things again since the i2c-mux code expects the root-adapter to have
		199	* a locking depth of 0. But we always have only 1 client directly attached
		200	* in the form of the Charger IC paired with the CHT Whiskey Cove PMIC.
		201	*/
		202	static void cht_wc_i2c_adap_lock_bus(struct i2c_adapter *adapter,
		203	unsigned int flags)
		204	{
		205	rt_mutex_lock_nested(&adapter->bus_lock, 1);
		206	}
		207
		208	static int cht_wc_i2c_adap_trylock_bus(struct i2c_adapter *adapter,
		209	unsigned int flags)
		210	{
		211	return rt_mutex_trylock(&adapter->bus_lock);
		212	}
		213
		214	static void cht_wc_i2c_adap_unlock_bus(struct i2c_adapter *adapter,
		215	unsigned int flags)
		216	{
		217	rt_mutex_unlock(&adapter->bus_lock);
		218	}
		219
		220	static const struct i2c_lock_operations cht_wc_i2c_adap_lock_ops = {
		221	.lock_bus = cht_wc_i2c_adap_lock_bus,
		222	.trylock_bus = cht_wc_i2c_adap_trylock_bus,
		223	.unlock_bus = cht_wc_i2c_adap_unlock_bus,
		224	};
		225
181	/** irqchip for the client connected to the extchgr i2c adapter **/	226	/** irqchip for the client connected to the extchgr i2c adapter **/
182	static void cht_wc_i2c_irq_lock(struct irq_data *data)	227	static void cht_wc_i2c_irq_lock(struct irq_data *data)
183	{	228	{
@@ -286,6 +331,7 @@ static int cht_wc_i2c_adap_i2c_probe(struct platform_device *pdev) · 102 unmodified lines
286	adap->adapter.owner = THIS_MODULE;	331	adap->adapter.owner = THIS_MODULE;
287	adap->adapter.class = I2C_CLASS_HWMON;	332	adap->adapter.class = I2C_CLASS_HWMON;
288	adap->adapter.algo = &cht_wc_i2c_adap_algo;	333	adap->adapter.algo = &cht_wc_i2c_adap_algo;
		334	adap->adapter.lock_ops = &cht_wc_i2c_adap_lock_ops;
289	strlcpy(adap->adapter.name, "PMIC I2C Adapter",	335	strlcpy(adap->adapter.name, "PMIC I2C Adapter",
290	sizeof(adap->adapter.name));	336	sizeof(adap->adapter.name));
291	adap->adapter.dev.parent = &pdev->dev;	337	adap->adapter.dev.parent = &pdev->dev;
@@ -363,8 +409,7 @@ static int cht_wc_i2c_adap_i2c_remove(struct platform_device *pdev) · 71 unmodified lines
363	{	409	{
364	struct cht_wc_i2c_adap *adap = platform_get_drvdata(pdev);	410	struct cht_wc_i2c_adap *adap = platform_get_drvdata(pdev);
365		411
366	if (adap->client)	412	i2c_unregister_device(adap->client);
367	i2c_unregister_device(adap->client);
368	i2c_del_adapter(&adap->adapter);	413	i2c_del_adapter(&adap->adapter);
369	irq_domain_remove(adap->irq_domain);	414	irq_domain_remove(adap->irq_domain);
370		415

drivers/i2c/busses/i2c-designware-master.c+5−9

@@ -655,15 +655,11 @@ static int i2c_dw_init_recovery_info(struct dw_i2c_dev *dev) · 654 unmodified lines
655	struct i2c_bus_recovery_info *rinfo = &dev->rinfo;	655	struct i2c_bus_recovery_info *rinfo = &dev->rinfo;
656	struct i2c_adapter *adap = &dev->adapter;	656	struct i2c_adapter *adap = &dev->adapter;
657	struct gpio_desc *gpio;	657	struct gpio_desc *gpio;
658	int r;	658
659		659	gpio = devm_gpiod_get_optional(dev->dev, "scl", GPIOD_OUT_HIGH);
660	gpio = devm_gpiod_get(dev->dev, "scl", GPIOD_OUT_HIGH);	660	if (IS_ERR_OR_NULL(gpio))
661	if (IS_ERR(gpio)) {	661	return PTR_ERR_OR_ZERO(gpio);
662	r = PTR_ERR(gpio);	662
663	if (r == -ENOENT \|\| r == -ENOSYS)
664	return 0;
665	return r;
666	}
667	rinfo->scl_gpiod = gpio;	663	rinfo->scl_gpiod = gpio;
668		664
669	gpio = devm_gpiod_get_optional(dev->dev, "sda", GPIOD_IN);	665	gpio = devm_gpiod_get_optional(dev->dev, "sda", GPIOD_IN);

drivers/i2c/busses/i2c-designware-pcidrv.c+34−7

 	baytrail,
 	cherrytrail,
 	haswell,
+	elkhartlake,
 };
 struct dw_scl_sda_cfg {
 		.flags = MODEL_CHERRYTRAIL,
 		.scl_sda_cfg = &byt_config,
 	},
+	[elkhartlake] = {
+		.bus_num = -1,
+		.bus_cfg = INTEL_MID_STD_CFG | DW_IC_CON_SPEED_FAST,
+		.tx_fifo_depth = 32,
+		.rx_fifo_depth = 32,
+		.functionality = I2C_FUNC_10BIT_ADDR,
+		.clk_khz = 100000,
+	},
 };
 #ifdef CONFIG_PM
 static int i2c_dw_pci_suspend(struct device *dev)
 {
-	struct pci_dev *pdev = to_pci_dev(dev);
+	struct dw_i2c_dev *i_dev = dev_get_drvdata(dev);
-	struct dw_i2c_dev *i_dev = pci_get_drvdata(pdev);
 	i_dev->suspended = true;
 	i_dev->disable(i_dev);
 static int i2c_dw_pci_resume(struct device *dev)
 {
-	struct pci_dev *pdev = to_pci_dev(dev);
+	struct dw_i2c_dev *i_dev = dev_get_drvdata(dev);
-	struct dw_i2c_dev *i_dev = pci_get_drvdata(pdev);
 	int ret;
 	ret = i_dev->init(i_dev);
 		return r;
 	}
+	pci_set_master(pdev);
 	r = pcim_iomap_regions(pdev, 1 << 0, pci_name(pdev));
 	if (r) {
 		dev_err(&pdev->dev, "I/O memory remapping failed\n");
 	if (!dev)
 		return -ENOMEM;
+	r = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES);
+	if (r < 0)
+		return r;
 	dev->clk = NULL;
 	dev->controller = controller;
 	dev->get_clk_rate_khz = i2c_dw_get_clk_rate_khz;
 	dev->base = pcim_iomap_table(pdev)[0];
 	dev->dev = &pdev->dev;
-	dev->irq = pdev->irq;
+	dev->irq = pci_irq_vector(pdev, 0);
 	dev->flags |= controller->flags;
 	if (controller->setup) {
 		r = controller->setup(pdev, controller);
-		if (r)
+		if (r) {
+			pci_free_irq_vectors(pdev);
 			return r;
+		}
 	}
 	dev->functionality = controller->functionality |
 	adap->nr = controller->bus_num;
 	r = i2c_dw_probe(dev);
-	if (r)
+	if (r) {
+		pci_free_irq_vectors(pdev);
 		return r;
+	}
 	pm_runtime_set_autosuspend_delay(&pdev->dev, 1000);
 	pm_runtime_use_autosuspend(&pdev->dev);
 	pm_runtime_get_noresume(&pdev->dev);
 	i2c_del_adapter(&dev->adapter);
+	pci_free_irq_vectors(pdev);
 }
 /* work with hotplug and coldplug */
 	{ PCI_VDEVICE(INTEL, 0x22C5), cherrytrail },
 	{ PCI_VDEVICE(INTEL, 0x22C6), cherrytrail },
 	{ PCI_VDEVICE(INTEL, 0x22C7), cherrytrail },
+	/* Elkhart Lake (PSE I2C) */
+	{ PCI_VDEVICE(INTEL, 0x4bb9), elkhartlake },
+	{ PCI_VDEVICE(INTEL, 0x4bba), elkhartlake },
+	{ PCI_VDEVICE(INTEL, 0x4bbb), elkhartlake },
+	{ PCI_VDEVICE(INTEL, 0x4bbc), elkhartlake },
+	{ PCI_VDEVICE(INTEL, 0x4bbd), elkhartlake },
+	{ PCI_VDEVICE(INTEL, 0x4bbe), elkhartlake },
+	{ PCI_VDEVICE(INTEL, 0x4bbf), elkhartlake },
+	{ PCI_VDEVICE(INTEL, 0x4bc0), elkhartlake },
 	{ 0,}
 };
 MODULE_DEVICE_TABLE(pci, i2_designware_pci_ids);

drivers/i2c/busses/i2c-designware-platdrv.c+10−12

@@ -279,12 +279,10 @@ static int dw_i2c_plat_probe(struct platform_device *pdev) · 278 unmodified lines
279	platform_set_drvdata(pdev, dev);	279	platform_set_drvdata(pdev, dev);
280		280
281	dev->rst = devm_reset_control_get_optional_exclusive(&pdev->dev, NULL);	281	dev->rst = devm_reset_control_get_optional_exclusive(&pdev->dev, NULL);
282	if (IS_ERR(dev->rst)) {	282	if (IS_ERR(dev->rst))
283	if (PTR_ERR(dev->rst) == -EPROBE_DEFER)	283	return PTR_ERR(dev->rst);
284	return -EPROBE_DEFER;	284
285	} else {	285	reset_control_deassert(dev->rst);
286	reset_control_deassert(dev->rst);
287	}
288		286
289	t = &dev->timings;	287	t = &dev->timings;
290	if (pdata)	288	if (pdata)
@@ -346,8 +344,10 @@ static int dw_i2c_plat_probe(struct platform_device *pdev) · 55 unmodified lines
346		344
347	/* Optional interface clock */	345	/* Optional interface clock */
348	dev->pclk = devm_clk_get_optional(&pdev->dev, "pclk");	346	dev->pclk = devm_clk_get_optional(&pdev->dev, "pclk");
349	if (IS_ERR(dev->pclk))	347	if (IS_ERR(dev->pclk)) {
350	return PTR_ERR(dev->pclk);	348	ret = PTR_ERR(dev->pclk);
		349	goto exit_reset;
		350	}
351		351
352	dev->clk = devm_clk_get(&pdev->dev, NULL);	352	dev->clk = devm_clk_get(&pdev->dev, NULL);
353	if (!i2c_dw_prepare_clk(dev, true)) {	353	if (!i2c_dw_prepare_clk(dev, true)) {
@@ -400,8 +400,7 @@ static int dw_i2c_plat_probe(struct platform_device *pdev) · 46 unmodified lines
400	exit_probe:	400	exit_probe:
401	dw_i2c_plat_pm_cleanup(dev);	401	dw_i2c_plat_pm_cleanup(dev);
402	exit_reset:	402	exit_reset:
403	if (!IS_ERR_OR_NULL(dev->rst))	403	reset_control_assert(dev->rst);
404	reset_control_assert(dev->rst);
405	return ret;	404	return ret;
406	}	405	}
407		406
@@ -419,8 +418,7 @@ static int dw_i2c_plat_remove(struct platform_device *pdev) · 11 unmodified lines
419	pm_runtime_put_sync(&pdev->dev);	418	pm_runtime_put_sync(&pdev->dev);
420	dw_i2c_plat_pm_cleanup(dev);	419	dw_i2c_plat_pm_cleanup(dev);
421		420
422	if (!IS_ERR_OR_NULL(dev->rst))	421	reset_control_assert(dev->rst);
423	reset_control_assert(dev->rst);
424		422
425	return 0;	423	return 0;
426	}	424	}

drivers/i2c/busses/i2c-exynos5.c+1−3

@@ -791,9 +791,7 @@ static int exynos5_i2c_probe(struct platform_device *pdev) · 790 unmodified lines
791	}	791	}
792		792
793	ret = devm_request_irq(&pdev->dev, i2c->irq, exynos5_i2c_irq,	793	ret = devm_request_irq(&pdev->dev, i2c->irq, exynos5_i2c_irq,
794	IRQF_NO_SUSPEND \| IRQF_ONESHOT,	794	IRQF_NO_SUSPEND, dev_name(&pdev->dev), i2c);
795	dev_name(&pdev->dev), i2c);
796
797	if (ret != 0) {	795	if (ret != 0) {
798	dev_err(&pdev->dev, "cannot request HS-I2C IRQ %d\n", i2c->irq);	796	dev_err(&pdev->dev, "cannot request HS-I2C IRQ %d\n", i2c->irq);
799	goto err_clk;	797	goto err_clk;

drivers/i2c/busses/i2c-fsi.c+3−1

 			continue;
 		port = kzalloc(sizeof(*port), GFP_KERNEL);
-		if (!port)
+		if (!port) {
+			of_node_put(np);
 			break;
+		}
 		port->master = i2c;
 		port->port = port_no;

drivers/i2c/busses/i2c-hix5hd2.c+1−2

@@ -445,8 +445,7 @@ static int hix5hd2_i2c_probe(struct platform_device *pdev) · 444 unmodified lines
445	hix5hd2_i2c_init(priv);	445	hix5hd2_i2c_init(priv);
446		446
447	ret = devm_request_irq(&pdev->dev, irq, hix5hd2_i2c_irq,	447	ret = devm_request_irq(&pdev->dev, irq, hix5hd2_i2c_irq,
448	IRQF_NO_SUSPEND \| IRQF_ONESHOT,	448	IRQF_NO_SUSPEND, dev_name(&pdev->dev), priv);
449	dev_name(&pdev->dev), priv);
450	if (ret != 0) {	449	if (ret != 0) {
451	dev_err(&pdev->dev, "cannot request HS-I2C IRQ %d\n", irq);	450	dev_err(&pdev->dev, "cannot request HS-I2C IRQ %d\n", irq);
452	goto err_clk;	451	goto err_clk;

drivers/i2c/busses/i2c-i801.c+89−56

@@ -292,7 +292,8 @@ struct i801_priv { · 291 unmodified lines
292	#define FEATURE_HOST_NOTIFY BIT(5)	292	#define FEATURE_HOST_NOTIFY BIT(5)
293	/* Not really a feature, but it's convenient to handle it as such */	293	/* Not really a feature, but it's convenient to handle it as such */
294	#define FEATURE_IDF BIT(15)	294	#define FEATURE_IDF BIT(15)
295	#define FEATURE_TCO BIT(16)	295	#define FEATURE_TCO_SPT BIT(16)
		296	#define FEATURE_TCO_CNL BIT(17)
296		297
297	static const char *i801_feature_names[] = {	298	static const char *i801_feature_names[] = {
298	"SMBus PEC",	299	"SMBus PEC",
@@ -1500,57 +1501,23 @@ static inline unsigned int i801_get_adapter_class(struct i801_priv *priv) · 1201 unmodified lines
1500	}	1501	}
1501	#endif	1502	#endif
1502		1503
1503	static const struct itco_wdt_platform_data tco_platform_data = {	1504	static const struct itco_wdt_platform_data spt_tco_platform_data = {
1504	.name = "Intel PCH",	1505	.name = "Intel PCH",
1505	.version = 4,	1506	.version = 4,
1506	};	1507	};
1507		1508
1508	static DEFINE_SPINLOCK(p2sb_spinlock);	1509	static DEFINE_SPINLOCK(p2sb_spinlock);
1509		1510
1510	static void i801_add_tco(struct i801_priv *priv)	1511	static struct platform_device *
		1512	i801_add_tco_spt(struct i801_priv priv, struct pci_dev pci_dev,
		1513	struct resource *tco_res)
1511	{	1514	{
1512	struct pci_dev *pci_dev = priv->pci_dev;	1515	struct resource *res;
1513	struct resource tco_res[3], *res;
1514	struct platform_device *pdev;
1515	unsigned int devfn;	1516	unsigned int devfn;
1516	u32 tco_base, tco_ctl;
1517	u32 base_addr, ctrl_val;
1518	u64 base64_addr;	1517	u64 base64_addr;
		1518	u32 base_addr;
1519	u8 hidden;	1519	u8 hidden;
1520		1520
1521	if (!(priv->features & FEATURE_TCO))
1522	return;
1523
1524	pci_read_config_dword(pci_dev, TCOBASE, &tco_base);
1525	pci_read_config_dword(pci_dev, TCOCTL, &tco_ctl);
1526	if (!(tco_ctl & TCOCTL_EN))
1527	return;
1528
1529	memset(tco_res, 0, sizeof(tco_res));
1530
1531	res = &tco_res[ICH_RES_IO_TCO];
1532	res->start = tco_base & ~1;
1533	res->end = res->start + 32 - 1;
1534	res->flags = IORESOURCE_IO;
1535
1536	/*
1537	* Power Management registers.
1538	*/
1539	devfn = PCI_DEVFN(PCI_SLOT(pci_dev->devfn), 2);
1540	pci_bus_read_config_dword(pci_dev->bus, devfn, ACPIBASE, &base_addr);
1541
1542	res = &tco_res[ICH_RES_IO_SMI];
1543	res->start = (base_addr & ~1) + ACPIBASE_SMI_OFF;
1544	res->end = res->start + 3;
1545	res->flags = IORESOURCE_IO;
1546
1547	/*
1548	* Enable the ACPI I/O space.
1549	*/
1550	pci_bus_read_config_dword(pci_dev->bus, devfn, ACPICTRL, &ctrl_val);
1551	ctrl_val \|= ACPICTRL_EN;
1552	pci_bus_write_config_dword(pci_dev->bus, devfn, ACPICTRL, ctrl_val);
1553
1554	/*	1521	/*
1555	* We must access the NO_REBOOT bit over the Primary to Sideband	1522	* We must access the NO_REBOOT bit over the Primary to Sideband
1556	* bridge (P2SB). The BIOS prevents the P2SB device from being	1523	* bridge (P2SB). The BIOS prevents the P2SB device from being
@@ -1586,15 +1553,76 @@ static void i801_add_tco(struct i801_priv *priv) · 29 unmodified lines
1586	res->end = res->start + 3;	1553	res->end = res->start + 3;
1587	res->flags = IORESOURCE_MEM;	1554	res->flags = IORESOURCE_MEM;
1588		1555
1589	pdev = platform_device_register_resndata(&pci_dev->dev, "iTCO_wdt", -1,	1556	return platform_device_register_resndata(&pci_dev->dev, "iTCO_wdt", -1,
1590	tco_res, 3, &tco_platform_data,	1557	tco_res, 3, &spt_tco_platform_data,
1591	sizeof(tco_platform_data));	1558	sizeof(spt_tco_platform_data));
1592	if (IS_ERR(pdev)) {	1559	}
1593	dev_warn(&pci_dev->dev, "failed to create iTCO device\n");	1560
		1561	static const struct itco_wdt_platform_data cnl_tco_platform_data = {
		1562	.name = "Intel PCH",
		1563	.version = 6,
		1564	};
		1565
		1566	static struct platform_device *
		1567	i801_add_tco_cnl(struct i801_priv priv, struct pci_dev pci_dev,
		1568	struct resource *tco_res)
		1569	{
		1570	return platform_device_register_resndata(&pci_dev->dev, "iTCO_wdt", -1,
		1571	tco_res, 2, &cnl_tco_platform_data,
		1572	sizeof(cnl_tco_platform_data));
		1573	}
		1574
		1575	static void i801_add_tco(struct i801_priv *priv)
		1576	{
		1577	u32 base_addr, tco_base, tco_ctl, ctrl_val;
		1578	struct pci_dev *pci_dev = priv->pci_dev;
		1579	struct resource tco_res[3], *res;
		1580	unsigned int devfn;
		1581
		1582	/* If we have ACPI based watchdog use that instead */
		1583	if (acpi_has_watchdog())
1594	return;	1584	return;
1595	}
1596		1585
1597	priv->tco_pdev = pdev;	1586	if (!(priv->features & (FEATURE_TCO_SPT \| FEATURE_TCO_CNL)))
		1587	return;
		1588
		1589	pci_read_config_dword(pci_dev, TCOBASE, &tco_base);
		1590	pci_read_config_dword(pci_dev, TCOCTL, &tco_ctl);
		1591	if (!(tco_ctl & TCOCTL_EN))
		1592	return;
		1593
		1594	memset(tco_res, 0, sizeof(tco_res));
		1595
		1596	res = &tco_res[ICH_RES_IO_TCO];
		1597	res->start = tco_base & ~1;
		1598	res->end = res->start + 32 - 1;
		1599	res->flags = IORESOURCE_IO;
		1600
		1601	/*
		1602	* Power Management registers.
		1603	*/
		1604	devfn = PCI_DEVFN(PCI_SLOT(pci_dev->devfn), 2);
		1605	pci_bus_read_config_dword(pci_dev->bus, devfn, ACPIBASE, &base_addr);
		1606
		1607	res = &tco_res[ICH_RES_IO_SMI];
		1608	res->start = (base_addr & ~1) + ACPIBASE_SMI_OFF;
		1609	res->end = res->start + 3;
		1610	res->flags = IORESOURCE_IO;
		1611
		1612	/*
		1613	* Enable the ACPI I/O space.
		1614	*/
		1615	pci_bus_read_config_dword(pci_dev->bus, devfn, ACPICTRL, &ctrl_val);
		1616	ctrl_val \|= ACPICTRL_EN;
		1617	pci_bus_write_config_dword(pci_dev->bus, devfn, ACPICTRL, ctrl_val);
		1618
		1619	if (priv->features & FEATURE_TCO_CNL)
		1620	priv->tco_pdev = i801_add_tco_cnl(priv, pci_dev, tco_res);
		1621	else
		1622	priv->tco_pdev = i801_add_tco_spt(priv, pci_dev, tco_res);
		1623
		1624	if (IS_ERR(priv->tco_pdev))
		1625	dev_warn(&pci_dev->dev, "failed to create iTCO device\n");
1598	}	1626	}
1599		1627
1600	#ifdef CONFIG_ACPI	1628	#ifdef CONFIG_ACPI
@@ -1704,13 +1732,21 @@ static int i801_probe(struct pci_dev dev, const struct pci_device_id id) · 103 unmodified lines
1704	switch (dev->device) {	1732	switch (dev->device) {
1705	case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_SMBUS:	1733	case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_SMBUS:
1706	case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_SMBUS:	1734	case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_SMBUS:
1707	case PCI_DEVICE_ID_INTEL_CANNONLAKE_H_SMBUS:
1708	case PCI_DEVICE_ID_INTEL_CANNONLAKE_LP_SMBUS:
1709	case PCI_DEVICE_ID_INTEL_LEWISBURG_SMBUS:	1735	case PCI_DEVICE_ID_INTEL_LEWISBURG_SMBUS:
1710	case PCI_DEVICE_ID_INTEL_LEWISBURG_SSKU_SMBUS:	1736	case PCI_DEVICE_ID_INTEL_LEWISBURG_SSKU_SMBUS:
1711	case PCI_DEVICE_ID_INTEL_CDF_SMBUS:
1712	case PCI_DEVICE_ID_INTEL_DNV_SMBUS:	1737	case PCI_DEVICE_ID_INTEL_DNV_SMBUS:
1713	case PCI_DEVICE_ID_INTEL_KABYLAKE_PCH_H_SMBUS:	1738	case PCI_DEVICE_ID_INTEL_KABYLAKE_PCH_H_SMBUS:
		1739	priv->features \|= FEATURE_I2C_BLOCK_READ;
		1740	priv->features \|= FEATURE_IRQ;
		1741	priv->features \|= FEATURE_SMBUS_PEC;
		1742	priv->features \|= FEATURE_BLOCK_BUFFER;
		1743	priv->features \|= FEATURE_TCO_SPT;
		1744	priv->features \|= FEATURE_HOST_NOTIFY;
		1745	break;
		1746
		1747	case PCI_DEVICE_ID_INTEL_CANNONLAKE_H_SMBUS:
		1748	case PCI_DEVICE_ID_INTEL_CANNONLAKE_LP_SMBUS:
		1749	case PCI_DEVICE_ID_INTEL_CDF_SMBUS:
1714	case PCI_DEVICE_ID_INTEL_ICELAKE_LP_SMBUS:	1750	case PCI_DEVICE_ID_INTEL_ICELAKE_LP_SMBUS:
1715	case PCI_DEVICE_ID_INTEL_COMETLAKE_SMBUS:	1751	case PCI_DEVICE_ID_INTEL_COMETLAKE_SMBUS:
1716	case PCI_DEVICE_ID_INTEL_ELKHART_LAKE_SMBUS:	1752	case PCI_DEVICE_ID_INTEL_ELKHART_LAKE_SMBUS:
@@ -1720,9 +1756,7 @@ static int i801_probe(struct pci_dev dev, const struct pci_device_id id) · 3 unmodified lines
1720	priv->features \|= FEATURE_IRQ;	1756	priv->features \|= FEATURE_IRQ;
1721	priv->features \|= FEATURE_SMBUS_PEC;	1757	priv->features \|= FEATURE_SMBUS_PEC;
1722	priv->features \|= FEATURE_BLOCK_BUFFER;	1758	priv->features \|= FEATURE_BLOCK_BUFFER;
1723	/* If we have ACPI based watchdog use that instead */	1759	priv->features \|= FEATURE_TCO_CNL;
1724	if (!acpi_has_watchdog())
1725	priv->features \|= FEATURE_TCO;
1726	priv->features \|= FEATURE_HOST_NOTIFY;	1760	priv->features \|= FEATURE_HOST_NOTIFY;
1727	break;	1761	break;
1728		1762
@@ -1921,8 +1955,7 @@ static int i801_suspend(struct device *dev) · 192 unmodified lines
1921		1955
1922	static int i801_resume(struct device *dev)	1956	static int i801_resume(struct device *dev)
1923	{	1957	{
1924	struct pci_dev *pci_dev = to_pci_dev(dev);	1958	struct i801_priv *priv = dev_get_drvdata(dev);
1925	struct i801_priv *priv = pci_get_drvdata(pci_dev);
1926		1959
1927	i801_enable_host_notify(&priv->adapter);	1960	i801_enable_host_notify(&priv->adapter);
1928		1961

drivers/i2c/busses/i2c-icy.c+230−0

@@ -0,0 +1,230 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* I2C driver for stand-alone PCF8584 style adapters on Zorro cards
	4	*
	5	* Original ICY documentation can be found on Aminet:
	6	* https://aminet.net/package/docs/hard/icy
	7	*
	8	* There has been a modern community re-print of this design in 2019:
	9	* https://www.a1k.org/forum/index.php?threads/70106/
	10	*
	11	* The card is basically a Philips PCF8584 connected straight to the
	12	* beginning of the AutoConfig'd address space (register S1 on base+2),
	13	* with /INT on /INT2 on the Zorro bus.
	14	*
	15	* Copyright (c) 2019 Max Staudt <max@enpas.org>
	16	*
	17	* This started as a fork of i2c-elektor.c and has evolved since.
	18	* Thanks go to its authors for providing a base to grow on.
	19	*
	20	*
	21	* IRQ support is currently not implemented.
	22	*
	23	* As it turns out, i2c-algo-pcf is really written with i2c-elektor's
	24	* edge-triggered ISA interrupts in mind, while the Amiga's Zorro bus has
	25	* level-triggered interrupts. This means that once an interrupt occurs, we
	26	* have to tell the PCF8584 to shut up immediately, or it will keep the
	27	* interrupt line busy and cause an IRQ storm.
	28
	29	* However, because of the PCF8584's host-side protocol, there is no good
	30	* way to just quieten it without side effects. Rather, we have to perform
	31	* the next read/write operation straight away, which will reset the /INT
	32	* pin. This entails re-designing the core of i2c-algo-pcf in the future.
	33	* For now, we never request an IRQ from the PCF8584, and poll it instead.
	34	*/
	35
	36	#include <linux/delay.h>
	37	#include <linux/init.h>
	38	#include <linux/io.h>
	39	#include <linux/ioport.h>
	40	#include <linux/kernel.h>
	41	#include <linux/module.h>
	42
	43	#include <linux/i2c.h>
	44	#include <linux/i2c-algo-pcf.h>
	45
	46	#include <asm/amigaints.h>
	47	#include <linux/zorro.h>
	48
	49	#include "../algos/i2c-algo-pcf.h"
	50
	51	struct icy_i2c {
	52	struct i2c_adapter adapter;
	53
	54	void __iomem *reg_s0;
	55	void __iomem *reg_s1;
	56	struct fwnode_handle *ltc2990_fwnode;
	57	struct i2c_client *ltc2990_client;
	58	};
	59
	60	/*
	61	* Functions called by i2c-algo-pcf
	62	*/
	63	static void icy_pcf_setpcf(void *data, int ctl, int val)
	64	{
	65	struct icy_i2c i2c = (struct icy_i2c )data;
	66
	67	u8 __iomem *address = ctl ? i2c->reg_s1 : i2c->reg_s0;
	68
	69	z_writeb(val, address);
	70	}
	71
	72	static int icy_pcf_getpcf(void *data, int ctl)
	73	{
	74	struct icy_i2c i2c = (struct icy_i2c )data;
	75
	76	u8 __iomem *address = ctl ? i2c->reg_s1 : i2c->reg_s0;
	77
	78	return z_readb(address);
	79	}
	80
	81	static int icy_pcf_getown(void *data)
	82	{
	83	return 0x55;
	84	}
	85
	86	static int icy_pcf_getclock(void *data)
	87	{
	88	return 0x1c;
	89	}
	90
	91	static void icy_pcf_waitforpin(void *data)
	92	{
	93	usleep_range(50, 150);
	94	}
	95
	96	/*
	97	* Main i2c-icy part
	98	*/
	99	static unsigned short const icy_ltc2990_addresses[] = {
	100	0x4c, 0x4d, 0x4e, 0x4f, I2C_CLIENT_END
	101	};
	102
	103	/*
	104	* Additional sensors exposed once this property is applied:
	105	*
	106	* in1 will be the voltage of the 5V rail, divided by 2.
	107	* in2 will be the voltage of the 12V rail, divided by 4.
	108	* temp3 will be measured using a PCB loop next the chip.
	109	*/
	110	static const u32 icy_ltc2990_meas_mode[] = {0, 3};
	111
	112	static const struct property_entry icy_ltc2990_props[] = {
	113	PROPERTY_ENTRY_U32_ARRAY("lltc,meas-mode", icy_ltc2990_meas_mode),
	114	{ }
	115	};
	116
	117	static int icy_probe(struct zorro_dev *z,
	118	const struct zorro_device_id *ent)
	119	{
	120	struct icy_i2c *i2c;
	121	struct i2c_algo_pcf_data *algo_data;
	122	struct fwnode_handle *new_fwnode;
	123	struct i2c_board_info ltc2990_info = {
	124	.type = "ltc2990",
	125	.addr = 0x4c,
	126	};
	127
	128	i2c = devm_kzalloc(&z->dev, sizeof(*i2c), GFP_KERNEL);
	129	if (!i2c)
	130	return -ENOMEM;
	131
	132	algo_data = devm_kzalloc(&z->dev, sizeof(*algo_data), GFP_KERNEL);
	133	if (!algo_data)
	134	return -ENOMEM;
	135
	136	dev_set_drvdata(&z->dev, i2c);
	137	i2c->adapter.dev.parent = &z->dev;
	138	i2c->adapter.owner = THIS_MODULE;
	139	/* i2c->adapter.algo assigned by i2c_pcf_add_bus() */
	140	i2c->adapter.algo_data = algo_data;
	141	strlcpy(i2c->adapter.name, "ICY I2C Zorro adapter",
	142	sizeof(i2c->adapter.name));
	143
	144	if (!devm_request_mem_region(&z->dev,
	145	z->resource.start,
	146	4, i2c->adapter.name))
	147	return -ENXIO;
	148
	149	/* Driver private data */
	150	i2c->reg_s0 = ZTWO_VADDR(z->resource.start);
	151	i2c->reg_s1 = ZTWO_VADDR(z->resource.start + 2);
	152
	153	algo_data->data = i2c;
	154	algo_data->setpcf = icy_pcf_setpcf;
	155	algo_data->getpcf = icy_pcf_getpcf;
	156	algo_data->getown = icy_pcf_getown;
	157	algo_data->getclock = icy_pcf_getclock;
	158	algo_data->waitforpin = icy_pcf_waitforpin;
	159
	160	if (i2c_pcf_add_bus(&i2c->adapter)) {
	161	dev_err(&z->dev, "i2c_pcf_add_bus() failed\n");
	162	return -ENXIO;
	163	}
	164
	165	dev_info(&z->dev, "ICY I2C controller at %pa, IRQ not implemented\n",
	166	&z->resource.start);
	167
	168	/*
	169	* The 2019 a1k.org PCBs have an LTC2990 at 0x4c, so start
	170	* it automatically once ltc2990 is modprobed.
	171	*
	172	* in0 is the voltage of the internal 5V power supply.
	173	* temp1 is the temperature inside the chip.
	174	*
	175	* See property_entry above for in1, in2, temp3.
	176	*/
	177	new_fwnode = fwnode_create_software_node(icy_ltc2990_props, NULL);
	178	if (IS_ERR(new_fwnode)) {
	179	dev_info(&z->dev, "Failed to create fwnode for LTC2990, error: %ld\n",
	180	PTR_ERR(new_fwnode));
	181	} else {
	182	/*
	183	* Store the fwnode so we can destroy it on .remove().
	184	* Only store it on success, as fwnode_remove_software_node()
	185	* is NULL safe, but not PTR_ERR safe.
	186	*/
	187	i2c->ltc2990_fwnode = new_fwnode;
	188	ltc2990_info.fwnode = new_fwnode;
	189
	190	i2c->ltc2990_client =
	191	i2c_new_probed_device(&i2c->adapter,
	192	&ltc2990_info,
	193	icy_ltc2990_addresses,
	194	NULL);
	195	}
	196
	197	return 0;
	198	}
	199
	200	static void icy_remove(struct zorro_dev *z)
	201	{
	202	struct icy_i2c *i2c = dev_get_drvdata(&z->dev);
	203
	204	i2c_unregister_device(i2c->ltc2990_client);
	205	fwnode_remove_software_node(i2c->ltc2990_fwnode);
	206
	207	i2c_del_adapter(&i2c->adapter);
	208	}
	209
	210	static const struct zorro_device_id icy_zorro_tbl[] = {
	211	{ ZORRO_ID(VMC, 15, 0), },
	212	{ 0 }
	213	};
	214
	215	MODULE_DEVICE_TABLE(zorro, icy_zorro_tbl);
	216
	217	static struct zorro_driver icy_driver = {
	218	.name = "i2c-icy",
	219	.id_table = icy_zorro_tbl,
	220	.probe = icy_probe,
	221	.remove = icy_remove,
	222	};
	223
	224	module_driver(icy_driver,
	225	zorro_register_driver,
	226	zorro_unregister_driver);
	227
	228	MODULE_AUTHOR("Max Staudt <max@enpas.org>");
	229	MODULE_DESCRIPTION("I2C bus via PCF8584 on ICY Zorro card");
	230	MODULE_LICENSE("GPL v2");

drivers/i2c/busses/i2c-imx-lpi2c.c+1−3

 static int lpi2c_imx_probe(struct platform_device *pdev)
 {
 	struct lpi2c_imx_struct *lpi2c_imx;
-	struct resource *res;
 	unsigned int temp;
 	int irq, ret;
 	if (!lpi2c_imx)
 		return -ENOMEM;
-	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	lpi2c_imx->base = devm_platform_ioremap_resource(pdev, 0);
-	lpi2c_imx->base = devm_ioremap_resource(&pdev->dev, res);
 	if (IS_ERR(lpi2c_imx->base))
 		return PTR_ERR(lpi2c_imx->base);

drivers/i2c/busses/i2c-imx.c+13−4

  *
  */
+#include <linux/acpi.h>
 #include <linux/clk.h>
 #include <linux/completion.h>
 #include <linux/delay.h>
 };
 MODULE_DEVICE_TABLE(of, i2c_imx_dt_ids);
+static const struct acpi_device_id i2c_imx_acpi_ids[] = {
+	{"NXP0001", .driver_data = (kernel_ulong_t)&vf610_i2c_hwdata},
+	{ }
+};
+MODULE_DEVICE_TABLE(acpi, i2c_imx_acpi_ids);
 static inline int is_imx1_i2c(struct imx_i2c_struct *i2c_imx)
 {
 	return i2c_imx->hwdata->devtype == IMX1_I2C;
 static int i2c_imx_probe(struct platform_device *pdev)
 {
-	const struct of_device_id *of_id = of_match_device(i2c_imx_dt_ids,
-							   &pdev->dev);
 	struct imx_i2c_struct *i2c_imx;
 	struct resource *res;
 	struct imxi2c_platform_data *pdata = dev_get_platdata(&pdev->dev);
 	void __iomem *base;
 	int irq, ret;
 	dma_addr_t phy_addr;
+	const struct imx_i2c_hwdata *match;
 	dev_dbg(&pdev->dev, "<%s>\n", __func__);
 	if (!i2c_imx)
 		return -ENOMEM;
-	if (of_id)
+	match = device_get_match_data(&pdev->dev);
-		i2c_imx->hwdata = of_id->data;
+	if (match)
+		i2c_imx->hwdata = match;
 	else
 		i2c_imx->hwdata = (struct imx_i2c_hwdata *)
 				platform_get_device_id(pdev)->driver_data;
 	i2c_imx->adapter.nr		= pdev->id;
 	i2c_imx->adapter.dev.of_node	= pdev->dev.of_node;
 	i2c_imx->base			= base;
+	ACPI_COMPANION_SET(&i2c_imx->adapter.dev, ACPI_COMPANION(&pdev->dev));
 	/* Get I2C clock */
 	i2c_imx->clk = devm_clk_get(&pdev->dev, NULL);
 		.name = DRIVER_NAME,
 		.pm = &i2c_imx_pm_ops,
 		.of_match_table = i2c_imx_dt_ids,
+		.acpi_match_table = i2c_imx_acpi_ids,
 	},
 	.id_table = imx_i2c_devtype,
 };

drivers/i2c/busses/i2c-ismt.c+0−2

@@ -781,8 +781,6 @@ static int ismt_dev_init(struct ismt_priv *priv) · 780 unmodified lines
781	if (!priv->hw)	781	if (!priv->hw)
782	return -ENOMEM;	782	return -ENOMEM;
783		783
784	memset(priv->hw, 0, (ISMT_DESC_ENTRIES * sizeof(struct ismt_desc)));
785
786	priv->head = 0;	784	priv->head = 0;
787	init_completion(&priv->cmp);	785	init_completion(&priv->cmp);
788		786

drivers/i2c/busses/i2c-mxs.c+1−3

 	struct device *dev = &pdev->dev;
 	struct mxs_i2c_dev *i2c;
 	struct i2c_adapter *adap;
-	struct resource *res;
 	int err, irq;
 	i2c = devm_kzalloc(dev, sizeof(*i2c), GFP_KERNEL);
 		i2c->dev_type = device_id->driver_data;
 	}
-	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	i2c->regs = devm_platform_ioremap_resource(pdev, 0);
-	i2c->regs = devm_ioremap_resource(&pdev->dev, res);
 	if (IS_ERR(i2c->regs))
 		return PTR_ERR(i2c->regs);

drivers/i2c/busses/i2c-ocores.c+3−2

 	}
 	if (ocores_algorithm.master_xfer != ocores_xfer_polling) {
-		ret = devm_request_irq(&pdev->dev, irq, ocores_isr, 0,
+		ret = devm_request_any_context_irq(&pdev->dev, irq,
-				       pdev->name, i2c);
+						   ocores_isr, 0,
+						   pdev->name, i2c);
 		if (ret) {
 			dev_err(&pdev->dev, "Cannot claim IRQ\n");
 			goto err_clk;

drivers/i2c/busses/i2c-piix4.c+27−7

 #define PIIX4_BLOCK_DATA	0x14
 /* Multi-port constants */
-#define PIIX4_MAX_ADAPTERS 4
+#define PIIX4_MAX_ADAPTERS	4
+#define HUDSON2_MAIN_PORTS	2 /* HUDSON2, KERNCZ reserves ports 3, 4 */
 /* SB800 constants */
 #define SB800_PIIX4_SMB_IDX		0xcd6
 static struct i2c_adapter *piix4_main_adapters[PIIX4_MAX_ADAPTERS];
 static struct i2c_adapter *piix4_aux_adapter;
+static int piix4_adapter_count;
 static int piix4_add_adapter(struct pci_dev *dev, unsigned short smba,
 			     bool sb800_main, u8 port, bool notify_imc,
-			     const char *name, struct i2c_adapter **padap)
+			     u8 hw_port_nr, const char *name,
+			     struct i2c_adapter **padap)
 {
 	struct i2c_adapter *adap;
 	struct i2c_piix4_adapdata *adapdata;
 	/* set up the sysfs linkage to our parent device */
 	adap->dev.parent = &dev->dev;
+	if (has_acpi_companion(&dev->dev)) {
+		acpi_preset_companion(&adap->dev,
+				      ACPI_COMPANION(&dev->dev),
+				      hw_port_nr);
+	}
 	snprintf(adap->name, sizeof(adap->name),
 		"SMBus PIIX4 adapter%s at %04x", name, smba);
 	int port;
 	int retval;
-	for (port = 0; port < PIIX4_MAX_ADAPTERS; port++) {
+	if (dev->device == PCI_DEVICE_ID_AMD_KERNCZ_SMBUS ||
+	    (dev->device == PCI_DEVICE_ID_AMD_HUDSON2_SMBUS &&
+	     dev->revision >= 0x1F)) {
+		piix4_adapter_count = HUDSON2_MAIN_PORTS;
+	} else {
+		piix4_adapter_count = PIIX4_MAX_ADAPTERS;
+	}
+	for (port = 0; port < piix4_adapter_count; port++) {
+		u8 hw_port_nr = port == 0 ? 0 : port + 1;
 		retval = piix4_add_adapter(dev, smba, true, port, notify_imc,
+					   hw_port_nr,
 					   piix4_main_port_names_sb800[port],
 					   &piix4_main_adapters[port]);
 		if (retval < 0)
 			return retval;
 		/* Try to register main SMBus adapter, give up if we can't */
-		retval = piix4_add_adapter(dev, retval, false, 0, false, "",
+		retval = piix4_add_adapter(dev, retval, false, 0, false, 0,
-					   &piix4_main_adapters[0]);
+					   "", &piix4_main_adapters[0]);
 		if (retval < 0)
 			return retval;
 	}
 	if (retval > 0) {
 		/* Try to add the aux adapter if it exists,
 		 * piix4_add_adapter will clean up if this fails */
-		piix4_add_adapter(dev, retval, false, 0, false,
+		piix4_add_adapter(dev, retval, false, 0, false, 1,
 				  is_sb800 ? piix4_aux_port_name_sb800 : "",
 				  &piix4_aux_adapter);
 	}
 static void piix4_remove(struct pci_dev *dev)
 {
-	int port = PIIX4_MAX_ADAPTERS;
+	int port = piix4_adapter_count;
 	while (--port >= 0) {
 		if (piix4_main_adapters[port]) {

drivers/i2c/busses/i2c-sprd.c+13−12

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#include <linux/init.h>	12	#include <linux/init.h>
13	#include <linux/interrupt.h>	13	#include <linux/interrupt.h>
14	#include <linux/kernel.h>	14	#include <linux/kernel.h>
		15	#include <linux/module.h>
15	#include <linux/of.h>	16	#include <linux/of.h>
16	#include <linux/of_device.h>	17	#include <linux/of_device.h>
17	#include <linux/platform_device.h>	18	#include <linux/platform_device.h>
@@ -465,9 +466,9 @@ static int sprd_i2c_clk_init(struct sprd_i2c *i2c_dev) · 447 unmodified lines
465		466
466	i2c_dev->clk = devm_clk_get(i2c_dev->dev, "enable");	467	i2c_dev->clk = devm_clk_get(i2c_dev->dev, "enable");
467	if (IS_ERR(i2c_dev->clk)) {	468	if (IS_ERR(i2c_dev->clk)) {
468	dev_warn(i2c_dev->dev, "i2c%d can't get the enable clock\n",	469	dev_err(i2c_dev->dev, "i2c%d can't get the enable clock\n",
469	i2c_dev->adap.nr);	470	i2c_dev->adap.nr);
470	i2c_dev->clk = NULL;	471	return PTR_ERR(i2c_dev->clk);
471	}	472	}
472		473
473	return 0;	474	return 0;
@@ -477,7 +478,6 @@ static int sprd_i2c_probe(struct platform_device *pdev) · 3 unmodified lines
477	{	478	{
478	struct device *dev = &pdev->dev;	479	struct device *dev = &pdev->dev;
479	struct sprd_i2c *i2c_dev;	480	struct sprd_i2c *i2c_dev;
480	struct resource *res;
481	u32 prop;	481	u32 prop;
482	int ret;	482	int ret;
483		483
@@ -487,8 +487,7 @@ static int sprd_i2c_probe(struct platform_device *pdev) · 3 unmodified lines
487	if (!i2c_dev)	487	if (!i2c_dev)
488	return -ENOMEM;	488	return -ENOMEM;
489		489
490	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);	490	i2c_dev->base = devm_platform_ioremap_resource(pdev, 0);
491	i2c_dev->base = devm_ioremap_resource(dev, res);
492	if (IS_ERR(i2c_dev->base))	491	if (IS_ERR(i2c_dev->base))
493	return PTR_ERR(i2c_dev->base);	492	return PTR_ERR(i2c_dev->base);
494		493
@@ -520,7 +519,10 @@ static int sprd_i2c_probe(struct platform_device *pdev) · 25 unmodified lines
520	if (i2c_dev->bus_freq != 100000 && i2c_dev->bus_freq != 400000)	519	if (i2c_dev->bus_freq != 100000 && i2c_dev->bus_freq != 400000)
521	return -EINVAL;	520	return -EINVAL;
522		521
523	sprd_i2c_clk_init(i2c_dev);	522	ret = sprd_i2c_clk_init(i2c_dev);
		523	if (ret)
		524	return ret;
		525
524	platform_set_drvdata(pdev, i2c_dev);	526	platform_set_drvdata(pdev, i2c_dev);
525		527
526	ret = clk_prepare_enable(i2c_dev->clk);	528	ret = clk_prepare_enable(i2c_dev->clk);
@@ -644,8 +646,7 @@ static struct platform_driver sprd_i2c_driver = { · 117 unmodified lines
644	},	646	},
645	};	647	};
646		648
647	static int sprd_i2c_init(void)	649	module_platform_driver(sprd_i2c_driver);
648	{	650
649	return platform_driver_register(&sprd_i2c_driver);	651	MODULE_DESCRIPTION("Spreadtrum I2C master controller driver");
650	}	652	MODULE_LICENSE("GPL v2");
651	arch_initcall_sync(sprd_i2c_init);

drivers/i2c/busses/i2c-stm32f7.c+1−1

@@ -1809,7 +1809,7 @@ static u32 stm32f7_i2c_func(struct i2c_adapter *adap) · 1808 unmodified lines
1809	I2C_FUNC_SMBUS_I2C_BLOCK;	1809	I2C_FUNC_SMBUS_I2C_BLOCK;
1810	}	1810	}
1811		1811
1812	static struct i2c_algorithm stm32f7_i2c_algo = {	1812	static const struct i2c_algorithm stm32f7_i2c_algo = {
1813	.master_xfer = stm32f7_i2c_xfer,	1813	.master_xfer = stm32f7_i2c_xfer,
1814	.smbus_xfer = stm32f7_i2c_smbus_xfer,	1814	.smbus_xfer = stm32f7_i2c_smbus_xfer,
1815	.functionality = stm32f7_i2c_func,	1815	.functionality = stm32f7_i2c_func,

drivers/i2c/busses/i2c-synquacer.c+1−1

@@ -526,7 +526,7 @@ static const struct i2c_algorithm synquacer_i2c_algo = { · 525 unmodified lines
526	.functionality = synquacer_i2c_functionality,	526	.functionality = synquacer_i2c_functionality,
527	};	527	};
528		528
529	static struct i2c_adapter synquacer_i2c_ops = {	529	static const struct i2c_adapter synquacer_i2c_ops = {
530	.owner = THIS_MODULE,	530	.owner = THIS_MODULE,
531	.name = "synquacer_i2c-adapter",	531	.name = "synquacer_i2c-adapter",
532	.algo = &synquacer_i2c_algo,	532	.algo = &synquacer_i2c_algo,

drivers/i2c/busses/i2c-taos-evm.c+1−1

@@ -39,7 +39,7 @@ struct taos_data { · 38 unmodified lines
39	};	39	};
40		40
41	/* TAOS TSL2550 EVM */	41	/* TAOS TSL2550 EVM */
42	static struct i2c_board_info tsl2550_info = {	42	static const struct i2c_board_info tsl2550_info = {
43	I2C_BOARD_INFO("tsl2550", 0x39),	43	I2C_BOARD_INFO("tsl2550", 0x39),
44	};	44	};
45		45

drivers/i2c/busses/i2c-tegra.c+27−29

@@ -636,7 +636,7 @@ static void tegra_dvc_init(struct tegra_i2c_dev *i2c_dev) · 635 unmodified lines
636	dvc_writel(i2c_dev, val, DVC_CTRL_REG1);	636	dvc_writel(i2c_dev, val, DVC_CTRL_REG1);
637	}	637	}
638		638
639	static int tegra_i2c_runtime_resume(struct device *dev)	639	static int __maybe_unused tegra_i2c_runtime_resume(struct device *dev)
640	{	640	{
641	struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);	641	struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);
642	int ret;	642	int ret;
@@ -665,7 +665,7 @@ static int tegra_i2c_runtime_resume(struct device *dev) · 22 unmodified lines
665	return 0;	665	return 0;
666	}	666	}
667		667
668	static int tegra_i2c_runtime_suspend(struct device *dev)	668	static int __maybe_unused tegra_i2c_runtime_suspend(struct device *dev)
669	{	669	{
670	struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);	670	struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);
671		671
@@ -713,12 +713,6 @@ static int tegra_i2c_init(struct tegra_i2c_dev *i2c_dev, bool clk_reinit) · 41 unmodified lines
713	u32 tsu_thd;	713	u32 tsu_thd;
714	u8 tlow, thigh;	714	u8 tlow, thigh;
715		715
716	err = pm_runtime_get_sync(i2c_dev->dev);
717	if (err < 0) {
718	dev_err(i2c_dev->dev, "runtime resume failed %d\n", err);
719	return err;
720	}
721
722	reset_control_assert(i2c_dev->rst);	716	reset_control_assert(i2c_dev->rst);
723	udelay(2);	717	udelay(2);
724	reset_control_deassert(i2c_dev->rst);	718	reset_control_deassert(i2c_dev->rst);
@@ -772,7 +766,7 @@ static int tegra_i2c_init(struct tegra_i2c_dev *i2c_dev, bool clk_reinit) · 47 unmodified lines
772	if (err) {	766	if (err) {
773	dev_err(i2c_dev->dev,	767	dev_err(i2c_dev->dev,
774	"failed changing clock rate: %d\n", err);	768	"failed changing clock rate: %d\n", err);
775	goto err;	769	return err;
776	}	770	}
777	}	771	}
778		772
@@ -787,23 +781,21 @@ static int tegra_i2c_init(struct tegra_i2c_dev *i2c_dev, bool clk_reinit) · 8 unmodified lines
787		781
788	err = tegra_i2c_flush_fifos(i2c_dev);	782	err = tegra_i2c_flush_fifos(i2c_dev);
789	if (err)	783	if (err)
790	goto err;	784	return err;
791		785
792	if (i2c_dev->is_multimaster_mode && i2c_dev->hw->has_slcg_override_reg)	786	if (i2c_dev->is_multimaster_mode && i2c_dev->hw->has_slcg_override_reg)
793	i2c_writel(i2c_dev, I2C_MST_CORE_CLKEN_OVR, I2C_CLKEN_OVERRIDE);	787	i2c_writel(i2c_dev, I2C_MST_CORE_CLKEN_OVR, I2C_CLKEN_OVERRIDE);
794		788
795	err = tegra_i2c_wait_for_config_load(i2c_dev);	789	err = tegra_i2c_wait_for_config_load(i2c_dev);
796	if (err)	790	if (err)
797	goto err;	791	return err;
798		792
799	if (i2c_dev->irq_disabled) {	793	if (i2c_dev->irq_disabled) {
800	i2c_dev->irq_disabled = false;	794	i2c_dev->irq_disabled = false;
801	enable_irq(i2c_dev->irq);	795	enable_irq(i2c_dev->irq);
802	}	796	}
803		797
804	err:	798	return 0;
805	pm_runtime_put(i2c_dev->dev);
806	return err;
807	}	799	}
808		800
809	static int tegra_i2c_disable_packet_mode(struct tegra_i2c_dev *i2c_dev)	801	static int tegra_i2c_disable_packet_mode(struct tegra_i2c_dev *i2c_dev)
@@ -1616,12 +1608,14 @@ static int tegra_i2c_probe(struct platform_device *pdev) · 806 unmodified lines
1616	}	1608	}
1617		1609
1618	pm_runtime_enable(&pdev->dev);	1610	pm_runtime_enable(&pdev->dev);
1619	if (!pm_runtime_enabled(&pdev->dev)) {	1611	if (!pm_runtime_enabled(&pdev->dev))
1620	ret = tegra_i2c_runtime_resume(&pdev->dev);	1612	ret = tegra_i2c_runtime_resume(&pdev->dev);
1621	if (ret < 0) {	1613	else
1622	dev_err(&pdev->dev, "runtime resume failed\n");	1614	ret = pm_runtime_get_sync(i2c_dev->dev);
1623	goto unprepare_div_clk;	1615
1624	}	1616	if (ret < 0) {
		1617	dev_err(&pdev->dev, "runtime resume failed\n");
		1618	goto unprepare_div_clk;
1625	}	1619	}
1626		1620
1627	if (i2c_dev->is_multimaster_mode) {	1621	if (i2c_dev->is_multimaster_mode) {
@@ -1666,6 +1660,8 @@ static int tegra_i2c_probe(struct platform_device *pdev) · 38 unmodified lines
1666	if (ret)	1660	if (ret)
1667	goto release_dma;	1661	goto release_dma;
1668		1662
		1663	pm_runtime_put(&pdev->dev);
		1664
1669	return 0;	1665	return 0;
1670		1666
1671	release_dma:	1667	release_dma:
@@ -1711,8 +1707,7 @@ static int tegra_i2c_remove(struct platform_device *pdev) · 39 unmodified lines
1711	return 0;	1707	return 0;
1712	}	1708	}
1713		1709
1714	#ifdef CONFIG_PM_SLEEP	1710	static int __maybe_unused tegra_i2c_suspend(struct device *dev)
1715	static int tegra_i2c_suspend(struct device *dev)
1716	{	1711	{
1717	struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);	1712	struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);
1718		1713
@@ -1721,38 +1716,41 @@ static int tegra_i2c_suspend(struct device *dev) · 2 unmodified lines
1721	return 0;	1716	return 0;
1722	}	1717	}
1723		1718
1724	static int tegra_i2c_resume(struct device *dev)	1719	static int __maybe_unused tegra_i2c_resume(struct device *dev)
1725	{	1720	{
1726	struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);	1721	struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);
1727	int err;	1722	int err;
1728		1723
		1724	err = tegra_i2c_runtime_resume(dev);
		1725	if (err)
		1726	return err;
		1727
1729	err = tegra_i2c_init(i2c_dev, false);	1728	err = tegra_i2c_init(i2c_dev, false);
1730	if (err)	1729	if (err)
1731	return err;	1730	return err;
1732		1731
		1732	err = tegra_i2c_runtime_suspend(dev);
		1733	if (err)
		1734	return err;
		1735
1733	i2c_mark_adapter_resumed(&i2c_dev->adapter);	1736	i2c_mark_adapter_resumed(&i2c_dev->adapter);
1734		1737
1735	return 0;	1738	return 0;
1736	}	1739	}
1737		1740
1738	static const struct dev_pm_ops tegra_i2c_pm = {	1741	static const struct dev_pm_ops tegra_i2c_pm = {
1739	SET_SYSTEM_SLEEP_PM_OPS(tegra_i2c_suspend, tegra_i2c_resume)	1742	SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(tegra_i2c_suspend, tegra_i2c_resume)
1740	SET_RUNTIME_PM_OPS(tegra_i2c_runtime_suspend, tegra_i2c_runtime_resume,	1743	SET_RUNTIME_PM_OPS(tegra_i2c_runtime_suspend, tegra_i2c_runtime_resume,
1741	NULL)	1744	NULL)
1742	};	1745	};
1743		1746
1744	#define TEGRA_I2C_PM (&tegra_i2c_pm)
1745	#else
1746	#define TEGRA_I2C_PM NULL
1747	#endif
1748
1749	static struct platform_driver tegra_i2c_driver = {	1747	static struct platform_driver tegra_i2c_driver = {
1750	.probe = tegra_i2c_probe,	1748	.probe = tegra_i2c_probe,
1751	.remove = tegra_i2c_remove,	1749	.remove = tegra_i2c_remove,
1752	.driver = {	1750	.driver = {
1753	.name = "tegra-i2c",	1751	.name = "tegra-i2c",
1754	.of_match_table = tegra_i2c_of_match,	1752	.of_match_table = tegra_i2c_of_match,
1755	.pm = TEGRA_I2C_PM,	1753	.pm = &tegra_i2c_pm,
1756	},	1754	},
1757	};	1755	};
1758		1756

drivers/i2c/busses/i2c-uniphier-f.c+2−24

 		if (fifo_space-- <= 0)
 			break;
-		dev_dbg(&priv->adap.dev, "write data: %02x\n", *priv->buf);
 		writel(*priv->buf++, priv->membase + UNIPHIER_FI2C_DTTX);
 		priv->len--;
 	}
 			break;
 		*priv->buf++ = readl(priv->membase + UNIPHIER_FI2C_DTRX);
-		dev_dbg(&priv->adap.dev, "read data: %02x\n", priv->buf[-1]);
 		priv->len--;
 	}
 }
 static void uniphier_fi2c_stop(struct uniphier_fi2c_priv *priv)
 {
-	dev_dbg(&priv->adap.dev, "stop condition\n");
 	priv->enabled_irqs |= UNIPHIER_FI2C_INT_STOP;
 	uniphier_fi2c_set_irqs(priv);
 	writel(UNIPHIER_FI2C_CR_MST | UNIPHIER_FI2C_CR_STO,
 	irq_status = readl(priv->membase + UNIPHIER_FI2C_INT);
 	irq_status &= priv->enabled_irqs;
-	dev_dbg(&priv->adap.dev,
-		"interrupt: enabled_irqs=%04x, irq_status=%04x\n",
-		priv->enabled_irqs, irq_status);
 	if (irq_status & UNIPHIER_FI2C_INT_STOP)
 		goto complete;
 	if (unlikely(irq_status & UNIPHIER_FI2C_INT_AL)) {
-		dev_dbg(&priv->adap.dev, "arbitration lost\n");
 		priv->error = -EAGAIN;
 		goto complete;
 	}
 	if (unlikely(irq_status & UNIPHIER_FI2C_INT_NA)) {
-		dev_dbg(&priv->adap.dev, "could not get ACK\n");
 		priv->error = -ENXIO;
 		if (priv->flags & UNIPHIER_FI2C_RD) {
 			/*
 		if (unlikely(priv->flags & UNIPHIER_FI2C_MANUAL_NACK)) {
 			if (priv->len <= UNIPHIER_FI2C_FIFO_SIZE &&
 			    !(priv->flags & UNIPHIER_FI2C_BYTE_WISE)) {
-				dev_dbg(&priv->adap.dev,
-					"enable read byte count IRQ\n");
 				priv->enabled_irqs |= UNIPHIER_FI2C_INT_RB;
 				uniphier_fi2c_set_irqs(priv);
 				priv->flags |= UNIPHIER_FI2C_BYTE_WISE;
 			}
-			if (priv->len <= 1) {
+			if (priv->len <= 1)
-				dev_dbg(&priv->adap.dev, "set NACK\n");
 				writel(UNIPHIER_FI2C_CR_MST |
 				       UNIPHIER_FI2C_CR_NACK,
 				       priv->membase + UNIPHIER_FI2C_CR);
-			}
 		}
 		goto handled;
 	bool is_read = msg->flags & I2C_M_RD;
 	unsigned long time_left, flags;
-	dev_dbg(&adap->dev, "%s: addr=0x%02x, len=%d, repeat=%d, stop=%d\n",
-		is_read ? "receive" : "transmit", msg->addr, msg->len,
-		repeat, stop);
 	priv->len = msg->len;
 	priv->buf = msg->buf;
 	priv->enabled_irqs = UNIPHIER_FI2C_INT_FAULTS;
 	else
 		uniphier_fi2c_tx_init(priv, msg->addr, repeat);
-	dev_dbg(&adap->dev, "start condition\n");
 	/*
 	 * For a repeated START condition, writing a slave address to the FIFO
 	 * kicks the controller. So, the UNIPHIER_FI2C_CR register should be
 		uniphier_fi2c_recover(priv);
 		return -ETIMEDOUT;
 	}
-	dev_dbg(&adap->dev, "complete\n");
 	if (unlikely(priv->flags & UNIPHIER_FI2C_DEFER_STOP_COMP)) {
 		u32 status;
 {
 	struct device *dev = &pdev->dev;
 	struct uniphier_fi2c_priv *priv;
-	struct resource *regs;
 	u32 bus_speed;
 	unsigned long clk_rate;
 	int irq, ret;
 	if (!priv)
 		return -ENOMEM;
-	regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	priv->membase = devm_platform_ioremap_resource(pdev, 0);
-	priv->membase = devm_ioremap_resource(dev, regs);
 	if (IS_ERR(priv->membase))
 		return PTR_ERR(priv->membase);

drivers/i2c/busses/i2c-uniphier.c+4−18

@@ -71,7 +71,6 @@ static int uniphier_i2c_xfer_byte(struct i2c_adapter *adap, u32 txdata, · 70 unmodified lines
71	reinit_completion(&priv->comp);	71	reinit_completion(&priv->comp);
72		72
73	txdata \|= UNIPHIER_I2C_DTRM_IRQEN;	73	txdata \|= UNIPHIER_I2C_DTRM_IRQEN;
74	dev_dbg(&adap->dev, "write data: 0x%04x\n", txdata);
75	writel(txdata, priv->membase + UNIPHIER_I2C_DTRM);	74	writel(txdata, priv->membase + UNIPHIER_I2C_DTRM);
76		75
77	time_left = wait_for_completion_timeout(&priv->comp, adap->timeout);	76	time_left = wait_for_completion_timeout(&priv->comp, adap->timeout);
@@ -81,8 +80,6 @@ static int uniphier_i2c_xfer_byte(struct i2c_adapter *adap, u32 txdata, · 3 unmodified lines
81	}	80	}
82		81
83	rxdata = readl(priv->membase + UNIPHIER_I2C_DREC);	82	rxdata = readl(priv->membase + UNIPHIER_I2C_DREC);
84	dev_dbg(&adap->dev, "read data: 0x%04x\n", rxdata);
85
86	if (rxdatap)	83	if (rxdatap)
87	*rxdatap = rxdata;	84	*rxdatap = rxdata;
88		85
@@ -98,14 +95,11 @@ static int uniphier_i2c_send_byte(struct i2c_adapter *adap, u32 txdata) · 9 unmodified lines
98	if (ret)	95	if (ret)
99	return ret;	96	return ret;
100		97
101	if (unlikely(rxdata & UNIPHIER_I2C_DREC_LAB)) {	98	if (unlikely(rxdata & UNIPHIER_I2C_DREC_LAB))
102	dev_dbg(&adap->dev, "arbitration lost\n");
103	return -EAGAIN;	99	return -EAGAIN;
104	}	100
105	if (unlikely(rxdata & UNIPHIER_I2C_DREC_LRB)) {	101	if (unlikely(rxdata & UNIPHIER_I2C_DREC_LRB))
106	dev_dbg(&adap->dev, "could not get ACK\n");
107	return -ENXIO;	102	return -ENXIO;
108	}
109		103
110	return 0;	104	return 0;
111	}	105	}
@@ -115,7 +109,6 @@ static int uniphier_i2c_tx(struct i2c_adapter *adap, u16 addr, u16 len, · 3 unmodified lines
115	{	109	{
116	int ret;	110	int ret;
117		111
118	dev_dbg(&adap->dev, "start condition\n");
119	ret = uniphier_i2c_send_byte(adap, addr << 1 \|	112	ret = uniphier_i2c_send_byte(adap, addr << 1 \|
120	UNIPHIER_I2C_DTRM_STA \|	113	UNIPHIER_I2C_DTRM_STA \|
121	UNIPHIER_I2C_DTRM_NACK);	114	UNIPHIER_I2C_DTRM_NACK);
@@ -137,7 +130,6 @@ static int uniphier_i2c_rx(struct i2c_adapter *adap, u16 addr, u16 len, · 15 unmodified lines
137	{	130	{
138	int ret;	131	int ret;
139		132
140	dev_dbg(&adap->dev, "start condition\n");
141	ret = uniphier_i2c_send_byte(adap, addr << 1 \|	133	ret = uniphier_i2c_send_byte(adap, addr << 1 \|
142	UNIPHIER_I2C_DTRM_STA \|	134	UNIPHIER_I2C_DTRM_STA \|
143	UNIPHIER_I2C_DTRM_NACK \|	135	UNIPHIER_I2C_DTRM_NACK \|
@@ -161,7 +153,6 @@ static int uniphier_i2c_rx(struct i2c_adapter *adap, u16 addr, u16 len, · 17 unmodified lines
161		153
162	static int uniphier_i2c_stop(struct i2c_adapter *adap)	154	static int uniphier_i2c_stop(struct i2c_adapter *adap)
163	{	155	{
164	dev_dbg(&adap->dev, "stop condition\n");
165	return uniphier_i2c_send_byte(adap, UNIPHIER_I2C_DTRM_STO \|	156	return uniphier_i2c_send_byte(adap, UNIPHIER_I2C_DTRM_STO \|
166	UNIPHIER_I2C_DTRM_NACK);	157	UNIPHIER_I2C_DTRM_NACK);
167	}	158	}
@@ -173,9 +164,6 @@ static int uniphier_i2c_master_xfer_one(struct i2c_adapter *adap, · 5 unmodified lines
173	bool recovery = false;	164	bool recovery = false;
174	int ret;	165	int ret;
175		166
176	dev_dbg(&adap->dev, "%s: addr=0x%02x, len=%d, stop=%d\n",
177	is_read ? "receive" : "transmit", msg->addr, msg->len, stop);
178
179	if (is_read)	167	if (is_read)
180	ret = uniphier_i2c_rx(adap, msg->addr, msg->len, msg->buf);	168	ret = uniphier_i2c_rx(adap, msg->addr, msg->len, msg->buf);
181	else	169	else
@@ -326,7 +314,6 @@ static int uniphier_i2c_probe(struct platform_device *pdev) · 144 unmodified lines
326	{	314	{
327	struct device *dev = &pdev->dev;	315	struct device *dev = &pdev->dev;
328	struct uniphier_i2c_priv *priv;	316	struct uniphier_i2c_priv *priv;
329	struct resource *regs;
330	u32 bus_speed;	317	u32 bus_speed;
331	unsigned long clk_rate;	318	unsigned long clk_rate;
332	int irq, ret;	319	int irq, ret;
@@ -335,8 +322,7 @@ static int uniphier_i2c_probe(struct platform_device *pdev) · 2 unmodified lines
335	if (!priv)	322	if (!priv)
336	return -ENOMEM;	323	return -ENOMEM;
337		324
338	regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);	325	priv->membase = devm_platform_ioremap_resource(pdev, 0);
339	priv->membase = devm_ioremap_resource(dev, regs);
340	if (IS_ERR(priv->membase))	326	if (IS_ERR(priv->membase))
341	return PTR_ERR(priv->membase);	327	return PTR_ERR(priv->membase);
342		328

drivers/i2c/i2c-core-base.c+9−11

 		return -ENODEV;
 	if (client->flags & I2C_CLIENT_WAKE) {
-		int wakeirq = -ENOENT;
+		int wakeirq;
-		if (dev->of_node) {
+		wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
-			wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
+		if (wakeirq == -EPROBE_DEFER)
-			if (wakeirq == -EPROBE_DEFER)
+			return wakeirq;
-				return wakeirq;
-		}
 		device_init_wakeup(&client->dev, true);
 EXPORT_SYMBOL_GPL(devm_i2c_new_dummy_device);
 /**
- * i2c_new_secondary_device - Helper to get the instantiated secondary address
+ * i2c_new_ancillary_device - Helper to get the instantiated secondary address
  * and create the associated device
  * @client: Handle to the primary client
  * @name: Handle to specify which secondary address to get
  * cell whose "reg-names" value matches the slave name.
  *
  * This returns the new i2c client, which should be saved for later use with
- * i2c_unregister_device(); or NULL to indicate an error.
+ * i2c_unregister_device(); or an ERR_PTR to describe the error.
  */
-struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
+struct i2c_client *i2c_new_ancillary_device(struct i2c_client *client,
 						const char *name,
 						u16 default_addr)
 {
 	}
 	dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
-	return i2c_new_dummy(client->adapter, addr);
+	return i2c_new_dummy_device(client->adapter, addr);
 }
-EXPORT_SYMBOL_GPL(i2c_new_secondary_device);
+EXPORT_SYMBOL_GPL(i2c_new_ancillary_device);
 /* ------------------------------------------------------------------------- */

drivers/i2c/i2c-slave-eeprom.c+31−11

  * pointer, yet implementation is deferred until the need actually arises.
  */
+/*
+ * FIXME: What to do if only 8 bits of a 16 bit address are sent?
+ * The ST-M24C64 sends only 0xff then. Needs verification with other
+ * EEPROMs, though. We currently use the 8 bit as a valid address.
+ */
+#include <linux/bitfield.h>
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/module.h>
 struct eeprom_data {
 	struct bin_attribute bin;
-	bool first_write;
 	spinlock_t buffer_lock;
-	u8 buffer_idx;
+	u16 buffer_idx;
+	u16 address_mask;
+	u8 num_address_bytes;
+	u8 idx_write_cnt;
 	u8 buffer[];
 };
+#define I2C_SLAVE_BYTELEN GENMASK(15, 0)
+#define I2C_SLAVE_FLAG_ADDR16 BIT(16)
+#define I2C_SLAVE_DEVICE_MAGIC(_len, _flags) ((_flags) | (_len))
 static int i2c_slave_eeprom_slave_cb(struct i2c_client *client,
 				     enum i2c_slave_event event, u8 *val)
 {
 	switch (event) {
 	case I2C_SLAVE_WRITE_RECEIVED:
-		if (eeprom->first_write) {
+		if (eeprom->idx_write_cnt < eeprom->num_address_bytes) {
-			eeprom->buffer_idx = *val;
+			if (eeprom->idx_write_cnt == 0)
-			eeprom->first_write = false;
+				eeprom->buffer_idx = 0;
+			eeprom->buffer_idx = *val | (eeprom->buffer_idx << 8);
+			eeprom->idx_write_cnt++;
 		} else {
 			spin_lock(&eeprom->buffer_lock);
-			eeprom->buffer[eeprom->buffer_idx++] = *val;
+			eeprom->buffer[eeprom->buffer_idx++ & eeprom->address_mask] = *val;
 			spin_unlock(&eeprom->buffer_lock);
 		}
 		break;
 		/* fallthrough */
 	case I2C_SLAVE_READ_REQUESTED:
 		spin_lock(&eeprom->buffer_lock);
-		*val = eeprom->buffer[eeprom->buffer_idx];
+		*val = eeprom->buffer[eeprom->buffer_idx & eeprom->address_mask];
 		spin_unlock(&eeprom->buffer_lock);
 		/*
 		 * Do not increment buffer_idx here, because we don't know if
 	case I2C_SLAVE_STOP:
 	case I2C_SLAVE_WRITE_REQUESTED:
-		eeprom->first_write = true;
+		eeprom->idx_write_cnt = 0;
 		break;
 	default:
 {
 	struct eeprom_data *eeprom;
 	int ret;
-	unsigned size = id->driver_data;
+	unsigned int size = FIELD_GET(I2C_SLAVE_BYTELEN, id->driver_data);
+	unsigned int flag_addr16 = FIELD_GET(I2C_SLAVE_FLAG_ADDR16, id->driver_data);
 	eeprom = devm_kzalloc(&client->dev, sizeof(struct eeprom_data) + size, GFP_KERNEL);
 	if (!eeprom)
 		return -ENOMEM;
-	eeprom->first_write = true;
+	eeprom->idx_write_cnt = 0;
+	eeprom->num_address_bytes = flag_addr16 ? 2 : 1;
+	eeprom->address_mask = size - 1;
 	spin_lock_init(&eeprom->buffer_lock);
 	i2c_set_clientdata(client, eeprom);
 }
 static const struct i2c_device_id i2c_slave_eeprom_id[] = {
-	{ "slave-24c02", 2048 / 8 },
+	{ "slave-24c02", I2C_SLAVE_DEVICE_MAGIC(2048 / 8,  0) },
+	{ "slave-24c32", I2C_SLAVE_DEVICE_MAGIC(32768 / 8, I2C_SLAVE_FLAG_ADDR16) },
+	{ "slave-24c64", I2C_SLAVE_DEVICE_MAGIC(65536 / 8, I2C_SLAVE_FLAG_ADDR16) },
 	{ }
 };
 MODULE_DEVICE_TABLE(i2c, i2c_slave_eeprom_id);

drivers/media/i2c/adv748x/adv748x-core.c+3−3

@@ -183,14 +183,14 @@ static int adv748x_initialise_clients(struct adv748x_state *state) · 182 unmodified lines
183	int ret;	183	int ret;
184		184
185	for (i = ADV748X_PAGE_DPLL; i < ADV748X_PAGE_MAX; ++i) {	185	for (i = ADV748X_PAGE_DPLL; i < ADV748X_PAGE_MAX; ++i) {
186	state->i2c_clients[i] = i2c_new_secondary_device(	186	state->i2c_clients[i] = i2c_new_ancillary_device(
187	state->client,	187	state->client,
188	adv748x_default_addresses[i].name,	188	adv748x_default_addresses[i].name,
189	adv748x_default_addresses[i].default_addr);	189	adv748x_default_addresses[i].default_addr);
190		190
191	if (state->i2c_clients[i] == NULL) {	191	if (IS_ERR(state->i2c_clients[i])) {
192	adv_err(state, "failed to create i2c client %u\n", i);	192	adv_err(state, "failed to create i2c client %u\n", i);
193	return -ENOMEM;	193	return PTR_ERR(state->i2c_clients[i]);
194	}	194	}
195		195
196	ret = adv748x_configure_regmap(state, i);	196	ret = adv748x_configure_regmap(state, i);

drivers/media/i2c/adv7604.c+12−10

 {
 	unsigned int i;
-	for (i = 1; i < ARRAY_SIZE(state->i2c_clients); ++i) {
+	for (i = 1; i < ARRAY_SIZE(state->i2c_clients); ++i)
-		if (state->i2c_clients[i])
+		i2c_unregister_device(state->i2c_clients[i]);
-			i2c_unregister_device(state->i2c_clients[i]);
-	}
 }
 static struct i2c_client *adv76xx_dummy_client(struct v4l2_subdev *sd,
 	struct i2c_client *new_client;
 	if (pdata && pdata->i2c_addresses[page])
-		new_client = i2c_new_dummy(client->adapter,
+		new_client = i2c_new_dummy_device(client->adapter,
 					   pdata->i2c_addresses[page]);
 	else
-		new_client = i2c_new_secondary_device(client,
+		new_client = i2c_new_ancillary_device(client,
 				adv76xx_default_addresses[page].name,
 				adv76xx_default_addresses[page].default_addr);
-	if (new_client)
+	if (!IS_ERR(new_client))
 		io_write(sd, io_reg, new_client->addr << 1);
 	return new_client;
 	}
 	for (i = 1; i < ADV76XX_PAGE_MAX; ++i) {
+		struct i2c_client *dummy_client;
 		if (!(BIT(i) & state->info->page_mask))
 			continue;
-		state->i2c_clients[i] = adv76xx_dummy_client(sd, i);
+		dummy_client = adv76xx_dummy_client(sd, i);
-		if (!state->i2c_clients[i]) {
+		if (IS_ERR(dummy_client)) {
-			err = -EINVAL;
+			err = PTR_ERR(dummy_client);
 			v4l2_err(sd, "failed to create i2c client %u\n", i);
 			goto err_i2c;
 		}
+		state->i2c_clients[i] = dummy_client;
 	}
 	INIT_DELAYED_WORK(&state->delayed_work_enable_hotplug,

drivers/misc/eeprom/at24.c+0−1

@@ -14,7 +14,6 @@ · 13 unmodified lines
14	#include <linux/delay.h>	14	#include <linux/delay.h>
15	#include <linux/mutex.h>	15	#include <linux/mutex.h>
16	#include <linux/mod_devicetable.h>	16	#include <linux/mod_devicetable.h>
17	#include <linux/log2.h>
18	#include <linux/bitops.h>	17	#include <linux/bitops.h>
19	#include <linux/jiffies.h>	18	#include <linux/jiffies.h>
20	#include <linux/property.h>	19	#include <linux/property.h>

drivers/watchdog/iTCO_wdt.c+24−2

 /* Includes */
 #include <linux/acpi.h>			/* For ACPI support */
+#include <linux/bits.h>			/* For BIT() */
 #include <linux/module.h>		/* For module specific items */
 #include <linux/moduleparam.h>		/* For new moduleparam's */
 #include <linux/types.h>		/* For standard types (like size_t) */
 	return 0;
 }
+static int update_no_reboot_bit_cnt(void *priv, bool set)
+{
+	struct iTCO_wdt_private *p = priv;
+	u16 val, newval;
+	val = inw(TCO1_CNT(p));
+	if (set)
+		val |= BIT(0);
+	else
+		val &= ~BIT(0);
+	outw(val, TCO1_CNT(p));
+	newval = inw(TCO1_CNT(p));
+	/* make sure the update is successful */
+	return val != newval ? -EIO : 0;
+}
 static void iTCO_wdt_no_reboot_bit_setup(struct iTCO_wdt_private *p,
 		struct itco_wdt_platform_data *pdata)
 {
 		return;
 	}
-	if (p->iTCO_version >= 2)
+	if (p->iTCO_version >= 6)
+		p->update_no_reboot_bit = update_no_reboot_bit_cnt;
+	else if (p->iTCO_version >= 2)
 		p->update_no_reboot_bit = update_no_reboot_bit_mem;
 	else if (p->iTCO_version == 1)
 		p->update_no_reboot_bit = update_no_reboot_bit_pci;
 	 * Get the Memory-Mapped GCS or PMC register, we need it for the
 	 * NO_REBOOT flag (TCO v2 and v3).
 	 */
-	if (p->iTCO_version >= 2 && !pdata->update_no_reboot_bit) {
+	if (p->iTCO_version >= 2 && p->iTCO_version < 6 &&
+	    !pdata->update_no_reboot_bit) {
 		p->gcs_pmc_res = platform_get_resource(pdev,
 						       IORESOURCE_MEM,
 						       ICH_RES_MEM_GCS_PMC);
 	/* Clear out the (probably old) status */
 	switch (p->iTCO_version) {
+	case 6:
 	case 5:
 	case 4:
 		outw(0x0008, TCO1_STS(p)); /* Clear the Time Out Status bit */

include/linux/i2c.h+1−1

@@ -473,7 +473,7 @@ extern struct i2c_client * · 472 unmodified lines
473	devm_i2c_new_dummy_device(struct device dev, struct i2c_adapter adap, u16 address);	473	devm_i2c_new_dummy_device(struct device dev, struct i2c_adapter adap, u16 address);
474		474
475	extern struct i2c_client *	475	extern struct i2c_client *
476	i2c_new_secondary_device(struct i2c_client *client,	476	i2c_new_ancillary_device(struct i2c_client *client,
477	const char *name,	477	const char *name,
478	u16 default_addr);	478	u16 default_addr);
479		479

Merge branch 'i2c/for-5.4' of git://git.kernel.org/pub/scm/linux/kernel/git/wsa/linux

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code