projects / deliverable / linux.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Merge tag 'v4.6-rc1' into for-linus-4.6
[deliverable/linux.git] / drivers / gpio / gpio-pca953x.c
... / ...
CommitLineData
1/*
2 * PCA953x 4/8/16/24/40 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/i2c.h>
19#include <linux/platform_data/pca953x.h>
20#include <linux/slab.h>
21#include <linux/of_platform.h>
22#include <linux/acpi.h>
23
24#define PCA953X_INPUT 0
25#define PCA953X_OUTPUT 1
26#define PCA953X_INVERT 2
27#define PCA953X_DIRECTION 3
28
29#define REG_ADDR_AI 0x80
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#define PCA_TYPE_MASK 0xF000
45
46#define PCA_CHIP_TYPE(x) ((x) & PCA_TYPE_MASK)
47
48static const struct i2c_device_id pca953x_id[] = {
49 { "pca9505", 40 | PCA953X_TYPE | PCA_INT, },
50 { "pca9534", 8 | PCA953X_TYPE | PCA_INT, },
51 { "pca9535", 16 | PCA953X_TYPE | PCA_INT, },
52 { "pca9536", 4 | PCA953X_TYPE, },
53 { "pca9537", 4 | PCA953X_TYPE | PCA_INT, },
54 { "pca9538", 8 | PCA953X_TYPE | PCA_INT, },
55 { "pca9539", 16 | PCA953X_TYPE | PCA_INT, },
56 { "pca9554", 8 | PCA953X_TYPE | PCA_INT, },
57 { "pca9555", 16 | PCA953X_TYPE | PCA_INT, },
58 { "pca9556", 8 | PCA953X_TYPE, },
59 { "pca9557", 8 | PCA953X_TYPE, },
60 { "pca9574", 8 | PCA957X_TYPE | PCA_INT, },
61 { "pca9575", 16 | PCA957X_TYPE | PCA_INT, },
62 { "pca9698", 40 | PCA953X_TYPE, },
63
64 { "max7310", 8 | PCA953X_TYPE, },
65 { "max7312", 16 | PCA953X_TYPE | PCA_INT, },
66 { "max7313", 16 | PCA953X_TYPE | PCA_INT, },
67 { "max7315", 8 | PCA953X_TYPE | PCA_INT, },
68 { "pca6107", 8 | PCA953X_TYPE | PCA_INT, },
69 { "tca6408", 8 | PCA953X_TYPE | PCA_INT, },
70 { "tca6416", 16 | PCA953X_TYPE | PCA_INT, },
71 { "tca6424", 24 | PCA953X_TYPE | PCA_INT, },
72 { "tca9539", 16 | PCA953X_TYPE | PCA_INT, },
73 { "xra1202", 8 | PCA953X_TYPE },
74 { }
75};
76MODULE_DEVICE_TABLE(i2c, pca953x_id);
77
78static const struct acpi_device_id pca953x_acpi_ids[] = {
79 { "INT3491", 16 | PCA953X_TYPE | PCA_INT, },
80 { }
81};
82MODULE_DEVICE_TABLE(acpi, pca953x_acpi_ids);
83
84#define MAX_BANK 5
85#define BANK_SZ 8
86
87#define NBANK(chip) (chip->gpio_chip.ngpio / BANK_SZ)
88
89struct pca953x_chip {
90 unsigned gpio_start;
91 u8 reg_output[MAX_BANK];
92 u8 reg_direction[MAX_BANK];
93 struct mutex i2c_lock;
94
95#ifdef CONFIG_GPIO_PCA953X_IRQ
96 struct mutex irq_lock;
97 u8 irq_mask[MAX_BANK];
98 u8 irq_stat[MAX_BANK];
99 u8 irq_trig_raise[MAX_BANK];
100 u8 irq_trig_fall[MAX_BANK];
101#endif
102
103 struct i2c_client *client;
104 struct gpio_chip gpio_chip;
105 const char *const *names;
106 int chip_type;
107 unsigned long driver_data;
108};
109
110static int pca953x_read_single(struct pca953x_chip *chip, int reg, u32 *val,
111 int off)
112{
113 int ret;
114 int bank_shift = fls((chip->gpio_chip.ngpio - 1) / BANK_SZ);
115 int offset = off / BANK_SZ;
116
117 ret = i2c_smbus_read_byte_data(chip->client,
118 (reg << bank_shift) + offset);
119 *val = ret;
120
121 if (ret < 0) {
122 dev_err(&chip->client->dev, "failed reading register\n");
123 return ret;
124 }
125
126 return 0;
127}
128
129static int pca953x_write_single(struct pca953x_chip *chip, int reg, u32 val,
130 int off)
131{
132 int ret = 0;
133 int bank_shift = fls((chip->gpio_chip.ngpio - 1) / BANK_SZ);
134 int offset = off / BANK_SZ;
135
136 ret = i2c_smbus_write_byte_data(chip->client,
137 (reg << bank_shift) + offset, val);
138
139 if (ret < 0) {
140 dev_err(&chip->client->dev, "failed writing register\n");
141 return ret;
142 }
143
144 return 0;
145}
146
147static int pca953x_write_regs(struct pca953x_chip *chip, int reg, u8 *val)
148{
149 int ret = 0;
150
151 if (chip->gpio_chip.ngpio <= 8)
152 ret = i2c_smbus_write_byte_data(chip->client, reg, *val);
153 else if (chip->gpio_chip.ngpio >= 24) {
154 int bank_shift = fls((chip->gpio_chip.ngpio - 1) / BANK_SZ);
155 ret = i2c_smbus_write_i2c_block_data(chip->client,
156 (reg << bank_shift) | REG_ADDR_AI,
157 NBANK(chip), val);
158 } else {
159 switch (chip->chip_type) {
160 case PCA953X_TYPE:
161 ret = i2c_smbus_write_word_data(chip->client,
162 reg << 1, (u16) *val);
163 break;
164 case PCA957X_TYPE:
165 ret = i2c_smbus_write_byte_data(chip->client, reg << 1,
166 val[0]);
167 if (ret < 0)
168 break;
169 ret = i2c_smbus_write_byte_data(chip->client,
170 (reg << 1) + 1,
171 val[1]);
172 break;
173 }
174 }
175
176 if (ret < 0) {
177 dev_err(&chip->client->dev, "failed writing register\n");
178 return ret;
179 }
180
181 return 0;
182}
183
184static int pca953x_read_regs(struct pca953x_chip *chip, int reg, u8 *val)
185{
186 int ret;
187
188 if (chip->gpio_chip.ngpio <= 8) {
189 ret = i2c_smbus_read_byte_data(chip->client, reg);
190 *val = ret;
191 } else if (chip->gpio_chip.ngpio >= 24) {
192 int bank_shift = fls((chip->gpio_chip.ngpio - 1) / BANK_SZ);
193
194 ret = i2c_smbus_read_i2c_block_data(chip->client,
195 (reg << bank_shift) | REG_ADDR_AI,
196 NBANK(chip), val);
197 } else {
198 ret = i2c_smbus_read_word_data(chip->client, reg << 1);
199 val[0] = (u16)ret & 0xFF;
200 val[1] = (u16)ret >> 8;
201 }
202 if (ret < 0) {
203 dev_err(&chip->client->dev, "failed reading register\n");
204 return ret;
205 }
206
207 return 0;
208}
209
210static int pca953x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
211{
212 struct pca953x_chip *chip = gpiochip_get_data(gc);
213 u8 reg_val;
214 int ret, offset = 0;
215
216 mutex_lock(&chip->i2c_lock);
217 reg_val = chip->reg_direction[off / BANK_SZ] | (1u << (off % BANK_SZ));
218
219 switch (chip->chip_type) {
220 case PCA953X_TYPE:
221 offset = PCA953X_DIRECTION;
222 break;
223 case PCA957X_TYPE:
224 offset = PCA957X_CFG;
225 break;
226 }
227 ret = pca953x_write_single(chip, offset, reg_val, off);
228 if (ret)
229 goto exit;
230
231 chip->reg_direction[off / BANK_SZ] = reg_val;
232 ret = 0;
233exit:
234 mutex_unlock(&chip->i2c_lock);
235 return ret;
236}
237
238static int pca953x_gpio_direction_output(struct gpio_chip *gc,
239 unsigned off, int val)
240{
241 struct pca953x_chip *chip = gpiochip_get_data(gc);
242 u8 reg_val;
243 int ret, offset = 0;
244
245 mutex_lock(&chip->i2c_lock);
246 /* set output level */
247 if (val)
248 reg_val = chip->reg_output[off / BANK_SZ]
249 | (1u << (off % BANK_SZ));
250 else
251 reg_val = chip->reg_output[off / BANK_SZ]
252 & ~(1u << (off % BANK_SZ));
253
254 switch (chip->chip_type) {
255 case PCA953X_TYPE:
256 offset = PCA953X_OUTPUT;
257 break;
258 case PCA957X_TYPE:
259 offset = PCA957X_OUT;
260 break;
261 }
262 ret = pca953x_write_single(chip, offset, reg_val, off);
263 if (ret)
264 goto exit;
265
266 chip->reg_output[off / BANK_SZ] = reg_val;
267
268 /* then direction */
269 reg_val = chip->reg_direction[off / BANK_SZ] & ~(1u << (off % BANK_SZ));
270 switch (chip->chip_type) {
271 case PCA953X_TYPE:
272 offset = PCA953X_DIRECTION;
273 break;
274 case PCA957X_TYPE:
275 offset = PCA957X_CFG;
276 break;
277 }
278 ret = pca953x_write_single(chip, offset, reg_val, off);
279 if (ret)
280 goto exit;
281
282 chip->reg_direction[off / BANK_SZ] = reg_val;
283 ret = 0;
284exit:
285 mutex_unlock(&chip->i2c_lock);
286 return ret;
287}
288
289static int pca953x_gpio_get_value(struct gpio_chip *gc, unsigned off)
290{
291 struct pca953x_chip *chip = gpiochip_get_data(gc);
292 u32 reg_val;
293 int ret, offset = 0;
294
295 mutex_lock(&chip->i2c_lock);
296 switch (chip->chip_type) {
297 case PCA953X_TYPE:
298 offset = PCA953X_INPUT;
299 break;
300 case PCA957X_TYPE:
301 offset = PCA957X_IN;
302 break;
303 }
304 ret = pca953x_read_single(chip, offset, &reg_val, off);
305 mutex_unlock(&chip->i2c_lock);
306 if (ret < 0) {
307 /* NOTE: diagnostic already emitted; that's all we should
308 * do unless gpio_*_value_cansleep() calls become different
309 * from their nonsleeping siblings (and report faults).
310 */
311 return 0;
312 }
313
314 return (reg_val & (1u << (off % BANK_SZ))) ? 1 : 0;
315}
316
317static void pca953x_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
318{
319 struct pca953x_chip *chip = gpiochip_get_data(gc);
320 u8 reg_val;
321 int ret, offset = 0;
322
323 mutex_lock(&chip->i2c_lock);
324 if (val)
325 reg_val = chip->reg_output[off / BANK_SZ]
326 | (1u << (off % BANK_SZ));
327 else
328 reg_val = chip->reg_output[off / BANK_SZ]
329 & ~(1u << (off % BANK_SZ));
330
331 switch (chip->chip_type) {
332 case PCA953X_TYPE:
333 offset = PCA953X_OUTPUT;
334 break;
335 case PCA957X_TYPE:
336 offset = PCA957X_OUT;
337 break;
338 }
339 ret = pca953x_write_single(chip, offset, reg_val, off);
340 if (ret)
341 goto exit;
342
343 chip->reg_output[off / BANK_SZ] = reg_val;
344exit:
345 mutex_unlock(&chip->i2c_lock);
346}
347
348
349static void pca953x_gpio_set_multiple(struct gpio_chip *gc,
350 unsigned long *mask, unsigned long *bits)
351{
352 struct pca953x_chip *chip = gpiochip_get_data(gc);
353 u8 reg_val[MAX_BANK];
354 int ret, offset = 0;
355 int bank_shift = fls((chip->gpio_chip.ngpio - 1) / BANK_SZ);
356 int bank;
357
358 switch (chip->chip_type) {
359 case PCA953X_TYPE:
360 offset = PCA953X_OUTPUT;
361 break;
362 case PCA957X_TYPE:
363 offset = PCA957X_OUT;
364 break;
365 }
366
367 memcpy(reg_val, chip->reg_output, NBANK(chip));
368 mutex_lock(&chip->i2c_lock);
369 for(bank=0; bank<NBANK(chip); bank++) {
370 unsigned bankmask = mask[bank / sizeof(*mask)] >>
371 ((bank % sizeof(*mask)) * 8);
372 if(bankmask) {
373 unsigned bankval = bits[bank / sizeof(*bits)] >>
374 ((bank % sizeof(*bits)) * 8);
375 reg_val[bank] = (reg_val[bank] & ~bankmask) | bankval;
376 }
377 }
378 ret = i2c_smbus_write_i2c_block_data(chip->client, offset << bank_shift, NBANK(chip), reg_val);
379 if (ret)
380 goto exit;
381
382 memcpy(chip->reg_output, reg_val, NBANK(chip));
383exit:
384 mutex_unlock(&chip->i2c_lock);
385}
386
387static void pca953x_setup_gpio(struct pca953x_chip *chip, int gpios)
388{
389 struct gpio_chip *gc;
390
391 gc = &chip->gpio_chip;
392
393 gc->direction_input = pca953x_gpio_direction_input;
394 gc->direction_output = pca953x_gpio_direction_output;
395 gc->get = pca953x_gpio_get_value;
396 gc->set = pca953x_gpio_set_value;
397 gc->set_multiple = pca953x_gpio_set_multiple;
398 gc->can_sleep = true;
399
400 gc->base = chip->gpio_start;
401 gc->ngpio = gpios;
402 gc->label = chip->client->name;
403 gc->parent = &chip->client->dev;
404 gc->owner = THIS_MODULE;
405 gc->names = chip->names;
406}
407
408#ifdef CONFIG_GPIO_PCA953X_IRQ
409static void pca953x_irq_mask(struct irq_data *d)
410{
411 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
412 struct pca953x_chip *chip = gpiochip_get_data(gc);
413
414 chip->irq_mask[d->hwirq / BANK_SZ] &= ~(1 << (d->hwirq % BANK_SZ));
415}
416
417static void pca953x_irq_unmask(struct irq_data *d)
418{
419 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
420 struct pca953x_chip *chip = gpiochip_get_data(gc);
421
422 chip->irq_mask[d->hwirq / BANK_SZ] |= 1 << (d->hwirq % BANK_SZ);
423}
424
425static void pca953x_irq_bus_lock(struct irq_data *d)
426{
427 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
428 struct pca953x_chip *chip = gpiochip_get_data(gc);
429
430 mutex_lock(&chip->irq_lock);
431}
432
433static void pca953x_irq_bus_sync_unlock(struct irq_data *d)
434{
435 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
436 struct pca953x_chip *chip = gpiochip_get_data(gc);
437 u8 new_irqs;
438 int level, i;
439
440 /* Look for any newly setup interrupt */
441 for (i = 0; i < NBANK(chip); i++) {
442 new_irqs = chip->irq_trig_fall[i] | chip->irq_trig_raise[i];
443 new_irqs &= ~chip->reg_direction[i];
444
445 while (new_irqs) {
446 level = __ffs(new_irqs);
447 pca953x_gpio_direction_input(&chip->gpio_chip,
448 level + (BANK_SZ * i));
449 new_irqs &= ~(1 << level);
450 }
451 }
452
453 mutex_unlock(&chip->irq_lock);
454}
455
456static int pca953x_irq_set_type(struct irq_data *d, unsigned int type)
457{
458 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
459 struct pca953x_chip *chip = gpiochip_get_data(gc);
460 int bank_nb = d->hwirq / BANK_SZ;
461 u8 mask = 1 << (d->hwirq % BANK_SZ);
462
463 if (!(type & IRQ_TYPE_EDGE_BOTH)) {
464 dev_err(&chip->client->dev, "irq %d: unsupported type %d\n",
465 d->irq, type);
466 return -EINVAL;
467 }
468
469 if (type & IRQ_TYPE_EDGE_FALLING)
470 chip->irq_trig_fall[bank_nb] |= mask;
471 else
472 chip->irq_trig_fall[bank_nb] &= ~mask;
473
474 if (type & IRQ_TYPE_EDGE_RISING)
475 chip->irq_trig_raise[bank_nb] |= mask;
476 else
477 chip->irq_trig_raise[bank_nb] &= ~mask;
478
479 return 0;
480}
481
482static struct irq_chip pca953x_irq_chip = {
483 .name = "pca953x",
484 .irq_mask = pca953x_irq_mask,
485 .irq_unmask = pca953x_irq_unmask,
486 .irq_bus_lock = pca953x_irq_bus_lock,
487 .irq_bus_sync_unlock = pca953x_irq_bus_sync_unlock,
488 .irq_set_type = pca953x_irq_set_type,
489};
490
491static bool pca953x_irq_pending(struct pca953x_chip *chip, u8 *pending)
492{
493 u8 cur_stat[MAX_BANK];
494 u8 old_stat[MAX_BANK];
495 bool pending_seen = false;
496 bool trigger_seen = false;
497 u8 trigger[MAX_BANK];
498 int ret, i, offset = 0;
499
500 switch (chip->chip_type) {
501 case PCA953X_TYPE:
502 offset = PCA953X_INPUT;
503 break;
504 case PCA957X_TYPE:
505 offset = PCA957X_IN;
506 break;
507 }
508 ret = pca953x_read_regs(chip, offset, cur_stat);
509 if (ret)
510 return false;
511
512 /* Remove output pins from the equation */
513 for (i = 0; i < NBANK(chip); i++)
514 cur_stat[i] &= chip->reg_direction[i];
515
516 memcpy(old_stat, chip->irq_stat, NBANK(chip));
517
518 for (i = 0; i < NBANK(chip); i++) {
519 trigger[i] = (cur_stat[i] ^ old_stat[i]) & chip->irq_mask[i];
520 if (trigger[i])
521 trigger_seen = true;
522 }
523
524 if (!trigger_seen)
525 return false;
526
527 memcpy(chip->irq_stat, cur_stat, NBANK(chip));
528
529 for (i = 0; i < NBANK(chip); i++) {
530 pending[i] = (old_stat[i] & chip->irq_trig_fall[i]) |
531 (cur_stat[i] & chip->irq_trig_raise[i]);
532 pending[i] &= trigger[i];
533 if (pending[i])
534 pending_seen = true;
535 }
536
537 return pending_seen;
538}
539
540static irqreturn_t pca953x_irq_handler(int irq, void *devid)
541{
542 struct pca953x_chip *chip = devid;
543 u8 pending[MAX_BANK];
544 u8 level;
545 unsigned nhandled = 0;
546 int i;
547
548 if (!pca953x_irq_pending(chip, pending))
549 return IRQ_NONE;
550
551 for (i = 0; i < NBANK(chip); i++) {
552 while (pending[i]) {
553 level = __ffs(pending[i]);
554 handle_nested_irq(irq_find_mapping(chip->gpio_chip.irqdomain,
555 level + (BANK_SZ * i)));
556 pending[i] &= ~(1 << level);
557 nhandled++;
558 }
559 }
560
561 return (nhandled > 0) ? IRQ_HANDLED : IRQ_NONE;
562}
563
564static int pca953x_irq_setup(struct pca953x_chip *chip,
565 int irq_base)
566{
567 struct i2c_client *client = chip->client;
568 int ret, i, offset = 0;
569
570 if (client->irq && irq_base != -1
571 && (chip->driver_data & PCA_INT)) {
572
573 switch (chip->chip_type) {
574 case PCA953X_TYPE:
575 offset = PCA953X_INPUT;
576 break;
577 case PCA957X_TYPE:
578 offset = PCA957X_IN;
579 break;
580 }
581 ret = pca953x_read_regs(chip, offset, chip->irq_stat);
582 if (ret)
583 return ret;
584
585 /*
586 * There is no way to know which GPIO line generated the
587 * interrupt. We have to rely on the previous read for
588 * this purpose.
589 */
590 for (i = 0; i < NBANK(chip); i++)
591 chip->irq_stat[i] &= chip->reg_direction[i];
592 mutex_init(&chip->irq_lock);
593
594 ret = devm_request_threaded_irq(&client->dev,
595 client->irq,
596 NULL,
597 pca953x_irq_handler,
598 IRQF_TRIGGER_LOW | IRQF_ONESHOT |
599 IRQF_SHARED,
600 dev_name(&client->dev), chip);
601 if (ret) {
602 dev_err(&client->dev, "failed to request irq %d\n",
603 client->irq);
604 return ret;
605 }
606
607 ret = gpiochip_irqchip_add(&chip->gpio_chip,
608 &pca953x_irq_chip,
609 irq_base,
610 handle_simple_irq,
611 IRQ_TYPE_NONE);
612 if (ret) {
613 dev_err(&client->dev,
614 "could not connect irqchip to gpiochip\n");
615 return ret;
616 }
617
618 gpiochip_set_chained_irqchip(&chip->gpio_chip,
619 &pca953x_irq_chip,
620 client->irq, NULL);
621 }
622
623 return 0;
624}
625
626#else /* CONFIG_GPIO_PCA953X_IRQ */
627static int pca953x_irq_setup(struct pca953x_chip *chip,
628 int irq_base)
629{
630 struct i2c_client *client = chip->client;
631
632 if (irq_base != -1 && (chip->driver_data & PCA_INT))
633 dev_warn(&client->dev, "interrupt support not compiled in\n");
634
635 return 0;
636}
637#endif
638
639static int device_pca953x_init(struct pca953x_chip *chip, u32 invert)
640{
641 int ret;
642 u8 val[MAX_BANK];
643
644 ret = pca953x_read_regs(chip, PCA953X_OUTPUT, chip->reg_output);
645 if (ret)
646 goto out;
647
648 ret = pca953x_read_regs(chip, PCA953X_DIRECTION,
649 chip->reg_direction);
650 if (ret)
651 goto out;
652
653 /* set platform specific polarity inversion */
654 if (invert)
655 memset(val, 0xFF, NBANK(chip));
656 else
657 memset(val, 0, NBANK(chip));
658
659 ret = pca953x_write_regs(chip, PCA953X_INVERT, val);
660out:
661 return ret;
662}
663
664static int device_pca957x_init(struct pca953x_chip *chip, u32 invert)
665{
666 int ret;
667 u8 val[MAX_BANK];
668
669 ret = pca953x_read_regs(chip, PCA957X_OUT, chip->reg_output);
670 if (ret)
671 goto out;
672 ret = pca953x_read_regs(chip, PCA957X_CFG, chip->reg_direction);
673 if (ret)
674 goto out;
675
676 /* set platform specific polarity inversion */
677 if (invert)
678 memset(val, 0xFF, NBANK(chip));
679 else
680 memset(val, 0, NBANK(chip));
681 ret = pca953x_write_regs(chip, PCA957X_INVRT, val);
682 if (ret)
683 goto out;
684
685 /* To enable register 6, 7 to control pull up and pull down */
686 memset(val, 0x02, NBANK(chip));
687 ret = pca953x_write_regs(chip, PCA957X_BKEN, val);
688 if (ret)
689 goto out;
690
691 return 0;
692out:
693 return ret;
694}
695
696static const struct of_device_id pca953x_dt_ids[];
697
698static int pca953x_probe(struct i2c_client *client,
699 const struct i2c_device_id *id)
700{
701 struct pca953x_platform_data *pdata;
702 struct pca953x_chip *chip;
703 int irq_base = 0;
704 int ret;
705 u32 invert = 0;
706
707 chip = devm_kzalloc(&client->dev,
708 sizeof(struct pca953x_chip), GFP_KERNEL);
709 if (chip == NULL)
710 return -ENOMEM;
711
712 pdata = dev_get_platdata(&client->dev);
713 if (pdata) {
714 irq_base = pdata->irq_base;
715 chip->gpio_start = pdata->gpio_base;
716 invert = pdata->invert;
717 chip->names = pdata->names;
718 } else {
719 chip->gpio_start = -1;
720 irq_base = 0;
721 }
722
723 chip->client = client;
724
725 if (id) {
726 chip->driver_data = id->driver_data;
727 } else {
728 const struct acpi_device_id *id;
729 const struct of_device_id *match;
730
731 match = of_match_device(pca953x_dt_ids, &client->dev);
732 if (match) {
733 chip->driver_data = (int)(uintptr_t)match->data;
734 } else {
735 id = acpi_match_device(pca953x_acpi_ids, &client->dev);
736 if (!id)
737 return -ENODEV;
738
739 chip->driver_data = id->driver_data;
740 }
741 }
742
743 chip->chip_type = PCA_CHIP_TYPE(chip->driver_data);
744
745 mutex_init(&chip->i2c_lock);
746
747 /* initialize cached registers from their original values.
748 * we can't share this chip with another i2c master.
749 */
750 pca953x_setup_gpio(chip, chip->driver_data & PCA_GPIO_MASK);
751
752 if (chip->chip_type == PCA953X_TYPE)
753 ret = device_pca953x_init(chip, invert);
754 else
755 ret = device_pca957x_init(chip, invert);
756 if (ret)
757 return ret;
758
759 ret = devm_gpiochip_add_data(&client->dev, &chip->gpio_chip, chip);
760 if (ret)
761 return ret;
762
763 ret = pca953x_irq_setup(chip, irq_base);
764 if (ret)
765 return ret;
766
767 if (pdata && pdata->setup) {
768 ret = pdata->setup(client, chip->gpio_chip.base,
769 chip->gpio_chip.ngpio, pdata->context);
770 if (ret < 0)
771 dev_warn(&client->dev, "setup failed, %d\n", ret);
772 }
773
774 i2c_set_clientdata(client, chip);
775 return 0;
776}
777
778static int pca953x_remove(struct i2c_client *client)
779{
780 struct pca953x_platform_data *pdata = dev_get_platdata(&client->dev);
781 struct pca953x_chip *chip = i2c_get_clientdata(client);
782 int ret = 0;
783
784 if (pdata && pdata->teardown) {
785 ret = pdata->teardown(client, chip->gpio_chip.base,
786 chip->gpio_chip.ngpio, pdata->context);
787 if (ret < 0) {
788 dev_err(&client->dev, "%s failed, %d\n",
789 "teardown", ret);
790 return ret;
791 }
792 }
793
794 return 0;
795}
796
797/* convenience to stop overlong match-table lines */
798#define OF_953X(__nrgpio, __int) (void *)(__nrgpio | PCA953X_TYPE | __int)
799#define OF_957X(__nrgpio, __int) (void *)(__nrgpio | PCA957X_TYPE | __int)
800
801static const struct of_device_id pca953x_dt_ids[] = {
802 { .compatible = "nxp,pca9505", .data = OF_953X(40, PCA_INT), },
803 { .compatible = "nxp,pca9534", .data = OF_953X( 8, PCA_INT), },
804 { .compatible = "nxp,pca9535", .data = OF_953X(16, PCA_INT), },
805 { .compatible = "nxp,pca9536", .data = OF_953X( 4, 0), },
806 { .compatible = "nxp,pca9537", .data = OF_953X( 4, PCA_INT), },
807 { .compatible = "nxp,pca9538", .data = OF_953X( 8, PCA_INT), },
808 { .compatible = "nxp,pca9539", .data = OF_953X(16, PCA_INT), },
809 { .compatible = "nxp,pca9554", .data = OF_953X( 8, PCA_INT), },
810 { .compatible = "nxp,pca9555", .data = OF_953X(16, PCA_INT), },
811 { .compatible = "nxp,pca9556", .data = OF_953X( 8, 0), },
812 { .compatible = "nxp,pca9557", .data = OF_953X( 8, 0), },
813 { .compatible = "nxp,pca9574", .data = OF_957X( 8, PCA_INT), },
814 { .compatible = "nxp,pca9575", .data = OF_957X(16, PCA_INT), },
815 { .compatible = "nxp,pca9698", .data = OF_953X(40, 0), },
816
817 { .compatible = "maxim,max7310", .data = OF_953X( 8, 0), },
818 { .compatible = "maxim,max7312", .data = OF_953X(16, PCA_INT), },
819 { .compatible = "maxim,max7313", .data = OF_953X(16, PCA_INT), },
820 { .compatible = "maxim,max7315", .data = OF_953X( 8, PCA_INT), },
821
822 { .compatible = "ti,pca6107", .data = OF_953X( 8, PCA_INT), },
823 { .compatible = "ti,tca6408", .data = OF_953X( 8, PCA_INT), },
824 { .compatible = "ti,tca6416", .data = OF_953X(16, PCA_INT), },
825 { .compatible = "ti,tca6424", .data = OF_953X(24, PCA_INT), },
826
827 { .compatible = "onsemi,pca9654", .data = OF_953X( 8, PCA_INT), },
828
829 { .compatible = "exar,xra1202", .data = OF_953X( 8, 0), },
830 { }
831};
832
833MODULE_DEVICE_TABLE(of, pca953x_dt_ids);
834
835static struct i2c_driver pca953x_driver = {
836 .driver = {
837 .name = "pca953x",
838 .of_match_table = pca953x_dt_ids,
839 .acpi_match_table = ACPI_PTR(pca953x_acpi_ids),
840 },
841 .probe = pca953x_probe,
842 .remove = pca953x_remove,
843 .id_table = pca953x_id,
844};
845
846static int __init pca953x_init(void)
847{
848 return i2c_add_driver(&pca953x_driver);
849}
850/* register after i2c postcore initcall and before
851 * subsys initcalls that may rely on these GPIOs
852 */
853subsys_initcall(pca953x_init);
854
855static void __exit pca953x_exit(void)
856{
857 i2c_del_driver(&pca953x_driver);
858}
859module_exit(pca953x_exit);
860
861MODULE_AUTHOR("eric miao <eric.miao@marvell.com>");
862MODULE_DESCRIPTION("GPIO expander driver for PCA953x");
863MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.028192 seconds and 5 git commands to generate.