gpio-pca953x.c 32.3 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2
/*
3
 *  PCA953x 4/8/16/24/40 bit I/O ports
4
5
6
7
8
9
10
 *
 *  Copyright (C) 2005 Ben Gardner <bgardner@wabtec.com>
 *  Copyright (C) 2007 Marvell International Ltd.
 *
 *  Derived from drivers/i2c/chips/pca9539.c
 */

11
#include <linux/acpi.h>
12
#include <linux/gpio/driver.h>
13
#include <linux/gpio/consumer.h>
14
#include <linux/i2c.h>
15
16
17
18
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/of_platform.h>
19
#include <linux/platform_data/pca953x.h>
20
#include <linux/regmap.h>
21
#include <linux/regulator/consumer.h>
22
#include <linux/slab.h>
23

24
#include <asm/unaligned.h>
25

26
27
28
29
#define PCA953X_INPUT		0x00
#define PCA953X_OUTPUT		0x01
#define PCA953X_INVERT		0x02
#define PCA953X_DIRECTION	0x03
30

31
32
#define REG_ADDR_MASK		0x3f
#define REG_ADDR_EXT		0x40
33
34
#define REG_ADDR_AI		0x80

35
36
37
38
39
40
41
42
#define PCA957X_IN		0x00
#define PCA957X_INVRT		0x01
#define PCA957X_BKEN		0x02
#define PCA957X_PUPD		0x03
#define PCA957X_CFG		0x04
#define PCA957X_OUT		0x05
#define PCA957X_MSK		0x06
#define PCA957X_INTS		0x07
43

44
#define PCAL953X_OUT_STRENGTH	0x20
45
#define PCAL953X_IN_LATCH	0x22
46
47
#define PCAL953X_PULL_EN	0x23
#define PCAL953X_PULL_SEL	0x24
48
49
#define PCAL953X_INT_MASK	0x25
#define PCAL953X_INT_STAT	0x26
50
#define PCAL953X_OUT_CONF	0x27
51

52
53
54
55
56
57
#define PCAL6524_INT_EDGE	0x28
#define PCAL6524_INT_CLR	0x2a
#define PCAL6524_IN_STATUS	0x2b
#define PCAL6524_OUT_INDCONF	0x2c
#define PCAL6524_DEBOUNCE	0x2d

58
#define PCA_GPIO_MASK		0x00FF
59
60

#define PCAL_GPIO_MASK		0x1f
61
#define PCAL_PINCTRL_MASK	0x60
62

63
#define PCA_INT			0x0100
64
#define PCA_PCAL		0x0200
65
#define PCA_LATCH_INT		(PCA_PCAL | PCA_INT)
66
67
#define PCA953X_TYPE		0x1000
#define PCA957X_TYPE		0x2000
68
69
70
#define PCA_TYPE_MASK		0xF000

#define PCA_CHIP_TYPE(x)	((x) & PCA_TYPE_MASK)
71

72
static const struct i2c_device_id pca953x_id[] = {
73
	{ "pca6416", 16 | PCA953X_TYPE | PCA_INT, },
74
	{ "pca9505", 40 | PCA953X_TYPE | PCA_INT, },
75
76
77
78
79
80
81
82
83
84
85
86
	{ "pca9534", 8  | PCA953X_TYPE | PCA_INT, },
	{ "pca9535", 16 | PCA953X_TYPE | PCA_INT, },
	{ "pca9536", 4  | PCA953X_TYPE, },
	{ "pca9537", 4  | PCA953X_TYPE | PCA_INT, },
	{ "pca9538", 8  | PCA953X_TYPE | PCA_INT, },
	{ "pca9539", 16 | PCA953X_TYPE | PCA_INT, },
	{ "pca9554", 8  | PCA953X_TYPE | PCA_INT, },
	{ "pca9555", 16 | PCA953X_TYPE | PCA_INT, },
	{ "pca9556", 8  | PCA953X_TYPE, },
	{ "pca9557", 8  | PCA953X_TYPE, },
	{ "pca9574", 8  | PCA957X_TYPE | PCA_INT, },
	{ "pca9575", 16 | PCA957X_TYPE | PCA_INT, },
Aaron Sierra's avatar
Aaron Sierra committed
87
	{ "pca9698", 40 | PCA953X_TYPE, },
88

89
90
91
	{ "pcal6416", 16 | PCA953X_TYPE | PCA_LATCH_INT, },
	{ "pcal6524", 24 | PCA953X_TYPE | PCA_LATCH_INT, },
	{ "pcal9555a", 16 | PCA953X_TYPE | PCA_LATCH_INT, },
92

93
94
95
96
	{ "max7310", 8  | PCA953X_TYPE, },
	{ "max7312", 16 | PCA953X_TYPE | PCA_INT, },
	{ "max7313", 16 | PCA953X_TYPE | PCA_INT, },
	{ "max7315", 8  | PCA953X_TYPE | PCA_INT, },
97
	{ "max7318", 16 | PCA953X_TYPE | PCA_INT, },
98
99
100
	{ "pca6107", 8  | PCA953X_TYPE | PCA_INT, },
	{ "tca6408", 8  | PCA953X_TYPE | PCA_INT, },
	{ "tca6416", 16 | PCA953X_TYPE | PCA_INT, },
101
	{ "tca6424", 24 | PCA953X_TYPE | PCA_INT, },
102
	{ "tca9539", 16 | PCA953X_TYPE | PCA_INT, },
103
	{ "tca9554", 8  | PCA953X_TYPE | PCA_INT, },
Aaron Sierra's avatar
Aaron Sierra committed
104
	{ "xra1202", 8  | PCA953X_TYPE },
105
	{ }
106
};
107
MODULE_DEVICE_TABLE(i2c, pca953x_id);
108

109
static const struct acpi_device_id pca953x_acpi_ids[] = {
110
	{ "INT3491", 16 | PCA953X_TYPE | PCA_LATCH_INT, },
111
112
113
114
	{ }
};
MODULE_DEVICE_TABLE(acpi, pca953x_acpi_ids);

115
116
117
#define MAX_BANK 5
#define BANK_SZ 8

118
#define NBANK(chip) DIV_ROUND_UP(chip->gpio_chip.ngpio, BANK_SZ)
119

120
121
122
123
struct pca953x_reg_config {
	int direction;
	int output;
	int input;
124
	int invert;
125
126
127
128
129
130
};

static const struct pca953x_reg_config pca953x_regs = {
	.direction = PCA953X_DIRECTION,
	.output = PCA953X_OUTPUT,
	.input = PCA953X_INPUT,
131
	.invert = PCA953X_INVERT,
132
133
134
135
136
137
};

static const struct pca953x_reg_config pca957x_regs = {
	.direction = PCA957X_CFG,
	.output = PCA957X_OUT,
	.input = PCA957X_IN,
138
	.invert = PCA957X_INVRT,
139
140
};

141
struct pca953x_chip {
142
	unsigned gpio_start;
143
	struct mutex i2c_lock;
144
	struct regmap *regmap;
145

146
147
#ifdef CONFIG_GPIO_PCA953X_IRQ
	struct mutex irq_lock;
148
149
150
151
	u8 irq_mask[MAX_BANK];
	u8 irq_stat[MAX_BANK];
	u8 irq_trig_raise[MAX_BANK];
	u8 irq_trig_fall[MAX_BANK];
152
	struct irq_chip irq_chip;
153
#endif
154
	atomic_t wakeup_path;
155

156
157
	struct i2c_client *client;
	struct gpio_chip gpio_chip;
158
	const char *const *names;
159
	unsigned long driver_data;
160
	struct regulator *regulator;
161
162

	const struct pca953x_reg_config *regs;
163
164
};

165
static int pca953x_bank_shift(struct pca953x_chip *chip)
166
{
167
168
	return fls((chip->gpio_chip.ngpio - 1) / BANK_SZ);
}
169

170
171
172
173
#define PCA953x_BANK_INPUT	BIT(0)
#define PCA953x_BANK_OUTPUT	BIT(1)
#define PCA953x_BANK_POLARITY	BIT(2)
#define PCA953x_BANK_CONFIG	BIT(3)
174

175
176
177
178
179
180
181
#define PCA957x_BANK_INPUT	BIT(0)
#define PCA957x_BANK_POLARITY	BIT(1)
#define PCA957x_BANK_BUSHOLD	BIT(2)
#define PCA957x_BANK_CONFIG	BIT(4)
#define PCA957x_BANK_OUTPUT	BIT(5)

#define PCAL9xxx_BANK_IN_LATCH	BIT(8 + 2)
182
183
#define PCAL9xxx_BANK_PULL_EN	BIT(8 + 3)
#define PCAL9xxx_BANK_PULL_SEL	BIT(8 + 4)
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
#define PCAL9xxx_BANK_IRQ_MASK	BIT(8 + 5)
#define PCAL9xxx_BANK_IRQ_STAT	BIT(8 + 6)

/*
 * We care about the following registers:
 * - Standard set, below 0x40, each port can be replicated up to 8 times
 *   - PCA953x standard
 *     Input port			0x00 + 0 * bank_size	R
 *     Output port			0x00 + 1 * bank_size	RW
 *     Polarity Inversion port		0x00 + 2 * bank_size	RW
 *     Configuration port		0x00 + 3 * bank_size	RW
 *   - PCA957x with mixed up registers
 *     Input port			0x00 + 0 * bank_size	R
 *     Polarity Inversion port		0x00 + 1 * bank_size	RW
 *     Bus hold port			0x00 + 2 * bank_size	RW
 *     Configuration port		0x00 + 4 * bank_size	RW
 *     Output port			0x00 + 5 * bank_size	RW
 *
 * - Extended set, above 0x40, often chip specific.
 *   - PCAL6524/PCAL9555A with custom PCAL IRQ handling:
 *     Input latch register		0x40 + 2 * bank_size	RW
205
206
 *     Pull-up/pull-down enable reg	0x40 + 3 * bank_size    RW
 *     Pull-up/pull-down select reg	0x40 + 4 * bank_size    RW
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
 *     Interrupt mask register		0x40 + 5 * bank_size	RW
 *     Interrupt status register	0x40 + 6 * bank_size	R
 *
 * - Registers with bit 0x80 set, the AI bit
 *   The bit is cleared and the registers fall into one of the
 *   categories above.
 */

static bool pca953x_check_register(struct pca953x_chip *chip, unsigned int reg,
				   u32 checkbank)
{
	int bank_shift = pca953x_bank_shift(chip);
	int bank = (reg & REG_ADDR_MASK) >> bank_shift;
	int offset = reg & (BIT(bank_shift) - 1);

	/* Special PCAL extended register check. */
	if (reg & REG_ADDR_EXT) {
		if (!(chip->driver_data & PCA_PCAL))
			return false;
		bank += 8;
227
228
	}

229
230
231
232
233
234
235
236
237
	/* Register is not in the matching bank. */
	if (!(BIT(bank) & checkbank))
		return false;

	/* Register is not within allowed range of bank. */
	if (offset >= NBANK(chip))
		return false;

	return true;
238
239
}

240
static bool pca953x_readable_register(struct device *dev, unsigned int reg)
241
{
242
243
	struct pca953x_chip *chip = dev_get_drvdata(dev);
	u32 bank;
244

245
246
247
248
249
250
251
252
	if (PCA_CHIP_TYPE(chip->driver_data) == PCA953X_TYPE) {
		bank = PCA953x_BANK_INPUT | PCA953x_BANK_OUTPUT |
		       PCA953x_BANK_POLARITY | PCA953x_BANK_CONFIG;
	} else {
		bank = PCA957x_BANK_INPUT | PCA957x_BANK_OUTPUT |
		       PCA957x_BANK_POLARITY | PCA957x_BANK_CONFIG |
		       PCA957x_BANK_BUSHOLD;
	}
253

254
	if (chip->driver_data & PCA_PCAL) {
255
256
		bank |= PCAL9xxx_BANK_IN_LATCH | PCAL9xxx_BANK_PULL_EN |
			PCAL9xxx_BANK_PULL_SEL | PCAL9xxx_BANK_IRQ_MASK |
257
			PCAL9xxx_BANK_IRQ_STAT;
258
259
	}

260
	return pca953x_check_register(chip, reg, bank);
261
262
}

263
static bool pca953x_writeable_register(struct device *dev, unsigned int reg)
264
{
265
266
	struct pca953x_chip *chip = dev_get_drvdata(dev);
	u32 bank;
267

268
269
270
271
272
273
274
	if (PCA_CHIP_TYPE(chip->driver_data) == PCA953X_TYPE) {
		bank = PCA953x_BANK_OUTPUT | PCA953x_BANK_POLARITY |
			PCA953x_BANK_CONFIG;
	} else {
		bank = PCA957x_BANK_OUTPUT | PCA957x_BANK_POLARITY |
			PCA957x_BANK_CONFIG | PCA957x_BANK_BUSHOLD;
	}
275

276
	if (chip->driver_data & PCA_PCAL)
277
278
		bank |= PCAL9xxx_BANK_IN_LATCH | PCAL9xxx_BANK_PULL_EN |
			PCAL9xxx_BANK_PULL_SEL | PCAL9xxx_BANK_IRQ_MASK;
279
280

	return pca953x_check_register(chip, reg, bank);
281
282
}

283
static bool pca953x_volatile_register(struct device *dev, unsigned int reg)
284
{
285
286
	struct pca953x_chip *chip = dev_get_drvdata(dev);
	u32 bank;
287

288
289
290
291
292
293
294
	if (PCA_CHIP_TYPE(chip->driver_data) == PCA953X_TYPE)
		bank = PCA953x_BANK_INPUT;
	else
		bank = PCA957x_BANK_INPUT;

	if (chip->driver_data & PCA_PCAL)
		bank |= PCAL9xxx_BANK_IRQ_STAT;
295

296
	return pca953x_check_register(chip, reg, bank);
297
}
298

299
static const struct regmap_config pca953x_i2c_regmap = {
300
301
302
303
304
305
306
307
	.reg_bits = 8,
	.val_bits = 8,

	.readable_reg = pca953x_readable_register,
	.writeable_reg = pca953x_writeable_register,
	.volatile_reg = pca953x_volatile_register,

	.cache_type = REGCACHE_RBTREE,
308
309
	/* REVISIT: should be 0x7f but some 24 bit chips use REG_ADDR_AI */
	.max_register = 0xff,
310
311
};

312
313
static u8 pca953x_recalc_addr(struct pca953x_chip *chip, int reg, int off,
			      bool write, bool addrinc)
314
{
315
	int bank_shift = pca953x_bank_shift(chip);
316
317
	int addr = (reg & PCAL_GPIO_MASK) << bank_shift;
	int pinctrl = (reg & PCAL_PINCTRL_MASK) << 1;
318
319
320
321
322
323
324
325
326
	u8 regaddr = pinctrl | addr | (off / BANK_SZ);

	/* Single byte read doesn't need AI bit set. */
	if (!addrinc)
		return regaddr;

	/* Chips with 24 and more GPIOs always support Auto Increment */
	if (write && NBANK(chip) > 2)
		regaddr |= REG_ADDR_AI;
327

328
329
330
331
332
	/* PCA9575 needs address-increment on multi-byte writes */
	if (PCA_CHIP_TYPE(chip->driver_data) == PCA957X_TYPE)
		regaddr |= REG_ADDR_AI;

	return regaddr;
333
334
335
336
}

static int pca953x_write_regs(struct pca953x_chip *chip, int reg, u8 *val)
{
337
	u8 regaddr = pca953x_recalc_addr(chip, reg, 0, true, true);
338
	int ret;
339

340
	ret = regmap_bulk_write(chip->regmap, regaddr, val, NBANK(chip));
341
342
	if (ret < 0) {
		dev_err(&chip->client->dev, "failed writing register\n");
343
		return ret;
344
345
346
	}

	return 0;
347
348
}

349
350
static int pca953x_read_regs(struct pca953x_chip *chip, int reg, u8 *val)
{
351
	u8 regaddr = pca953x_recalc_addr(chip, reg, 0, false, true);
352
353
	int ret;

354
	ret = regmap_bulk_read(chip->regmap, regaddr, val, NBANK(chip));
355
356
	if (ret < 0) {
		dev_err(&chip->client->dev, "failed reading register\n");
357
		return ret;
358
359
360
361
362
	}

	return 0;
}

363
static int pca953x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
364
{
365
	struct pca953x_chip *chip = gpiochip_get_data(gc);
366
367
368
	u8 dirreg = pca953x_recalc_addr(chip, chip->regs->direction, off,
					true, false);
	u8 bit = BIT(off % BANK_SZ);
369
	int ret;
370

371
	mutex_lock(&chip->i2c_lock);
372
	ret = regmap_write_bits(chip->regmap, dirreg, bit, bit);
373
374
	mutex_unlock(&chip->i2c_lock);
	return ret;
375
376
}

377
static int pca953x_gpio_direction_output(struct gpio_chip *gc,
378
379
		unsigned off, int val)
{
380
	struct pca953x_chip *chip = gpiochip_get_data(gc);
381
382
	u8 dirreg = pca953x_recalc_addr(chip, chip->regs->direction, off,
					true, false);
383
384
	u8 outreg = pca953x_recalc_addr(chip, chip->regs->output, off,
					true, false);
385
	u8 bit = BIT(off % BANK_SZ);
386
	int ret;
387

388
	mutex_lock(&chip->i2c_lock);
389
	/* set output level */
390
	ret = regmap_write_bits(chip->regmap, outreg, bit, val ? bit : 0);
391
	if (ret)
392
		goto exit;
393
394

	/* then direction */
395
	ret = regmap_write_bits(chip->regmap, dirreg, bit, 0);
396
397
398
exit:
	mutex_unlock(&chip->i2c_lock);
	return ret;
399
400
}

401
static int pca953x_gpio_get_value(struct gpio_chip *gc, unsigned off)
402
{
403
	struct pca953x_chip *chip = gpiochip_get_data(gc);
404
405
406
	u8 inreg = pca953x_recalc_addr(chip, chip->regs->input, off,
				       true, false);
	u8 bit = BIT(off % BANK_SZ);
407
	u32 reg_val;
408
	int ret;
409

410
	mutex_lock(&chip->i2c_lock);
411
	ret = regmap_read(chip->regmap, inreg, &reg_val);
412
	mutex_unlock(&chip->i2c_lock);
413
414
415
416
417
418
419
420
	if (ret < 0) {
		/* NOTE:  diagnostic already emitted; that's all we should
		 * do unless gpio_*_value_cansleep() calls become different
		 * from their nonsleeping siblings (and report faults).
		 */
		return 0;
	}

421
	return !!(reg_val & bit);
422
423
}

424
static void pca953x_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
425
{
426
	struct pca953x_chip *chip = gpiochip_get_data(gc);
427
428
429
	u8 outreg = pca953x_recalc_addr(chip, chip->regs->output, off,
					true, false);
	u8 bit = BIT(off % BANK_SZ);
430

431
	mutex_lock(&chip->i2c_lock);
432
	regmap_write_bits(chip->regmap, outreg, bit, val ? bit : 0);
433
	mutex_unlock(&chip->i2c_lock);
434
435
}

436
437
438
static int pca953x_gpio_get_direction(struct gpio_chip *gc, unsigned off)
{
	struct pca953x_chip *chip = gpiochip_get_data(gc);
439
440
441
	u8 dirreg = pca953x_recalc_addr(chip, chip->regs->direction, off,
					true, false);
	u8 bit = BIT(off % BANK_SZ);
442
443
444
445
	u32 reg_val;
	int ret;

	mutex_lock(&chip->i2c_lock);
446
	ret = regmap_read(chip->regmap, dirreg, &reg_val);
447
448
449
450
	mutex_unlock(&chip->i2c_lock);
	if (ret < 0)
		return ret;

451
	return !!(reg_val & bit);
452
453
}

454
static void pca953x_gpio_set_multiple(struct gpio_chip *gc,
455
				      unsigned long *mask, unsigned long *bits)
456
{
457
	struct pca953x_chip *chip = gpiochip_get_data(gc);
458
	unsigned int bank_mask, bank_val;
459
	int bank;
460
	u8 reg_val[MAX_BANK];
461
	int ret;
462

463
	mutex_lock(&chip->i2c_lock);
464
465
466
467
	ret = pca953x_read_regs(chip, chip->regs->output, reg_val);
	if (ret)
		goto exit;

468
469
470
471
472
473
	for (bank = 0; bank < NBANK(chip); bank++) {
		bank_mask = mask[bank / sizeof(*mask)] >>
			   ((bank % sizeof(*mask)) * 8);
		if (bank_mask) {
			bank_val = bits[bank / sizeof(*bits)] >>
				  ((bank % sizeof(*bits)) * 8);
474
			bank_val &= bank_mask;
475
			reg_val[bank] = (reg_val[bank] & ~bank_mask) | bank_val;
476
477
		}
	}
478

479
	pca953x_write_regs(chip, chip->regs->output, reg_val);
480
481
482
483
exit:
	mutex_unlock(&chip->i2c_lock);
}

484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
static int pca953x_gpio_set_pull_up_down(struct pca953x_chip *chip,
					 unsigned int offset,
					 unsigned long config)
{
	u8 pull_en_reg = pca953x_recalc_addr(chip, PCAL953X_PULL_EN, offset,
					     true, false);
	u8 pull_sel_reg = pca953x_recalc_addr(chip, PCAL953X_PULL_SEL, offset,
					      true, false);
	u8 bit = BIT(offset % BANK_SZ);
	int ret;

	/*
	 * pull-up/pull-down configuration requires PCAL extended
	 * registers
	 */
	if (!(chip->driver_data & PCA_PCAL))
		return -ENOTSUPP;

	mutex_lock(&chip->i2c_lock);

	/* Disable pull-up/pull-down */
	ret = regmap_write_bits(chip->regmap, pull_en_reg, bit, 0);
	if (ret)
		goto exit;

	/* Configure pull-up/pull-down */
	if (config == PIN_CONFIG_BIAS_PULL_UP)
		ret = regmap_write_bits(chip->regmap, pull_sel_reg, bit, bit);
	else if (config == PIN_CONFIG_BIAS_PULL_DOWN)
		ret = regmap_write_bits(chip->regmap, pull_sel_reg, bit, 0);
	if (ret)
		goto exit;

	/* Enable pull-up/pull-down */
	ret = regmap_write_bits(chip->regmap, pull_en_reg, bit, bit);

exit:
	mutex_unlock(&chip->i2c_lock);
	return ret;
}

static int pca953x_gpio_set_config(struct gpio_chip *gc, unsigned int offset,
				   unsigned long config)
{
	struct pca953x_chip *chip = gpiochip_get_data(gc);

	switch (config) {
	case PIN_CONFIG_BIAS_PULL_UP:
	case PIN_CONFIG_BIAS_PULL_DOWN:
		return pca953x_gpio_set_pull_up_down(chip, offset, config);
	default:
		return -ENOTSUPP;
	}
}

539
static void pca953x_setup_gpio(struct pca953x_chip *chip, int gpios)
540
541
542
543
544
{
	struct gpio_chip *gc;

	gc = &chip->gpio_chip;

545
546
547
548
	gc->direction_input  = pca953x_gpio_direction_input;
	gc->direction_output = pca953x_gpio_direction_output;
	gc->get = pca953x_gpio_get_value;
	gc->set = pca953x_gpio_set_value;
549
	gc->get_direction = pca953x_gpio_get_direction;
550
	gc->set_multiple = pca953x_gpio_set_multiple;
551
	gc->set_config = pca953x_gpio_set_config;
552
	gc->can_sleep = true;
553
554

	gc->base = chip->gpio_start;
555
	gc->ngpio = gpios;
556
	gc->label = dev_name(&chip->client->dev);
557
	gc->parent = &chip->client->dev;
558
	gc->owner = THIS_MODULE;
559
	gc->names = chip->names;
560
561
}

562
#ifdef CONFIG_GPIO_PCA953X_IRQ
563
static void pca953x_irq_mask(struct irq_data *d)
564
{
565
	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
566
	struct pca953x_chip *chip = gpiochip_get_data(gc);
567

568
	chip->irq_mask[d->hwirq / BANK_SZ] &= ~(1 << (d->hwirq % BANK_SZ));
569
570
}

571
static void pca953x_irq_unmask(struct irq_data *d)
572
{
573
	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
574
	struct pca953x_chip *chip = gpiochip_get_data(gc);
575

576
	chip->irq_mask[d->hwirq / BANK_SZ] |= 1 << (d->hwirq % BANK_SZ);
577
578
}

579
580
581
582
583
static int pca953x_irq_set_wake(struct irq_data *d, unsigned int on)
{
	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
	struct pca953x_chip *chip = gpiochip_get_data(gc);

584
585
586
587
588
	if (on)
		atomic_inc(&chip->wakeup_path);
	else
		atomic_dec(&chip->wakeup_path);

589
590
591
	return irq_set_irq_wake(chip->client->irq, on);
}

592
static void pca953x_irq_bus_lock(struct irq_data *d)
593
{
594
	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
595
	struct pca953x_chip *chip = gpiochip_get_data(gc);
596
597
598
599

	mutex_lock(&chip->irq_lock);
}

600
static void pca953x_irq_bus_sync_unlock(struct irq_data *d)
601
{
602
	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
603
	struct pca953x_chip *chip = gpiochip_get_data(gc);
604
605
	u8 new_irqs;
	int level, i;
606
	u8 invert_irq_mask[MAX_BANK];
607
	u8 reg_direction[MAX_BANK];
608

609
	pca953x_read_regs(chip, chip->regs->direction, reg_direction);
610
611
612
613
614
615
616
617
618
619
620

	if (chip->driver_data & PCA_PCAL) {
		/* Enable latch on interrupt-enabled inputs */
		pca953x_write_regs(chip, PCAL953X_IN_LATCH, chip->irq_mask);

		for (i = 0; i < NBANK(chip); i++)
			invert_irq_mask[i] = ~chip->irq_mask[i];

		/* Unmask enabled interrupts */
		pca953x_write_regs(chip, PCAL953X_INT_MASK, invert_irq_mask);
	}
621
622

	/* Look for any newly setup interrupt */
623
624
	for (i = 0; i < NBANK(chip); i++) {
		new_irqs = chip->irq_trig_fall[i] | chip->irq_trig_raise[i];
625
		new_irqs &= reg_direction[i];
626
627
628
629
630
631
632

		while (new_irqs) {
			level = __ffs(new_irqs);
			pca953x_gpio_direction_input(&chip->gpio_chip,
							level + (BANK_SZ * i));
			new_irqs &= ~(1 << level);
		}
633
	}
634
635
636
637

	mutex_unlock(&chip->irq_lock);
}

638
static int pca953x_irq_set_type(struct irq_data *d, unsigned int type)
639
{
640
	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
641
	struct pca953x_chip *chip = gpiochip_get_data(gc);
642
643
	int bank_nb = d->hwirq / BANK_SZ;
	u8 mask = 1 << (d->hwirq % BANK_SZ);
644
645
646

	if (!(type & IRQ_TYPE_EDGE_BOTH)) {
		dev_err(&chip->client->dev, "irq %d: unsupported type %d\n",
647
			d->irq, type);
648
649
650
651
		return -EINVAL;
	}

	if (type & IRQ_TYPE_EDGE_FALLING)
652
		chip->irq_trig_fall[bank_nb] |= mask;
653
	else
654
		chip->irq_trig_fall[bank_nb] &= ~mask;
655
656

	if (type & IRQ_TYPE_EDGE_RISING)
657
		chip->irq_trig_raise[bank_nb] |= mask;
658
	else
659
		chip->irq_trig_raise[bank_nb] &= ~mask;
660

661
	return 0;
662
663
}

664
665
static void pca953x_irq_shutdown(struct irq_data *d)
{
666
667
	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
	struct pca953x_chip *chip = gpiochip_get_data(gc);
668
669
670
671
672
673
	u8 mask = 1 << (d->hwirq % BANK_SZ);

	chip->irq_trig_raise[d->hwirq / BANK_SZ] &= ~mask;
	chip->irq_trig_fall[d->hwirq / BANK_SZ] &= ~mask;
}

674
static bool pca953x_irq_pending(struct pca953x_chip *chip, u8 *pending)
675
{
676
677
	u8 cur_stat[MAX_BANK];
	u8 old_stat[MAX_BANK];
678
679
680
	bool pending_seen = false;
	bool trigger_seen = false;
	u8 trigger[MAX_BANK];
681
	u8 reg_direction[MAX_BANK];
682
	int ret, i;
683

684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
	if (chip->driver_data & PCA_PCAL) {
		/* Read the current interrupt status from the device */
		ret = pca953x_read_regs(chip, PCAL953X_INT_STAT, trigger);
		if (ret)
			return false;

		/* Check latched inputs and clear interrupt status */
		ret = pca953x_read_regs(chip, PCA953X_INPUT, cur_stat);
		if (ret)
			return false;

		for (i = 0; i < NBANK(chip); i++) {
			/* Apply filter for rising/falling edge selection */
			pending[i] = (~cur_stat[i] & chip->irq_trig_fall[i]) |
				(cur_stat[i] & chip->irq_trig_raise[i]);
			pending[i] &= trigger[i];
			if (pending[i])
				pending_seen = true;
		}

		return pending_seen;
	}

707
	ret = pca953x_read_regs(chip, chip->regs->input, cur_stat);
708
	if (ret)
709
		return false;
710
711

	/* Remove output pins from the equation */
712
	pca953x_read_regs(chip, chip->regs->direction, reg_direction);
713
	for (i = 0; i < NBANK(chip); i++)
714
		cur_stat[i] &= reg_direction[i];
715

716
	memcpy(old_stat, chip->irq_stat, NBANK(chip));
717

718
719
	for (i = 0; i < NBANK(chip); i++) {
		trigger[i] = (cur_stat[i] ^ old_stat[i]) & chip->irq_mask[i];
720
721
		if (trigger[i])
			trigger_seen = true;
722
723
	}

724
725
	if (!trigger_seen)
		return false;
726

727
	memcpy(chip->irq_stat, cur_stat, NBANK(chip));
728

729
730
731
732
	for (i = 0; i < NBANK(chip); i++) {
		pending[i] = (old_stat[i] & chip->irq_trig_fall[i]) |
			(cur_stat[i] & chip->irq_trig_raise[i]);
		pending[i] &= trigger[i];
733
734
		if (pending[i])
			pending_seen = true;
735
	}
736

737
	return pending_seen;
738
739
740
741
742
}

static irqreturn_t pca953x_irq_handler(int irq, void *devid)
{
	struct pca953x_chip *chip = devid;
743
744
	u8 pending[MAX_BANK];
	u8 level;
745
	unsigned nhandled = 0;
746
	int i;
747

748
	if (!pca953x_irq_pending(chip, pending))
749
		return IRQ_NONE;
750

751
752
753
	for (i = 0; i < NBANK(chip); i++) {
		while (pending[i]) {
			level = __ffs(pending[i]);
754
			handle_nested_irq(irq_find_mapping(chip->gpio_chip.irq.domain,
755
756
							level + (BANK_SZ * i)));
			pending[i] &= ~(1 << level);
757
			nhandled++;
758
759
		}
	}
760

761
	return (nhandled > 0) ? IRQ_HANDLED : IRQ_NONE;
762
763
764
}

static int pca953x_irq_setup(struct pca953x_chip *chip,
765
			     int irq_base)
766
767
{
	struct i2c_client *client = chip->client;
768
	struct irq_chip *irq_chip = &chip->irq_chip;
769
	u8 reg_direction[MAX_BANK];
770
	int ret, i;
771

772
773
	if (!client->irq)
		return 0;
774

775
776
	if (irq_base == -1)
		return 0;
777

778
779
	if (!(chip->driver_data & PCA_INT))
		return 0;
780

781
782
783
784
785
786
787
788
789
	ret = pca953x_read_regs(chip, chip->regs->input, chip->irq_stat);
	if (ret)
		return ret;

	/*
	 * There is no way to know which GPIO line generated the
	 * interrupt.  We have to rely on the previous read for
	 * this purpose.
	 */
790
	pca953x_read_regs(chip, chip->regs->direction, reg_direction);
791
792
793
794
795
796
797
798
799
800
801
802
803
	for (i = 0; i < NBANK(chip); i++)
		chip->irq_stat[i] &= reg_direction[i];
	mutex_init(&chip->irq_lock);

	ret = devm_request_threaded_irq(&client->dev, client->irq,
					NULL, pca953x_irq_handler,
					IRQF_TRIGGER_LOW | IRQF_ONESHOT |
					IRQF_SHARED,
					dev_name(&client->dev), chip);
	if (ret) {
		dev_err(&client->dev, "failed to request irq %d\n",
			client->irq);
		return ret;
804
805
	}

806
807
808
	irq_chip->name = dev_name(&chip->client->dev);
	irq_chip->irq_mask = pca953x_irq_mask;
	irq_chip->irq_unmask = pca953x_irq_unmask;
809
	irq_chip->irq_set_wake = pca953x_irq_set_wake;
810
811
812
813
814
815
	irq_chip->irq_bus_lock = pca953x_irq_bus_lock;
	irq_chip->irq_bus_sync_unlock = pca953x_irq_bus_sync_unlock;
	irq_chip->irq_set_type = pca953x_irq_set_type;
	irq_chip->irq_shutdown = pca953x_irq_shutdown;

	ret =  gpiochip_irqchip_add_nested(&chip->gpio_chip, irq_chip,
816
817
818
819
820
821
822
823
					   irq_base, handle_simple_irq,
					   IRQ_TYPE_NONE);
	if (ret) {
		dev_err(&client->dev,
			"could not connect irqchip to gpiochip\n");
		return ret;
	}

824
	gpiochip_set_nested_irqchip(&chip->gpio_chip, irq_chip, client->irq);
825

826
827
828
829
830
	return 0;
}

#else /* CONFIG_GPIO_PCA953X_IRQ */
static int pca953x_irq_setup(struct pca953x_chip *chip,
831
			     int irq_base)
832
833
834
{
	struct i2c_client *client = chip->client;

835
	if (client->irq && irq_base != -1 && (chip->driver_data & PCA_INT))
836
837
838
839
840
841
		dev_warn(&client->dev, "interrupt support not compiled in\n");

	return 0;
}
#endif

842
static int device_pca95xx_init(struct pca953x_chip *chip, u32 invert)
843
844
{
	int ret;
845
	u8 val[MAX_BANK];
846

847
848
849
	ret = regcache_sync_region(chip->regmap, chip->regs->output,
				   chip->regs->output + NBANK(chip));
	if (ret != 0)
850
851
		goto out;

852
853
854
	ret = regcache_sync_region(chip->regmap, chip->regs->direction,
				   chip->regs->direction + NBANK(chip));
	if (ret != 0)
855
856
857
		goto out;

	/* set platform specific polarity inversion */
858
859
860
861
862
	if (invert)
		memset(val, 0xFF, NBANK(chip));
	else
		memset(val, 0, NBANK(chip));

863
	ret = pca953x_write_regs(chip, chip->regs->invert, val);
864
865
866
867
out:
	return ret;
}

Bill Pemberton's avatar
Bill Pemberton committed
868
static int device_pca957x_init(struct pca953x_chip *chip, u32 invert)
869
870
{
	int ret;
871
	u8 val[MAX_BANK];
872

873
	ret = device_pca95xx_init(chip, invert);
874
875
	if (ret)
		goto out;
876

877
	/* To enable register 6, 7 to control pull up and pull down */
878
	memset(val, 0x02, NBANK(chip));
879
880
881
	ret = pca953x_write_regs(chip, PCA957X_BKEN, val);
	if (ret)
		goto out;
882
883
884
885
886
887

	return 0;
out:
	return ret;
}

888
889
static const struct of_device_id pca953x_dt_ids[];

Bill Pemberton's avatar
Bill Pemberton committed
890
static int pca953x_probe(struct i2c_client *client,
891
				   const struct i2c_device_id *i2c_id)
892
{
893
894
	struct pca953x_platform_data *pdata;
	struct pca953x_chip *chip;
895
	int irq_base = 0;
896
	int ret;
897
	u32 invert = 0;
898
	struct regulator *reg;
899

900
901
	chip = devm_kzalloc(&client->dev,
			sizeof(struct pca953x_chip), GFP_KERNEL);
902
903
904
	if (chip == NULL)
		return -ENOMEM;

Jingoo Han's avatar
Jingoo Han committed
905
	pdata = dev_get_platdata(&client->dev);
906
907
908
909
910
911
	if (pdata) {
		irq_base = pdata->irq_base;
		chip->gpio_start = pdata->gpio_base;
		invert = pdata->invert;
		chip->names = pdata->names;
	} else {
912
913
		struct gpio_desc *reset_gpio;

914
915
		chip->gpio_start = -1;
		irq_base = 0;
916

917
918
919
920
921
922
923
		/*
		 * See if we need to de-assert a reset pin.
		 *
		 * There is no known ACPI-enabled platforms that are
		 * using "reset" GPIO. Otherwise any of those platform
		 * must use _DSD method with corresponding property.
		 */
924
925
926
927
		reset_gpio = devm_gpiod_get_optional(&client->dev, "reset",
						     GPIOD_OUT_LOW);
		if (IS_ERR(reset_gpio))
			return PTR_ERR(reset_gpio);
928
	}
929
930
931

	chip->client = client;

932
933
934
935
936
937
938
939
940
941
942
943
944
945
	reg = devm_regulator_get(&client->dev, "vcc");
	if (IS_ERR(reg)) {
		ret = PTR_ERR(reg);
		if (ret != -EPROBE_DEFER)
			dev_err(&client->dev, "reg get err: %d\n", ret);
		return ret;
	}
	ret = regulator_enable(reg);
	if (ret) {
		dev_err(&client->dev, "reg en err: %d\n", ret);
		return ret;
	}
	chip->regulator = reg;

946
947
	if (i2c_id) {
		chip->driver_data = i2c_id->driver_data;
948
	} else {
949
		const struct acpi_device_id *acpi_id;
950
		struct device *dev = &client->dev;
951

952
953
954
		chip->driver_data = (uintptr_t)of_device_get_match_data(dev);
		if (!chip->driver_data) {
			acpi_id = acpi_match_device(pca953x_acpi_ids, dev);
955
			if (!acpi_id) {
956
957
958
				ret = -ENODEV;
				goto err_exit;
			}
959