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 */
549void
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
577void
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);
599	if (ret)
600		goto out;
601	return 0;
 
 
602out:
603	return ret;
604}
605
606static int __devinit device_pca957x_init(struct pca953x_chip *chip, int invert)
607{
 
 
608	int ret;
609	uint16_t val = 0;
610
611	/* Let every port in proper state, that could save power */
612	pca953x_write_reg(chip, PCA957X_PUPD, 0x0);
613	pca953x_write_reg(chip, PCA957X_CFG, 0xffff);
614	pca953x_write_reg(chip, PCA957X_OUT, 0x0);
615
616	ret = pca953x_read_reg(chip, PCA957X_IN, &val);
617	if (ret)
618		goto out;
619	ret = pca953x_read_reg(chip, PCA957X_OUT, &chip->reg_output);
620	if (ret)
621		goto out;
622	ret = pca953x_read_reg(chip, PCA957X_CFG, &chip->reg_direction);
623	if (ret)
624		goto out;
625
626	/* set platform specific polarity inversion */
627	pca953x_write_reg(chip, PCA957X_INVRT, invert);
 
628
629	/* To enable register 6, 7 to controll pull up and pull down */
630	pca953x_write_reg(chip, PCA957X_BKEN, 0x202);
 
631
632	return 0;
633out:
634	return ret;
635}
636
637static int __devinit pca953x_probe(struct i2c_client *client,
638				   const struct i2c_device_id *id)
639{
640	struct pca953x_platform_data *pdata;
641	struct pca953x_chip *chip;
642	int irq_base=0, invert=0;
643	int ret = 0;
 
 
 
644
645	chip = kzalloc(sizeof(struct pca953x_chip), GFP_KERNEL);
646	if (chip == NULL)
647		return -ENOMEM;
648
649	pdata = client->dev.platform_data;
650	if (pdata) {
651		irq_base = pdata->irq_base;
652		chip->gpio_start = pdata->gpio_base;
653		invert = pdata->invert;
654		chip->names = pdata->names;
655	} else {
656		pca953x_get_alt_pdata(client, &chip->gpio_start, &invert);
657#ifdef CONFIG_OF_GPIO
658		/* If I2C node has no interrupts property, disable GPIO interrupts */
659		if (of_find_property(client->dev.of_node, "interrupts", NULL) == NULL)
660			irq_base = -1;
661#endif
 
 
 
 
 
 
 
 
 
 
662	}
663
664	chip->client = client;
665
666	chip->chip_type = id->driver_data & (PCA953X_TYPE | PCA957X_TYPE);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
667
668	mutex_init(&chip->i2c_lock);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
669
670	/* initialize cached registers from their original values.
671	 * we can't share this chip with another i2c master.
672	 */
673	pca953x_setup_gpio(chip, id->driver_data & PCA_GPIO_MASK);
674
675	if (chip->chip_type == PCA953X_TYPE)
676		device_pca953x_init(chip, invert);
677	else if (chip->chip_type == PCA957X_TYPE)
678		device_pca957x_init(chip, invert);
679	else
680		goto out_failed;
 
 
 
681
682	ret = pca953x_irq_setup(chip, id, irq_base);
683	if (ret)
684		goto out_failed;
685
686	ret = gpiochip_add(&chip->gpio_chip);
687	if (ret)
688		goto out_failed_irq;
689
690	if (pdata && pdata->setup) {
691		ret = pdata->setup(client, chip->gpio_chip.base,
692				chip->gpio_chip.ngpio, pdata->context);
693		if (ret < 0)
694			dev_warn(&client->dev, "setup failed, %d\n", ret);
695	}
696
697	i2c_set_clientdata(client, chip);
698	return 0;
699
700out_failed_irq:
701	pca953x_irq_teardown(chip);
702out_failed:
703	kfree(chip);
704	return ret;
705}
706
707static int pca953x_remove(struct i2c_client *client)
708{
709	struct pca953x_platform_data *pdata = client->dev.platform_data;
710	struct pca953x_chip *chip = i2c_get_clientdata(client);
711	int ret = 0;
712
713	if (pdata && pdata->teardown) {
714		ret = pdata->teardown(client, chip->gpio_chip.base,
715				chip->gpio_chip.ngpio, pdata->context);
716		if (ret < 0) {
717			dev_err(&client->dev, "%s failed, %d\n",
718					"teardown", ret);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
719			return ret;
720		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
721	}
722
723	ret = gpiochip_remove(&chip->gpio_chip);
 
 
 
 
 
 
724	if (ret) {
725		dev_err(&client->dev, "%s failed, %d\n",
726				"gpiochip_remove()", ret);
727		return ret;
728	}
729
730	pca953x_irq_teardown(chip);
731	kfree(chip);
732	return 0;
733}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
734
735static struct i2c_driver pca953x_driver = {
736	.driver = {
737		.name	= "pca953x",
 
 
 
738	},
739	.probe		= pca953x_probe,
740	.remove		= pca953x_remove,
741	.id_table	= pca953x_id,
742};
743
744static int __init pca953x_init(void)
745{
746	return i2c_add_driver(&pca953x_driver);
747}
748/* register after i2c postcore initcall and before
749 * subsys initcalls that may rely on these GPIOs
750 */
751subsys_initcall(pca953x_init);
752
753static void __exit pca953x_exit(void)
754{
755	i2c_del_driver(&pca953x_driver);
756}
757module_exit(pca953x_exit);
758
759MODULE_AUTHOR("eric miao <eric.miao@marvell.com>");
760MODULE_DESCRIPTION("GPIO expander driver for PCA953x");
761MODULE_LICENSE("GPL");