stmfx.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Driver for STMicroelectronics Multi-Function eXpander (STMFX) core
  4 *
  5 * Copyright (C) 2019 STMicroelectronics
  6 * Author(s): Amelie Delaunay <amelie.delaunay@st.com>.
  7 */
  8#include <linux/bitfield.h>
  9#include <linux/i2c.h>
 10#include <linux/interrupt.h>
 11#include <linux/irq.h>
 12#include <linux/mfd/core.h>
 13#include <linux/mfd/stmfx.h>
 14#include <linux/module.h>
 15#include <linux/regulator/consumer.h>
 16
 17static bool stmfx_reg_volatile(struct device *dev, unsigned int reg)
 18{
 19	switch (reg) {
 20	case STMFX_REG_SYS_CTRL:
 21	case STMFX_REG_IRQ_SRC_EN:
 22	case STMFX_REG_IRQ_PENDING:
 23	case STMFX_REG_IRQ_GPI_PENDING1:
 24	case STMFX_REG_IRQ_GPI_PENDING2:
 25	case STMFX_REG_IRQ_GPI_PENDING3:
 26	case STMFX_REG_GPIO_STATE1:
 27	case STMFX_REG_GPIO_STATE2:
 28	case STMFX_REG_GPIO_STATE3:
 29	case STMFX_REG_IRQ_GPI_SRC1:
 30	case STMFX_REG_IRQ_GPI_SRC2:
 31	case STMFX_REG_IRQ_GPI_SRC3:
 32	case STMFX_REG_GPO_SET1:
 33	case STMFX_REG_GPO_SET2:
 34	case STMFX_REG_GPO_SET3:
 35	case STMFX_REG_GPO_CLR1:
 36	case STMFX_REG_GPO_CLR2:
 37	case STMFX_REG_GPO_CLR3:
 38		return true;
 39	default:
 40		return false;
 41	}
 42}
 43
 44static bool stmfx_reg_writeable(struct device *dev, unsigned int reg)
 45{
 46	return (reg >= STMFX_REG_SYS_CTRL);
 47}
 48
 49static const struct regmap_config stmfx_regmap_config = {
 50	.reg_bits	= 8,
 51	.reg_stride	= 1,
 52	.val_bits	= 8,
 53	.max_register	= STMFX_REG_MAX,
 54	.volatile_reg	= stmfx_reg_volatile,
 55	.writeable_reg	= stmfx_reg_writeable,
 56	.cache_type	= REGCACHE_MAPLE,
 57};
 58
 59static const struct resource stmfx_pinctrl_resources[] = {
 60	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_GPIO),
 61};
 62
 63static const struct resource stmfx_idd_resources[] = {
 64	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_IDD),
 65	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_ERROR),
 66};
 67
 68static const struct resource stmfx_ts_resources[] = {
 69	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_DET),
 70	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_NE),
 71	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_TH),
 72	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_FULL),
 73	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_OVF),
 74};
 75
 76static struct mfd_cell stmfx_cells[] = {
 77	{
 78		.of_compatible = "st,stmfx-0300-pinctrl",
 79		.name = "stmfx-pinctrl",
 80		.resources = stmfx_pinctrl_resources,
 81		.num_resources = ARRAY_SIZE(stmfx_pinctrl_resources),
 82	},
 83	{
 84		.of_compatible = "st,stmfx-0300-idd",
 85		.name = "stmfx-idd",
 86		.resources = stmfx_idd_resources,
 87		.num_resources = ARRAY_SIZE(stmfx_idd_resources),
 88	},
 89	{
 90		.of_compatible = "st,stmfx-0300-ts",
 91		.name = "stmfx-ts",
 92		.resources = stmfx_ts_resources,
 93		.num_resources = ARRAY_SIZE(stmfx_ts_resources),
 94	},
 95};
 96
 97static u8 stmfx_func_to_mask(u32 func)
 98{
 99	u8 mask = 0;
100
101	if (func & STMFX_FUNC_GPIO)
102		mask |= STMFX_REG_SYS_CTRL_GPIO_EN;
103
104	if ((func & STMFX_FUNC_ALTGPIO_LOW) || (func & STMFX_FUNC_ALTGPIO_HIGH))
105		mask |= STMFX_REG_SYS_CTRL_ALTGPIO_EN;
106
107	if (func & STMFX_FUNC_TS)
108		mask |= STMFX_REG_SYS_CTRL_TS_EN;
109
110	if (func & STMFX_FUNC_IDD)
111		mask |= STMFX_REG_SYS_CTRL_IDD_EN;
112
113	return mask;
114}
115
116int stmfx_function_enable(struct stmfx *stmfx, u32 func)
117{
118	u32 sys_ctrl;
119	u8 mask;
120	int ret;
121
122	ret = regmap_read(stmfx->map, STMFX_REG_SYS_CTRL, &sys_ctrl);
123	if (ret)
124		return ret;
125
126	/*
127	 * IDD and TS have priority in STMFX FW, so if IDD and TS are enabled,
128	 * ALTGPIO function is disabled by STMFX FW. If IDD or TS is enabled,
129	 * the number of aGPIO available decreases. To avoid GPIO management
130	 * disturbance, abort IDD or TS function enable in this case.
131	 */
132	if (((func & STMFX_FUNC_IDD) || (func & STMFX_FUNC_TS)) &&
133	    (sys_ctrl & STMFX_REG_SYS_CTRL_ALTGPIO_EN)) {
134		dev_err(stmfx->dev, "ALTGPIO function already enabled\n");
135		return -EBUSY;
136	}
137
138	/* If TS is enabled, aGPIO[3:0] cannot be used */
139	if ((func & STMFX_FUNC_ALTGPIO_LOW) &&
140	    (sys_ctrl & STMFX_REG_SYS_CTRL_TS_EN)) {
141		dev_err(stmfx->dev, "TS in use, aGPIO[3:0] unavailable\n");
142		return -EBUSY;
143	}
144
145	/* If IDD is enabled, aGPIO[7:4] cannot be used */
146	if ((func & STMFX_FUNC_ALTGPIO_HIGH) &&
147	    (sys_ctrl & STMFX_REG_SYS_CTRL_IDD_EN)) {
148		dev_err(stmfx->dev, "IDD in use, aGPIO[7:4] unavailable\n");
149		return -EBUSY;
150	}
151
152	mask = stmfx_func_to_mask(func);
153
154	return regmap_update_bits(stmfx->map, STMFX_REG_SYS_CTRL, mask, mask);
155}
156EXPORT_SYMBOL_GPL(stmfx_function_enable);
157
158int stmfx_function_disable(struct stmfx *stmfx, u32 func)
159{
160	u8 mask = stmfx_func_to_mask(func);
161
162	return regmap_update_bits(stmfx->map, STMFX_REG_SYS_CTRL, mask, 0);
163}
164EXPORT_SYMBOL_GPL(stmfx_function_disable);
165
166static void stmfx_irq_bus_lock(struct irq_data *data)
167{
168	struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
169
170	mutex_lock(&stmfx->lock);
171}
172
173static void stmfx_irq_bus_sync_unlock(struct irq_data *data)
174{
175	struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
176
177	regmap_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, stmfx->irq_src);
178
179	mutex_unlock(&stmfx->lock);
180}
181
182static void stmfx_irq_mask(struct irq_data *data)
183{
184	struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
185
186	stmfx->irq_src &= ~BIT(data->hwirq % 8);
187}
188
189static void stmfx_irq_unmask(struct irq_data *data)
190{
191	struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
192
193	stmfx->irq_src |= BIT(data->hwirq % 8);
194}
195
196static struct irq_chip stmfx_irq_chip = {
197	.name			= "stmfx-core",
198	.irq_bus_lock		= stmfx_irq_bus_lock,
199	.irq_bus_sync_unlock	= stmfx_irq_bus_sync_unlock,
200	.irq_mask		= stmfx_irq_mask,
201	.irq_unmask		= stmfx_irq_unmask,
202};
203
204static irqreturn_t stmfx_irq_handler(int irq, void *data)
205{
206	struct stmfx *stmfx = data;
207	unsigned long bits;
208	u32 pending, ack;
209	int n, ret;
210
211	ret = regmap_read(stmfx->map, STMFX_REG_IRQ_PENDING, &pending);
212	if (ret)
213		return IRQ_NONE;
214
215	/*
216	 * There is no ACK for GPIO, MFX_REG_IRQ_PENDING_GPIO is a logical OR
217	 * of MFX_REG_IRQ_GPI _PENDING1/_PENDING2/_PENDING3
218	 */
219	ack = pending & ~BIT(STMFX_REG_IRQ_SRC_EN_GPIO);
220	if (ack) {
221		ret = regmap_write(stmfx->map, STMFX_REG_IRQ_ACK, ack);
222		if (ret)
223			return IRQ_NONE;
224	}
225
226	bits = pending;
227	for_each_set_bit(n, &bits, STMFX_REG_IRQ_SRC_MAX)
228		handle_nested_irq(irq_find_mapping(stmfx->irq_domain, n));
229
230	return IRQ_HANDLED;
231}
232
233static int stmfx_irq_map(struct irq_domain *d, unsigned int virq,
234			 irq_hw_number_t hwirq)
235{
236	irq_set_chip_data(virq, d->host_data);
237	irq_set_chip_and_handler(virq, &stmfx_irq_chip, handle_simple_irq);
238	irq_set_nested_thread(virq, 1);
239	irq_set_noprobe(virq);
240
241	return 0;
242}
243
244static void stmfx_irq_unmap(struct irq_domain *d, unsigned int virq)
245{
246	irq_set_chip_and_handler(virq, NULL, NULL);
247	irq_set_chip_data(virq, NULL);
248}
249
250static const struct irq_domain_ops stmfx_irq_ops = {
251	.map	= stmfx_irq_map,
252	.unmap	= stmfx_irq_unmap,
253};
254
255static void stmfx_irq_exit(struct i2c_client *client)
256{
257	struct stmfx *stmfx = i2c_get_clientdata(client);
258	int hwirq;
259
260	for (hwirq = 0; hwirq < STMFX_REG_IRQ_SRC_MAX; hwirq++)
261		irq_dispose_mapping(irq_find_mapping(stmfx->irq_domain, hwirq));
262
263	irq_domain_remove(stmfx->irq_domain);
264}
265
266static int stmfx_irq_init(struct i2c_client *client)
267{
268	struct stmfx *stmfx = i2c_get_clientdata(client);
269	u32 irqoutpin = 0, irqtrigger;
270	int ret;
271
272	stmfx->irq_domain = irq_domain_create_simple(dev_fwnode(stmfx->dev), STMFX_REG_IRQ_SRC_MAX,
273						     0, &stmfx_irq_ops, stmfx);
274	if (!stmfx->irq_domain) {
275		dev_err(stmfx->dev, "Failed to create IRQ domain\n");
276		return -EINVAL;
277	}
278
279	if (!of_property_read_bool(stmfx->dev->of_node, "drive-open-drain"))
280		irqoutpin |= STMFX_REG_IRQ_OUT_PIN_TYPE;
281
282	irqtrigger = irq_get_trigger_type(client->irq);
283	if ((irqtrigger & IRQ_TYPE_EDGE_RISING) ||
284	    (irqtrigger & IRQ_TYPE_LEVEL_HIGH))
285		irqoutpin |= STMFX_REG_IRQ_OUT_PIN_POL;
286
287	ret = regmap_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN, irqoutpin);
288	if (ret)
289		goto irq_exit;
290
291	ret = devm_request_threaded_irq(stmfx->dev, client->irq,
292					NULL, stmfx_irq_handler,
293					irqtrigger | IRQF_ONESHOT,
294					"stmfx", stmfx);
295	if (ret)
296		goto irq_exit;
297
298	stmfx->irq = client->irq;
299
300	return 0;
301
302irq_exit:
303	stmfx_irq_exit(client);
304
305	return ret;
306}
307
308static int stmfx_chip_reset(struct stmfx *stmfx)
309{
310	int ret;
311
312	ret = regmap_write(stmfx->map, STMFX_REG_SYS_CTRL,
313			   STMFX_REG_SYS_CTRL_SWRST);
314	if (ret)
315		return ret;
316
317	msleep(STMFX_BOOT_TIME_MS);
318
319	return ret;
320}
321
322static int stmfx_chip_init(struct i2c_client *client)
323{
324	struct stmfx *stmfx = i2c_get_clientdata(client);
325	u32 id;
326	u8 version[2];
327	int ret;
328
329	stmfx->vdd = devm_regulator_get_optional(&client->dev, "vdd");
330	ret = PTR_ERR_OR_ZERO(stmfx->vdd);
331	if (ret) {
332		stmfx->vdd = NULL;
333		if (ret != -ENODEV)
334			return dev_err_probe(&client->dev, ret, "Failed to get VDD regulator\n");
335	}
336
337	if (stmfx->vdd) {
338		ret = regulator_enable(stmfx->vdd);
339		if (ret) {
340			dev_err(&client->dev, "VDD enable failed: %d\n", ret);
341			return ret;
342		}
343	}
344
345	ret = regmap_read(stmfx->map, STMFX_REG_CHIP_ID, &id);
346	if (ret) {
347		dev_err(&client->dev, "Error reading chip ID: %d\n", ret);
348		goto err;
349	}
350
351	/*
352	 * Check that ID is the complement of the I2C address:
353	 * STMFX I2C address follows the 7-bit format (MSB), that's why
354	 * client->addr is shifted.
355	 *
356	 * STMFX_I2C_ADDR|       STMFX         |        Linux
357	 *   input pin   | I2C device address  | I2C device address
358	 *---------------------------------------------------------
359	 *       0       | b: 1000 010x h:0x84 |       0x42
360	 *       1       | b: 1000 011x h:0x86 |       0x43
361	 */
362	if (FIELD_GET(STMFX_REG_CHIP_ID_MASK, ~id) != (client->addr << 1)) {
363		dev_err(&client->dev, "Unknown chip ID: %#x\n", id);
364		ret = -EINVAL;
365		goto err;
366	}
367
368	ret = regmap_bulk_read(stmfx->map, STMFX_REG_FW_VERSION_MSB,
369			       version, ARRAY_SIZE(version));
370	if (ret) {
371		dev_err(&client->dev, "Error reading FW version: %d\n", ret);
372		goto err;
373	}
374
375	dev_info(&client->dev, "STMFX id: %#x, fw version: %x.%02x\n",
376		 id, version[0], version[1]);
377
378	ret = stmfx_chip_reset(stmfx);
379	if (ret) {
380		dev_err(&client->dev, "Failed to reset chip: %d\n", ret);
381		goto err;
382	}
383
384	return 0;
385
386err:
387	if (stmfx->vdd)
388		regulator_disable(stmfx->vdd);
389
390	return ret;
391}
392
393static void stmfx_chip_exit(struct i2c_client *client)
394{
395	struct stmfx *stmfx = i2c_get_clientdata(client);
396
397	regmap_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, 0);
398	regmap_write(stmfx->map, STMFX_REG_SYS_CTRL, 0);
399
400	if (stmfx->vdd) {
401		int ret;
402
403		ret = regulator_disable(stmfx->vdd);
404		if (ret)
405			dev_err(&client->dev,
406				"Failed to disable vdd regulator: %pe\n",
407				ERR_PTR(ret));
408	}
409}
410
411static int stmfx_probe(struct i2c_client *client)
412{
413	struct device *dev = &client->dev;
414	struct stmfx *stmfx;
415	int ret;
416
417	stmfx = devm_kzalloc(dev, sizeof(*stmfx), GFP_KERNEL);
418	if (!stmfx)
419		return -ENOMEM;
420
421	i2c_set_clientdata(client, stmfx);
422
423	stmfx->dev = dev;
424
425	stmfx->map = devm_regmap_init_i2c(client, &stmfx_regmap_config);
426	if (IS_ERR(stmfx->map)) {
427		ret = PTR_ERR(stmfx->map);
428		dev_err(dev, "Failed to allocate register map: %d\n", ret);
429		return ret;
430	}
431
432	mutex_init(&stmfx->lock);
433
434	ret = stmfx_chip_init(client);
435	if (ret) {
436		if (ret == -ETIMEDOUT)
437			return -EPROBE_DEFER;
438		return ret;
439	}
440
441	if (client->irq < 0) {
442		dev_err(dev, "Failed to get IRQ: %d\n", client->irq);
443		ret = client->irq;
444		goto err_chip_exit;
445	}
446
447	ret = stmfx_irq_init(client);
448	if (ret)
449		goto err_chip_exit;
450
451	ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_NONE,
452				   stmfx_cells, ARRAY_SIZE(stmfx_cells), NULL,
453				   0, stmfx->irq_domain);
454	if (ret)
455		goto err_irq_exit;
456
457	return 0;
458
459err_irq_exit:
460	stmfx_irq_exit(client);
461err_chip_exit:
462	stmfx_chip_exit(client);
463
464	return ret;
465}
466
467static void stmfx_remove(struct i2c_client *client)
468{
469	stmfx_irq_exit(client);
470
471	stmfx_chip_exit(client);
472}
473
474static int stmfx_suspend(struct device *dev)
475{
476	struct stmfx *stmfx = dev_get_drvdata(dev);
477	int ret;
478
479	ret = regmap_raw_read(stmfx->map, STMFX_REG_SYS_CTRL,
480			      &stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl));
481	if (ret)
482		return ret;
483
484	ret = regmap_raw_read(stmfx->map, STMFX_REG_IRQ_OUT_PIN,
485			      &stmfx->bkp_irqoutpin,
486			      sizeof(stmfx->bkp_irqoutpin));
487	if (ret)
488		return ret;
489
490	disable_irq(stmfx->irq);
491
492	if (stmfx->vdd)
493		return regulator_disable(stmfx->vdd);
494
495	return 0;
496}
497
498static int stmfx_resume(struct device *dev)
499{
500	struct stmfx *stmfx = dev_get_drvdata(dev);
501	int ret;
502
503	if (stmfx->vdd) {
504		ret = regulator_enable(stmfx->vdd);
505		if (ret) {
506			dev_err(stmfx->dev,
507				"VDD enable failed: %d\n", ret);
508			return ret;
509		}
510	}
511
512	/* Reset STMFX - supply has been stopped during suspend */
513	ret = stmfx_chip_reset(stmfx);
514	if (ret) {
515		dev_err(stmfx->dev, "Failed to reset chip: %d\n", ret);
516		return ret;
517	}
518
519	ret = regmap_raw_write(stmfx->map, STMFX_REG_SYS_CTRL,
520			       &stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl));
521	if (ret)
522		return ret;
523
524	ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN,
525			       &stmfx->bkp_irqoutpin,
526			       sizeof(stmfx->bkp_irqoutpin));
527	if (ret)
528		return ret;
529
530	ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_SRC_EN,
531			       &stmfx->irq_src, sizeof(stmfx->irq_src));
532	if (ret)
533		return ret;
534
535	enable_irq(stmfx->irq);
536
537	return 0;
538}
539
540static DEFINE_SIMPLE_DEV_PM_OPS(stmfx_dev_pm_ops, stmfx_suspend, stmfx_resume);
541
542static const struct of_device_id stmfx_of_match[] = {
543	{ .compatible = "st,stmfx-0300", },
544	{},
545};
546MODULE_DEVICE_TABLE(of, stmfx_of_match);
547
548static struct i2c_driver stmfx_driver = {
549	.driver = {
550		.name = "stmfx-core",
551		.of_match_table = stmfx_of_match,
552		.pm = pm_sleep_ptr(&stmfx_dev_pm_ops),
553	},
554	.probe = stmfx_probe,
555	.remove = stmfx_remove,
556};
557module_i2c_driver(stmfx_driver);
558
559MODULE_DESCRIPTION("STMFX core driver");
560MODULE_AUTHOR("Amelie Delaunay <amelie.delaunay@st.com>");
561MODULE_LICENSE("GPL v2");