gpio-pca953x.c revision 404ba2b8f611bea3228daf031f03901d0c34ecd7 
1/*
2 *  PCA953x 4/8/16 bit I/O ports
3 *
4 *  Copyright (C) 2005 Ben Gardner <bgardner@wabtec.com>
5 *  Copyright (C) 2007 Marvell International Ltd.
6 *
7 *  Derived from drivers/i2c/chips/pca9539.c
8 *
9 *  This program is free software; you can redistribute it and/or modify
10 *  it under the terms of the GNU General Public License as published by
11 *  the Free Software Foundation; version 2 of the License.
12 */
13
14#include <linux/module.h>
15#include <linux/init.h>
16#include <linux/gpio.h>
17#include <linux/interrupt.h>
18#include <linux/irq.h>
19#include <linux/i2c.h>
20#include <linux/i2c/pca953x.h>
21#include <linux/slab.h>
22#ifdef CONFIG_OF_GPIO
23#include <linux/of_platform.h>
24#endif
25
26#define PCA953X_INPUT		0
27#define PCA953X_OUTPUT		1
28#define PCA953X_INVERT		2
29#define PCA953X_DIRECTION	3
30
31#define PCA957X_IN		0
32#define PCA957X_INVRT		1
33#define PCA957X_BKEN		2
34#define PCA957X_PUPD		3
35#define PCA957X_CFG		4
36#define PCA957X_OUT		5
37#define PCA957X_MSK		6
38#define PCA957X_INTS		7
39
40#define PCA_GPIO_MASK		0x00FF
41#define PCA_INT			0x0100
42#define PCA953X_TYPE		0x1000
43#define PCA957X_TYPE		0x2000
44
45static const struct i2c_device_id pca953x_id[] = {
46	{ "pca9534", 8  | PCA953X_TYPE | PCA_INT, },
47	{ "pca9535", 16 | PCA953X_TYPE | PCA_INT, },
48	{ "pca9536", 4  | PCA953X_TYPE, },
49	{ "pca9537", 4  | PCA953X_TYPE | PCA_INT, },
50	{ "pca9538", 8  | PCA953X_TYPE | PCA_INT, },
51	{ "pca9539", 16 | PCA953X_TYPE | PCA_INT, },
52	{ "pca9554", 8  | PCA953X_TYPE | PCA_INT, },
53	{ "pca9555", 16 | PCA953X_TYPE | PCA_INT, },
54	{ "pca9556", 8  | PCA953X_TYPE, },
55	{ "pca9557", 8  | PCA953X_TYPE, },
56	{ "pca9574", 8  | PCA957X_TYPE | PCA_INT, },
57	{ "pca9575", 16 | PCA957X_TYPE | PCA_INT, },
58
59	{ "max7310", 8  | PCA953X_TYPE, },
60	{ "max7312", 16 | PCA953X_TYPE | PCA_INT, },
61	{ "max7313", 16 | PCA953X_TYPE | PCA_INT, },
62	{ "max7315", 8  | PCA953X_TYPE | PCA_INT, },
63	{ "pca6107", 8  | PCA953X_TYPE | PCA_INT, },
64	{ "tca6408", 8  | PCA953X_TYPE | PCA_INT, },
65	{ "tca6416", 16 | PCA953X_TYPE | PCA_INT, },
66	/* NYET:  { "tca6424", 24, }, */
67	{ }
68};
69MODULE_DEVICE_TABLE(i2c, pca953x_id);
70
71struct pca953x_chip {
72	unsigned gpio_start;
73	uint16_t reg_output;
74	uint16_t reg_direction;
75	struct mutex i2c_lock;
76
77#ifdef CONFIG_GPIO_PCA953X_IRQ
78	struct mutex irq_lock;
79	uint16_t irq_mask;
80	uint16_t irq_stat;
81	uint16_t irq_trig_raise;
82	uint16_t irq_trig_fall;
83	int	 irq_base;
84#endif
85
86	struct i2c_client *client;
87	struct gpio_chip gpio_chip;
88	const char *const *names;
89	int	chip_type;
90};
91
92static int pca953x_write_reg(struct pca953x_chip *chip, int reg, uint16_t val)
93{
94	int ret = 0;
95
96	if (chip->gpio_chip.ngpio <= 8)
97		ret = i2c_smbus_write_byte_data(chip->client, reg, val);
98	else {
99		switch (chip->chip_type) {
100		case PCA953X_TYPE:
101			ret = i2c_smbus_write_word_data(chip->client,
102							reg << 1, val);
103			break;
104		case PCA957X_TYPE:
105			ret = i2c_smbus_write_byte_data(chip->client, reg << 1,
106							val & 0xff);
107			if (ret < 0)
108				break;
109			ret = i2c_smbus_write_byte_data(chip->client,
110							(reg << 1) + 1,
111							(val & 0xff00) >> 8);
112			break;
113		}
114	}
115
116	if (ret < 0) {
117		dev_err(&chip->client->dev, "failed writing register\n");
118		return ret;
119	}
120
121	return 0;
122}
123
124static int pca953x_read_reg(struct pca953x_chip *chip, int reg, uint16_t *val)
125{
126	int ret;
127
128	if (chip->gpio_chip.ngpio <= 8)
129		ret = i2c_smbus_read_byte_data(chip->client, reg);
130	else
131		ret = i2c_smbus_read_word_data(chip->client, reg << 1);
132
133	if (ret < 0) {
134		dev_err(&chip->client->dev, "failed reading register\n");
135		return ret;
136	}
137
138	*val = (uint16_t)ret;
139	return 0;
140}
141
142static int pca953x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
143{
144	struct pca953x_chip *chip;
145	uint16_t reg_val;
146	int ret, offset = 0;
147
148	chip = container_of(gc, struct pca953x_chip, gpio_chip);
149
150	mutex_lock(&chip->i2c_lock);
151	reg_val = chip->reg_direction | (1u << off);
152
153	switch (chip->chip_type) {
154	case PCA953X_TYPE:
155		offset = PCA953X_DIRECTION;
156		break;
157	case PCA957X_TYPE:
158		offset = PCA957X_CFG;
159		break;
160	}
161	ret = pca953x_write_reg(chip, offset, reg_val);
162	if (ret)
163		goto exit;
164
165	chip->reg_direction = reg_val;
166	ret = 0;
167exit:
168	mutex_unlock(&chip->i2c_lock);
169	return ret;
170}
171
172static int pca953x_gpio_direction_output(struct gpio_chip *gc,
173		unsigned off, int val)
174{
175	struct pca953x_chip *chip;
176	uint16_t reg_val;
177	int ret, offset = 0;
178
179	chip = container_of(gc, struct pca953x_chip, gpio_chip);
180
181	mutex_lock(&chip->i2c_lock);
182	/* set output level */
183	if (val)
184		reg_val = chip->reg_output | (1u << off);
185	else
186		reg_val = chip->reg_output & ~(1u << off);
187
188	switch (chip->chip_type) {
189	case PCA953X_TYPE:
190		offset = PCA953X_OUTPUT;
191		break;
192	case PCA957X_TYPE:
193		offset = PCA957X_OUT;
194		break;
195	}
196	ret = pca953x_write_reg(chip, offset, reg_val);
197	if (ret)
198		goto exit;
199
200	chip->reg_output = reg_val;
201
202	/* then direction */
203	reg_val = chip->reg_direction & ~(1u << off);
204	switch (chip->chip_type) {
205	case PCA953X_TYPE:
206		offset = PCA953X_DIRECTION;
207		break;
208	case PCA957X_TYPE:
209		offset = PCA957X_CFG;
210		break;
211	}
212	ret = pca953x_write_reg(chip, offset, reg_val);
213	if (ret)
214		goto exit;
215
216	chip->reg_direction = reg_val;
217	ret = 0;
218exit:
219	mutex_unlock(&chip->i2c_lock);
220	return ret;
221}
222
223static int pca953x_gpio_get_value(struct gpio_chip *gc, unsigned off)
224{
225	struct pca953x_chip *chip;
226	uint16_t reg_val;
227	int ret, offset = 0;
228
229	chip = container_of(gc, struct pca953x_chip, gpio_chip);
230
231	mutex_lock(&chip->i2c_lock);
232	switch (chip->chip_type) {
233	case PCA953X_TYPE:
234		offset = PCA953X_INPUT;
235		break;
236	case PCA957X_TYPE:
237		offset = PCA957X_IN;
238		break;
239	}
240	ret = pca953x_read_reg(chip, offset, &reg_val);
241	mutex_unlock(&chip->i2c_lock);
242	if (ret < 0) {
243		/* NOTE:  diagnostic already emitted; that's all we should
244		 * do unless gpio_*_value_cansleep() calls become different
245		 * from their nonsleeping siblings (and report faults).
246		 */
247		return 0;
248	}
249
250	return (reg_val & (1u << off)) ? 1 : 0;
251}
252
253static void pca953x_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
254{
255	struct pca953x_chip *chip;
256	uint16_t reg_val;
257	int ret, offset = 0;
258
259	chip = container_of(gc, struct pca953x_chip, gpio_chip);
260
261	mutex_lock(&chip->i2c_lock);
262	if (val)
263		reg_val = chip->reg_output | (1u << off);
264	else
265		reg_val = chip->reg_output & ~(1u << off);
266
267	switch (chip->chip_type) {
268	case PCA953X_TYPE:
269		offset = PCA953X_OUTPUT;
270		break;
271	case PCA957X_TYPE:
272		offset = PCA957X_OUT;
273		break;
274	}
275	ret = pca953x_write_reg(chip, offset, reg_val);
276	if (ret)
277		goto exit;
278
279	chip->reg_output = reg_val;
280exit:
281	mutex_unlock(&chip->i2c_lock);
282}
283
284static void pca953x_setup_gpio(struct pca953x_chip *chip, int gpios)
285{
286	struct gpio_chip *gc;
287
288	gc = &chip->gpio_chip;
289
290	gc->direction_input  = pca953x_gpio_direction_input;
291	gc->direction_output = pca953x_gpio_direction_output;
292	gc->get = pca953x_gpio_get_value;
293	gc->set = pca953x_gpio_set_value;
294	gc->can_sleep = 1;
295
296	gc->base = chip->gpio_start;
297	gc->ngpio = gpios;
298	gc->label = chip->client->name;
299	gc->dev = &chip->client->dev;
300	gc->owner = THIS_MODULE;
301	gc->names = chip->names;
302}
303
304#ifdef CONFIG_GPIO_PCA953X_IRQ
305static int pca953x_gpio_to_irq(struct gpio_chip *gc, unsigned off)
306{
307	struct pca953x_chip *chip;
308
309	chip = container_of(gc, struct pca953x_chip, gpio_chip);
310	return chip->irq_base + off;
311}
312
313static void pca953x_irq_mask(struct irq_data *d)
314{
315	struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
316
317	chip->irq_mask &= ~(1 << (d->irq - chip->irq_base));
318}
319
320static void pca953x_irq_unmask(struct irq_data *d)
321{
322	struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
323
324	chip->irq_mask |= 1 << (d->irq - chip->irq_base);
325}
326
327static void pca953x_irq_bus_lock(struct irq_data *d)
328{
329	struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
330
331	mutex_lock(&chip->irq_lock);
332}
333
334static void pca953x_irq_bus_sync_unlock(struct irq_data *d)
335{
336	struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
337	uint16_t new_irqs;
338	uint16_t level;
339
340	/* Look for any newly setup interrupt */
341	new_irqs = chip->irq_trig_fall | chip->irq_trig_raise;
342	new_irqs &= ~chip->reg_direction;
343
344	while (new_irqs) {
345		level = __ffs(new_irqs);
346		pca953x_gpio_direction_input(&chip->gpio_chip, level);
347		new_irqs &= ~(1 << level);
348	}
349
350	mutex_unlock(&chip->irq_lock);
351}
352
353static int pca953x_irq_set_type(struct irq_data *d, unsigned int type)
354{
355	struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
356	uint16_t level = d->irq - chip->irq_base;
357	uint16_t mask = 1 << level;
358
359	if (!(type & IRQ_TYPE_EDGE_BOTH)) {
360		dev_err(&chip->client->dev, "irq %d: unsupported type %d\n",
361			d->irq, type);
362		return -EINVAL;
363	}
364
365	if (type & IRQ_TYPE_EDGE_FALLING)
366		chip->irq_trig_fall |= mask;
367	else
368		chip->irq_trig_fall &= ~mask;
369
370	if (type & IRQ_TYPE_EDGE_RISING)
371		chip->irq_trig_raise |= mask;
372	else
373		chip->irq_trig_raise &= ~mask;
374
375	return 0;
376}
377
378static struct irq_chip pca953x_irq_chip = {
379	.name			= "pca953x",
380	.irq_mask		= pca953x_irq_mask,
381	.irq_unmask		= pca953x_irq_unmask,
382	.irq_bus_lock		= pca953x_irq_bus_lock,
383	.irq_bus_sync_unlock	= pca953x_irq_bus_sync_unlock,
384	.irq_set_type		= pca953x_irq_set_type,
385};
386
387static uint16_t pca953x_irq_pending(struct pca953x_chip *chip)
388{
389	uint16_t cur_stat;
390	uint16_t old_stat;
391	uint16_t pending;
392	uint16_t trigger;
393	int ret, offset = 0;
394
395	switch (chip->chip_type) {
396	case PCA953X_TYPE:
397		offset = PCA953X_INPUT;
398		break;
399	case PCA957X_TYPE:
400		offset = PCA957X_IN;
401		break;
402	}
403	ret = pca953x_read_reg(chip, offset, &cur_stat);
404	if (ret)
405		return 0;
406
407	/* Remove output pins from the equation */
408	cur_stat &= chip->reg_direction;
409
410	old_stat = chip->irq_stat;
411	trigger = (cur_stat ^ old_stat) & chip->irq_mask;
412
413	if (!trigger)
414		return 0;
415
416	chip->irq_stat = cur_stat;
417
418	pending = (old_stat & chip->irq_trig_fall) |
419		  (cur_stat & chip->irq_trig_raise);
420	pending &= trigger;
421
422	return pending;
423}
424
425static irqreturn_t pca953x_irq_handler(int irq, void *devid)
426{
427	struct pca953x_chip *chip = devid;
428	uint16_t pending;
429	uint16_t level;
430
431	pending = pca953x_irq_pending(chip);
432
433	if (!pending)
434		return IRQ_HANDLED;
435
436	do {
437		level = __ffs(pending);
438		handle_nested_irq(level + chip->irq_base);
439
440		pending &= ~(1 << level);
441	} while (pending);
442
443	return IRQ_HANDLED;
444}
445
446static int pca953x_irq_setup(struct pca953x_chip *chip,
447			     const struct i2c_device_id *id,
448			     int irq_base)
449{
450	struct i2c_client *client = chip->client;
451	int ret, offset = 0;
452
453	if (irq_base != -1
454			&& (id->driver_data & PCA_INT)) {
455		int lvl;
456
457		switch (chip->chip_type) {
458		case PCA953X_TYPE:
459			offset = PCA953X_INPUT;
460			break;
461		case PCA957X_TYPE:
462			offset = PCA957X_IN;
463			break;
464		}
465		ret = pca953x_read_reg(chip, offset, &chip->irq_stat);
466		if (ret)
467			goto out_failed;
468
469		/*
470		 * There is no way to know which GPIO line generated the
471		 * interrupt.  We have to rely on the previous read for
472		 * this purpose.
473		 */
474		chip->irq_stat &= chip->reg_direction;
475		mutex_init(&chip->irq_lock);
476
477		chip->irq_base = irq_alloc_descs(-1, irq_base, chip->gpio_chip.ngpio, -1);
478		if (chip->irq_base < 0)
479			goto out_failed;
480
481		for (lvl = 0; lvl < chip->gpio_chip.ngpio; lvl++) {
482			int irq = lvl + chip->irq_base;
483
484			irq_clear_status_flags(irq, IRQ_NOREQUEST);
485			irq_set_chip_data(irq, chip);
486			irq_set_chip(irq, &pca953x_irq_chip);
487			irq_set_nested_thread(irq, true);
488#ifdef CONFIG_ARM
489			set_irq_flags(irq, IRQF_VALID);
490#else
491			irq_set_noprobe(irq);
492#endif
493		}
494
495		ret = request_threaded_irq(client->irq,
496					   NULL,
497					   pca953x_irq_handler,
498					   IRQF_TRIGGER_LOW | IRQF_ONESHOT,
499					   dev_name(&client->dev), chip);
500		if (ret) {
501			dev_err(&client->dev, "failed to request irq %d\n",
502				client->irq);
503			goto out_failed;
504		}
505
506		chip->gpio_chip.to_irq = pca953x_gpio_to_irq;
507	}
508
509	return 0;
510
511out_failed:
512	chip->irq_base = -1;
513	return ret;
514}
515
516static void pca953x_irq_teardown(struct pca953x_chip *chip)
517{
518	if (chip->irq_base != -1) {
519		irq_free_descs(chip->irq_base, chip->gpio_chip.ngpio);
520		free_irq(chip->client->irq, chip);
521	}
522}
523#else /* CONFIG_GPIO_PCA953X_IRQ */
524static int pca953x_irq_setup(struct pca953x_chip *chip,
525			     const struct i2c_device_id *id,
526			     int irq_base)
527{
528	struct i2c_client *client = chip->client;
529
530	if (irq_base != -1 && (id->driver_data & PCA_INT))
531		dev_warn(&client->dev, "interrupt support not compiled in\n");
532
533	return 0;
534}
535
536static void pca953x_irq_teardown(struct pca953x_chip *chip)
537{
538}
539#endif
540
541/*
542 * Handlers for alternative sources of platform_data
543 */
544#ifdef CONFIG_OF_GPIO
545/*
546 * Translate OpenFirmware node properties into platform_data
547 * WARNING: This is DEPRECATED and will be removed eventually!
548 */
549static void
550pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, int *invert)
551{
552	struct device_node *node;
553	const __be32 *val;
554	int size;
555
556	node = client->dev.of_node;
557	if (node == NULL)
558		return;
559
560	*gpio_base = -1;
561	val = of_get_property(node, "linux,gpio-base", &size);
562	WARN(val, "%s: device-tree property 'linux,gpio-base' is deprecated!", __func__);
563	if (val) {
564		if (size != sizeof(*val))
565			dev_warn(&client->dev, "%s: wrong linux,gpio-base\n",
566				 node->full_name);
567		else
568			*gpio_base = be32_to_cpup(val);
569	}
570
571	val = of_get_property(node, "polarity", NULL);
572	WARN(val, "%s: device-tree property 'polarity' is deprecated!", __func__);
573	if (val)
574		*invert = *val;
575}
576#else
577static void
578pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, int *invert)
579{
580	*gpio_base = -1;
581}
582#endif
583
584static int __devinit device_pca953x_init(struct pca953x_chip *chip, int invert)
585{
586	int ret;
587
588	ret = pca953x_read_reg(chip, PCA953X_OUTPUT, &chip->reg_output);
589	if (ret)
590		goto out;
591
592	ret = pca953x_read_reg(chip, PCA953X_DIRECTION,
593			       &chip->reg_direction);
594	if (ret)
595		goto out;
596
597	/* set platform specific polarity inversion */
598	ret = pca953x_write_reg(chip, PCA953X_INVERT, invert);
599out:
600	return ret;
601}
602
603static int __devinit device_pca957x_init(struct pca953x_chip *chip, int invert)
604{
605	int ret;
606	uint16_t val = 0;
607
608	/* Let every port in proper state, that could save power */
609	pca953x_write_reg(chip, PCA957X_PUPD, 0x0);
610	pca953x_write_reg(chip, PCA957X_CFG, 0xffff);
611	pca953x_write_reg(chip, PCA957X_OUT, 0x0);
612
613	ret = pca953x_read_reg(chip, PCA957X_IN, &val);
614	if (ret)
615		goto out;
616	ret = pca953x_read_reg(chip, PCA957X_OUT, &chip->reg_output);
617	if (ret)
618		goto out;
619	ret = pca953x_read_reg(chip, PCA957X_CFG, &chip->reg_direction);
620	if (ret)
621		goto out;
622
623	/* set platform specific polarity inversion */
624	pca953x_write_reg(chip, PCA957X_INVRT, invert);
625
626	/* To enable register 6, 7 to controll pull up and pull down */
627	pca953x_write_reg(chip, PCA957X_BKEN, 0x202);
628
629	return 0;
630out:
631	return ret;
632}
633
634static int __devinit pca953x_probe(struct i2c_client *client,
635				   const struct i2c_device_id *id)
636{
637	struct pca953x_platform_data *pdata;
638	struct pca953x_chip *chip;
639	int irq_base=0, invert=0;
640	int ret;
641
642	chip = kzalloc(sizeof(struct pca953x_chip), GFP_KERNEL);
643	if (chip == NULL)
644		return -ENOMEM;
645
646	pdata = client->dev.platform_data;
647	if (pdata) {
648		irq_base = pdata->irq_base;
649		chip->gpio_start = pdata->gpio_base;
650		invert = pdata->invert;
651		chip->names = pdata->names;
652	} else {
653		pca953x_get_alt_pdata(client, &chip->gpio_start, &invert);
654#ifdef CONFIG_OF_GPIO
655		/* If I2C node has no interrupts property, disable GPIO interrupts */
656		if (of_find_property(client->dev.of_node, "interrupts", NULL) == NULL)
657			irq_base = -1;
658#endif
659	}
660
661	chip->client = client;
662
663	chip->chip_type = id->driver_data & (PCA953X_TYPE | PCA957X_TYPE);
664
665	mutex_init(&chip->i2c_lock);
666
667	/* initialize cached registers from their original values.
668	 * we can't share this chip with another i2c master.
669	 */
670	pca953x_setup_gpio(chip, id->driver_data & PCA_GPIO_MASK);
671
672	if (chip->chip_type == PCA953X_TYPE)
673		ret = device_pca953x_init(chip, invert);
674	else
675		ret = device_pca957x_init(chip, invert);
676	if (ret)
677		goto out_failed;
678
679	ret = pca953x_irq_setup(chip, id, irq_base);
680	if (ret)
681		goto out_failed;
682
683	ret = gpiochip_add(&chip->gpio_chip);
684	if (ret)
685		goto out_failed_irq;
686
687	if (pdata && pdata->setup) {
688		ret = pdata->setup(client, chip->gpio_chip.base,
689				chip->gpio_chip.ngpio, pdata->context);
690		if (ret < 0)
691			dev_warn(&client->dev, "setup failed, %d\n", ret);
692	}
693
694	i2c_set_clientdata(client, chip);
695	return 0;
696
697out_failed_irq:
698	pca953x_irq_teardown(chip);
699out_failed:
700	kfree(chip);
701	return ret;
702}
703
704static int pca953x_remove(struct i2c_client *client)
705{
706	struct pca953x_platform_data *pdata = client->dev.platform_data;
707	struct pca953x_chip *chip = i2c_get_clientdata(client);
708	int ret = 0;
709
710	if (pdata && pdata->teardown) {
711		ret = pdata->teardown(client, chip->gpio_chip.base,
712				chip->gpio_chip.ngpio, pdata->context);
713		if (ret < 0) {
714			dev_err(&client->dev, "%s failed, %d\n",
715					"teardown", ret);
716			return ret;
717		}
718	}
719
720	ret = gpiochip_remove(&chip->gpio_chip);
721	if (ret) {
722		dev_err(&client->dev, "%s failed, %d\n",
723				"gpiochip_remove()", ret);
724		return ret;
725	}
726
727	pca953x_irq_teardown(chip);
728	kfree(chip);
729	return 0;
730}
731
732static struct i2c_driver pca953x_driver = {
733	.driver = {
734		.name	= "pca953x",
735	},
736	.probe		= pca953x_probe,
737	.remove		= pca953x_remove,
738	.id_table	= pca953x_id,
739};
740
741static int __init pca953x_init(void)
742{
743	return i2c_add_driver(&pca953x_driver);
744}
745/* register after i2c postcore initcall and before
746 * subsys initcalls that may rely on these GPIOs
747 */
748subsys_initcall(pca953x_init);
749
750static void __exit pca953x_exit(void)
751{
752	i2c_del_driver(&pca953x_driver);
753}
754module_exit(pca953x_exit);
755
756MODULE_AUTHOR("eric miao <eric.miao@marvell.com>");
757MODULE_DESCRIPTION("GPIO expander driver for PCA953x");
758MODULE_LICENSE("GPL");
759