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