blob: 8c5252c6c327764cb6fc4ae99f321e2cdf830537 [file] [log] [blame]
Eric Miaobbcd6d52008-07-25 01:46:14 -07001/*
Grant Likelyc103de22011-06-04 18:38:28 -06002 * MAX732x I2C Port Expander with 8/16 I/O
Eric Miaobbcd6d52008-07-25 01:46:14 -07003 *
4 * Copyright (C) 2007 Marvell International Ltd.
5 * Copyright (C) 2008 Jack Ren <jack.ren@marvell.com>
6 * Copyright (C) 2008 Eric Miao <eric.miao@marvell.com>
Linus Walleij984f6642015-01-30 11:32:01 +01007 * Copyright (C) 2015 Linus Walleij <linus.walleij@linaro.org>
Eric Miaobbcd6d52008-07-25 01:46:14 -07008 *
9 * Derived from drivers/gpio/pca953x.c
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; version 2 of the License.
14 */
15
16#include <linux/module.h>
17#include <linux/init.h>
18#include <linux/slab.h>
19#include <linux/string.h>
Linus Walleij984f6642015-01-30 11:32:01 +010020#include <linux/gpio/driver.h>
Marc Zyngiera80a0bb2010-05-26 14:42:16 -070021#include <linux/interrupt.h>
Eric Miaobbcd6d52008-07-25 01:46:14 -070022#include <linux/i2c.h>
23#include <linux/i2c/max732x.h>
Semen Protsenko43c4bcf2015-01-13 15:41:42 +020024#include <linux/of.h>
Eric Miaobbcd6d52008-07-25 01:46:14 -070025
26
27/*
28 * Each port of MAX732x (including MAX7319) falls into one of the
29 * following three types:
30 *
31 * - Push Pull Output
32 * - Input
33 * - Open Drain I/O
34 *
35 * designated by 'O', 'I' and 'P' individually according to MAXIM's
Marc Zyngiera80a0bb2010-05-26 14:42:16 -070036 * datasheets. 'I' and 'P' ports are interrupt capables, some with
37 * a dedicated interrupt mask.
Eric Miaobbcd6d52008-07-25 01:46:14 -070038 *
39 * There are two groups of I/O ports, each group usually includes
40 * up to 8 I/O ports, and is accessed by a specific I2C address:
41 *
42 * - Group A : by I2C address 0b'110xxxx
43 * - Group B : by I2C address 0b'101xxxx
44 *
45 * where 'xxxx' is decided by the connections of pin AD2/AD0. The
46 * address used also affects the initial state of output signals.
47 *
48 * Within each group of ports, there are five known combinations of
49 * I/O ports: 4I4O, 4P4O, 8I, 8P, 8O, see the definitions below for
Marc Zyngiera80a0bb2010-05-26 14:42:16 -070050 * the detailed organization of these ports. Only Goup A is interrupt
51 * capable.
Eric Miaobbcd6d52008-07-25 01:46:14 -070052 *
53 * GPIO numbers start from 'gpio_base + 0' to 'gpio_base + 8/16',
54 * and GPIOs from GROUP_A are numbered before those from GROUP_B
55 * (if there are two groups).
56 *
57 * NOTE: MAX7328/MAX7329 are drop-in replacements for PCF8574/a, so
58 * they are not supported by this driver.
59 */
60
61#define PORT_NONE 0x0 /* '/' No Port */
62#define PORT_OUTPUT 0x1 /* 'O' Push-Pull, Output Only */
63#define PORT_INPUT 0x2 /* 'I' Input Only */
64#define PORT_OPENDRAIN 0x3 /* 'P' Open-Drain, I/O */
65
66#define IO_4I4O 0x5AA5 /* O7 O6 I5 I4 I3 I2 O1 O0 */
67#define IO_4P4O 0x5FF5 /* O7 O6 P5 P4 P3 P2 O1 O0 */
68#define IO_8I 0xAAAA /* I7 I6 I5 I4 I3 I2 I1 I0 */
69#define IO_8P 0xFFFF /* P7 P6 P5 P4 P3 P2 P1 P0 */
70#define IO_8O 0x5555 /* O7 O6 O5 O4 O3 O2 O1 O0 */
71
72#define GROUP_A(x) ((x) & 0xffff) /* I2C Addr: 0b'110xxxx */
73#define GROUP_B(x) ((x) << 16) /* I2C Addr: 0b'101xxxx */
74
Marc Zyngiera80a0bb2010-05-26 14:42:16 -070075#define INT_NONE 0x0 /* No interrupt capability */
76#define INT_NO_MASK 0x1 /* Has interrupts, no mask */
77#define INT_INDEP_MASK 0x2 /* Has interrupts, independent mask */
78#define INT_MERGED_MASK 0x3 /* Has interrupts, merged mask */
79
80#define INT_CAPS(x) (((uint64_t)(x)) << 32)
81
82enum {
83 MAX7319,
84 MAX7320,
85 MAX7321,
86 MAX7322,
87 MAX7323,
88 MAX7324,
89 MAX7325,
90 MAX7326,
91 MAX7327,
92};
93
94static uint64_t max732x_features[] = {
95 [MAX7319] = GROUP_A(IO_8I) | INT_CAPS(INT_MERGED_MASK),
96 [MAX7320] = GROUP_B(IO_8O),
97 [MAX7321] = GROUP_A(IO_8P) | INT_CAPS(INT_NO_MASK),
98 [MAX7322] = GROUP_A(IO_4I4O) | INT_CAPS(INT_MERGED_MASK),
99 [MAX7323] = GROUP_A(IO_4P4O) | INT_CAPS(INT_INDEP_MASK),
100 [MAX7324] = GROUP_A(IO_8I) | GROUP_B(IO_8O) | INT_CAPS(INT_MERGED_MASK),
101 [MAX7325] = GROUP_A(IO_8P) | GROUP_B(IO_8O) | INT_CAPS(INT_NO_MASK),
102 [MAX7326] = GROUP_A(IO_4I4O) | GROUP_B(IO_8O) | INT_CAPS(INT_MERGED_MASK),
103 [MAX7327] = GROUP_A(IO_4P4O) | GROUP_B(IO_8O) | INT_CAPS(INT_NO_MASK),
104};
105
Eric Miaobbcd6d52008-07-25 01:46:14 -0700106static const struct i2c_device_id max732x_id[] = {
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700107 { "max7319", MAX7319 },
108 { "max7320", MAX7320 },
109 { "max7321", MAX7321 },
110 { "max7322", MAX7322 },
111 { "max7323", MAX7323 },
112 { "max7324", MAX7324 },
113 { "max7325", MAX7325 },
114 { "max7326", MAX7326 },
115 { "max7327", MAX7327 },
Eric Miaobbcd6d52008-07-25 01:46:14 -0700116 { },
117};
118MODULE_DEVICE_TABLE(i2c, max732x_id);
119
Semen Protsenko43c4bcf2015-01-13 15:41:42 +0200120#ifdef CONFIG_OF
121static const struct of_device_id max732x_of_table[] = {
122 { .compatible = "maxim,max7319" },
123 { .compatible = "maxim,max7320" },
124 { .compatible = "maxim,max7321" },
125 { .compatible = "maxim,max7322" },
126 { .compatible = "maxim,max7323" },
127 { .compatible = "maxim,max7324" },
128 { .compatible = "maxim,max7325" },
129 { .compatible = "maxim,max7326" },
130 { .compatible = "maxim,max7327" },
131 { }
132};
133MODULE_DEVICE_TABLE(of, max732x_of_table);
134#endif
135
Eric Miaobbcd6d52008-07-25 01:46:14 -0700136struct max732x_chip {
137 struct gpio_chip gpio_chip;
138
139 struct i2c_client *client; /* "main" client */
140 struct i2c_client *client_dummy;
141 struct i2c_client *client_group_a;
142 struct i2c_client *client_group_b;
143
144 unsigned int mask_group_a;
145 unsigned int dir_input;
146 unsigned int dir_output;
147
148 struct mutex lock;
149 uint8_t reg_out[2];
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700150
151#ifdef CONFIG_GPIO_MAX732X_IRQ
Semen Protsenko479f8a52015-01-13 15:41:43 +0200152 struct mutex irq_lock;
Semen Protsenko479f8a52015-01-13 15:41:43 +0200153 uint8_t irq_mask;
154 uint8_t irq_mask_cur;
155 uint8_t irq_trig_raise;
156 uint8_t irq_trig_fall;
157 uint8_t irq_features;
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700158#endif
Eric Miaobbcd6d52008-07-25 01:46:14 -0700159};
160
Linus Walleij37fc8a92015-01-30 10:56:05 +0100161static inline struct max732x_chip *to_max732x(struct gpio_chip *gc)
162{
163 return container_of(gc, struct max732x_chip, gpio_chip);
164}
165
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700166static int max732x_writeb(struct max732x_chip *chip, int group_a, uint8_t val)
Eric Miaobbcd6d52008-07-25 01:46:14 -0700167{
168 struct i2c_client *client;
169 int ret;
170
171 client = group_a ? chip->client_group_a : chip->client_group_b;
172 ret = i2c_smbus_write_byte(client, val);
173 if (ret < 0) {
174 dev_err(&client->dev, "failed writing\n");
175 return ret;
176 }
177
178 return 0;
179}
180
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700181static int max732x_readb(struct max732x_chip *chip, int group_a, uint8_t *val)
Eric Miaobbcd6d52008-07-25 01:46:14 -0700182{
183 struct i2c_client *client;
184 int ret;
185
186 client = group_a ? chip->client_group_a : chip->client_group_b;
187 ret = i2c_smbus_read_byte(client);
188 if (ret < 0) {
189 dev_err(&client->dev, "failed reading\n");
190 return ret;
191 }
192
193 *val = (uint8_t)ret;
194 return 0;
195}
196
197static inline int is_group_a(struct max732x_chip *chip, unsigned off)
198{
199 return (1u << off) & chip->mask_group_a;
200}
201
202static int max732x_gpio_get_value(struct gpio_chip *gc, unsigned off)
203{
Linus Walleij37fc8a92015-01-30 10:56:05 +0100204 struct max732x_chip *chip = to_max732x(gc);
Eric Miaobbcd6d52008-07-25 01:46:14 -0700205 uint8_t reg_val;
206 int ret;
207
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700208 ret = max732x_readb(chip, is_group_a(chip, off), &reg_val);
Eric Miaobbcd6d52008-07-25 01:46:14 -0700209 if (ret < 0)
210 return 0;
211
212 return reg_val & (1u << (off & 0x7));
213}
214
Mans Rullgard161af6c2015-01-21 17:17:49 +0000215static void max732x_gpio_set_mask(struct gpio_chip *gc, unsigned off, int mask,
216 int val)
Eric Miaobbcd6d52008-07-25 01:46:14 -0700217{
Linus Walleij37fc8a92015-01-30 10:56:05 +0100218 struct max732x_chip *chip = to_max732x(gc);
Mans Rullgard161af6c2015-01-21 17:17:49 +0000219 uint8_t reg_out;
Eric Miaobbcd6d52008-07-25 01:46:14 -0700220 int ret;
221
Eric Miaobbcd6d52008-07-25 01:46:14 -0700222 mutex_lock(&chip->lock);
223
224 reg_out = (off > 7) ? chip->reg_out[1] : chip->reg_out[0];
Mans Rullgard161af6c2015-01-21 17:17:49 +0000225 reg_out = (reg_out & ~mask) | (val & mask);
Eric Miaobbcd6d52008-07-25 01:46:14 -0700226
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700227 ret = max732x_writeb(chip, is_group_a(chip, off), reg_out);
Eric Miaobbcd6d52008-07-25 01:46:14 -0700228 if (ret < 0)
229 goto out;
230
231 /* update the shadow register then */
232 if (off > 7)
233 chip->reg_out[1] = reg_out;
234 else
235 chip->reg_out[0] = reg_out;
236out:
237 mutex_unlock(&chip->lock);
238}
239
Mans Rullgard161af6c2015-01-21 17:17:49 +0000240static void max732x_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
241{
242 unsigned base = off & ~0x7;
243 uint8_t mask = 1u << (off & 0x7);
244
245 max732x_gpio_set_mask(gc, base, mask, val << (off & 0x7));
246}
247
248static void max732x_gpio_set_multiple(struct gpio_chip *gc,
249 unsigned long *mask, unsigned long *bits)
250{
251 unsigned mask_lo = mask[0] & 0xff;
252 unsigned mask_hi = (mask[0] >> 8) & 0xff;
253
254 if (mask_lo)
255 max732x_gpio_set_mask(gc, 0, mask_lo, bits[0] & 0xff);
256 if (mask_hi)
257 max732x_gpio_set_mask(gc, 8, mask_hi, (bits[0] >> 8) & 0xff);
258}
259
Eric Miaobbcd6d52008-07-25 01:46:14 -0700260static int max732x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
261{
Linus Walleij37fc8a92015-01-30 10:56:05 +0100262 struct max732x_chip *chip = to_max732x(gc);
Eric Miaobbcd6d52008-07-25 01:46:14 -0700263 unsigned int mask = 1u << off;
264
Eric Miaobbcd6d52008-07-25 01:46:14 -0700265 if ((mask & chip->dir_input) == 0) {
266 dev_dbg(&chip->client->dev, "%s port %d is output only\n",
267 chip->client->name, off);
268 return -EACCES;
269 }
270
Marc Zyngiera13c1862010-05-26 14:42:21 -0700271 /*
272 * Open-drain pins must be set to high impedance (which is
273 * equivalent to output-high) to be turned into an input.
274 */
275 if ((mask & chip->dir_output))
276 max732x_gpio_set_value(gc, off, 1);
277
Eric Miaobbcd6d52008-07-25 01:46:14 -0700278 return 0;
279}
280
281static int max732x_gpio_direction_output(struct gpio_chip *gc,
282 unsigned off, int val)
283{
Linus Walleij37fc8a92015-01-30 10:56:05 +0100284 struct max732x_chip *chip = to_max732x(gc);
Eric Miaobbcd6d52008-07-25 01:46:14 -0700285 unsigned int mask = 1u << off;
286
Eric Miaobbcd6d52008-07-25 01:46:14 -0700287 if ((mask & chip->dir_output) == 0) {
288 dev_dbg(&chip->client->dev, "%s port %d is input only\n",
289 chip->client->name, off);
290 return -EACCES;
291 }
292
293 max732x_gpio_set_value(gc, off, val);
294 return 0;
295}
296
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700297#ifdef CONFIG_GPIO_MAX732X_IRQ
298static int max732x_writew(struct max732x_chip *chip, uint16_t val)
299{
300 int ret;
301
302 val = cpu_to_le16(val);
303
304 ret = i2c_master_send(chip->client_group_a, (char *)&val, 2);
305 if (ret < 0) {
306 dev_err(&chip->client_group_a->dev, "failed writing\n");
307 return ret;
308 }
309
310 return 0;
311}
312
313static int max732x_readw(struct max732x_chip *chip, uint16_t *val)
314{
315 int ret;
316
317 ret = i2c_master_recv(chip->client_group_a, (char *)val, 2);
318 if (ret < 0) {
319 dev_err(&chip->client_group_a->dev, "failed reading\n");
320 return ret;
321 }
322
323 *val = le16_to_cpu(*val);
324 return 0;
325}
326
327static void max732x_irq_update_mask(struct max732x_chip *chip)
328{
329 uint16_t msg;
330
331 if (chip->irq_mask == chip->irq_mask_cur)
332 return;
333
334 chip->irq_mask = chip->irq_mask_cur;
335
336 if (chip->irq_features == INT_NO_MASK)
337 return;
338
339 mutex_lock(&chip->lock);
340
341 switch (chip->irq_features) {
342 case INT_INDEP_MASK:
343 msg = (chip->irq_mask << 8) | chip->reg_out[0];
344 max732x_writew(chip, msg);
345 break;
346
347 case INT_MERGED_MASK:
348 msg = chip->irq_mask | chip->reg_out[0];
349 max732x_writeb(chip, 1, (uint8_t)msg);
350 break;
351 }
352
353 mutex_unlock(&chip->lock);
354}
355
Lennert Buytenhekfbc4667a2011-01-12 17:00:14 -0800356static void max732x_irq_mask(struct irq_data *d)
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700357{
Linus Walleij984f6642015-01-30 11:32:01 +0100358 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
359 struct max732x_chip *chip = to_max732x(gc);
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700360
Semen Protsenko479f8a52015-01-13 15:41:43 +0200361 chip->irq_mask_cur &= ~(1 << d->hwirq);
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700362}
363
Lennert Buytenhekfbc4667a2011-01-12 17:00:14 -0800364static void max732x_irq_unmask(struct irq_data *d)
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700365{
Linus Walleij984f6642015-01-30 11:32:01 +0100366 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
367 struct max732x_chip *chip = to_max732x(gc);
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700368
Semen Protsenko479f8a52015-01-13 15:41:43 +0200369 chip->irq_mask_cur |= 1 << d->hwirq;
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700370}
371
Lennert Buytenhekfbc4667a2011-01-12 17:00:14 -0800372static void max732x_irq_bus_lock(struct irq_data *d)
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700373{
Linus Walleij984f6642015-01-30 11:32:01 +0100374 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
375 struct max732x_chip *chip = to_max732x(gc);
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700376
377 mutex_lock(&chip->irq_lock);
378 chip->irq_mask_cur = chip->irq_mask;
379}
380
Lennert Buytenhekfbc4667a2011-01-12 17:00:14 -0800381static void max732x_irq_bus_sync_unlock(struct irq_data *d)
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700382{
Linus Walleij984f6642015-01-30 11:32:01 +0100383 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
384 struct max732x_chip *chip = to_max732x(gc);
Semen Protsenko09afa272015-01-13 15:41:44 +0200385 uint16_t new_irqs;
386 uint16_t level;
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700387
388 max732x_irq_update_mask(chip);
Semen Protsenko09afa272015-01-13 15:41:44 +0200389
390 new_irqs = chip->irq_trig_fall | chip->irq_trig_raise;
391 while (new_irqs) {
392 level = __ffs(new_irqs);
393 max732x_gpio_direction_input(&chip->gpio_chip, level);
394 new_irqs &= ~(1 << level);
395 }
396
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700397 mutex_unlock(&chip->irq_lock);
398}
399
Lennert Buytenhekfbc4667a2011-01-12 17:00:14 -0800400static int max732x_irq_set_type(struct irq_data *d, unsigned int type)
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700401{
Linus Walleij984f6642015-01-30 11:32:01 +0100402 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
403 struct max732x_chip *chip = to_max732x(gc);
Semen Protsenko479f8a52015-01-13 15:41:43 +0200404 uint16_t off = d->hwirq;
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700405 uint16_t mask = 1 << off;
406
407 if (!(mask & chip->dir_input)) {
408 dev_dbg(&chip->client->dev, "%s port %d is output only\n",
409 chip->client->name, off);
410 return -EACCES;
411 }
412
413 if (!(type & IRQ_TYPE_EDGE_BOTH)) {
414 dev_err(&chip->client->dev, "irq %d: unsupported type %d\n",
Lennert Buytenhekfbc4667a2011-01-12 17:00:14 -0800415 d->irq, type);
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700416 return -EINVAL;
417 }
418
419 if (type & IRQ_TYPE_EDGE_FALLING)
420 chip->irq_trig_fall |= mask;
421 else
422 chip->irq_trig_fall &= ~mask;
423
424 if (type & IRQ_TYPE_EDGE_RISING)
425 chip->irq_trig_raise |= mask;
426 else
427 chip->irq_trig_raise &= ~mask;
428
Semen Protsenko09afa272015-01-13 15:41:44 +0200429 return 0;
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700430}
431
Semen Protsenko67ddd322015-04-21 20:27:37 +0300432static int max732x_irq_set_wake(struct irq_data *data, unsigned int on)
433{
434 struct max732x_chip *chip = irq_data_get_irq_chip_data(data);
435
436 irq_set_irq_wake(chip->client->irq, on);
437 return 0;
438}
439
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700440static struct irq_chip max732x_irq_chip = {
441 .name = "max732x",
Lennert Buytenhekfbc4667a2011-01-12 17:00:14 -0800442 .irq_mask = max732x_irq_mask,
443 .irq_unmask = max732x_irq_unmask,
444 .irq_bus_lock = max732x_irq_bus_lock,
445 .irq_bus_sync_unlock = max732x_irq_bus_sync_unlock,
446 .irq_set_type = max732x_irq_set_type,
Semen Protsenko67ddd322015-04-21 20:27:37 +0300447 .irq_set_wake = max732x_irq_set_wake,
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700448};
449
450static uint8_t max732x_irq_pending(struct max732x_chip *chip)
451{
452 uint8_t cur_stat;
453 uint8_t old_stat;
454 uint8_t trigger;
455 uint8_t pending;
456 uint16_t status;
457 int ret;
458
459 ret = max732x_readw(chip, &status);
460 if (ret)
461 return 0;
462
463 trigger = status >> 8;
464 trigger &= chip->irq_mask;
465
466 if (!trigger)
467 return 0;
468
469 cur_stat = status & 0xFF;
470 cur_stat &= chip->irq_mask;
471
472 old_stat = cur_stat ^ trigger;
473
474 pending = (old_stat & chip->irq_trig_fall) |
475 (cur_stat & chip->irq_trig_raise);
476 pending &= trigger;
477
478 return pending;
479}
480
481static irqreturn_t max732x_irq_handler(int irq, void *devid)
482{
483 struct max732x_chip *chip = devid;
484 uint8_t pending;
485 uint8_t level;
486
487 pending = max732x_irq_pending(chip);
488
489 if (!pending)
490 return IRQ_HANDLED;
491
492 do {
493 level = __ffs(pending);
Linus Walleij984f6642015-01-30 11:32:01 +0100494 handle_nested_irq(irq_find_mapping(chip->gpio_chip.irqdomain,
495 level));
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700496
497 pending &= ~(1 << level);
498 } while (pending);
499
500 return IRQ_HANDLED;
501}
502
503static int max732x_irq_setup(struct max732x_chip *chip,
504 const struct i2c_device_id *id)
505{
506 struct i2c_client *client = chip->client;
Jingoo Hane56aee12013-07-30 17:08:05 +0900507 struct max732x_platform_data *pdata = dev_get_platdata(&client->dev);
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700508 int has_irq = max732x_features[id->driver_data] >> 32;
Linus Walleij984f6642015-01-30 11:32:01 +0100509 int irq_base = 0;
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700510 int ret;
511
Semen Protsenko43c4bcf2015-01-13 15:41:42 +0200512 if (((pdata && pdata->irq_base) || client->irq)
513 && has_irq != INT_NONE) {
Semen Protsenko43c4bcf2015-01-13 15:41:42 +0200514 if (pdata)
Linus Walleij984f6642015-01-30 11:32:01 +0100515 irq_base = pdata->irq_base;
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700516 chip->irq_features = has_irq;
517 mutex_init(&chip->irq_lock);
518
Semen Protsenko68689db2015-04-21 16:19:04 +0300519 ret = devm_request_threaded_irq(&client->dev, client->irq,
520 NULL, max732x_irq_handler, IRQF_ONESHOT |
521 IRQF_TRIGGER_FALLING | IRQF_SHARED,
522 dev_name(&client->dev), chip);
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700523 if (ret) {
524 dev_err(&client->dev, "failed to request irq %d\n",
525 client->irq);
Linus Walleij984f6642015-01-30 11:32:01 +0100526 return ret;
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700527 }
Linus Walleij984f6642015-01-30 11:32:01 +0100528 ret = gpiochip_irqchip_add(&chip->gpio_chip,
529 &max732x_irq_chip,
530 irq_base,
Semen Protsenko606f13e2015-04-22 16:20:41 +0300531 handle_simple_irq,
Linus Walleij984f6642015-01-30 11:32:01 +0100532 IRQ_TYPE_NONE);
533 if (ret) {
534 dev_err(&client->dev,
535 "could not connect irqchip to gpiochip\n");
536 return ret;
537 }
538 gpiochip_set_chained_irqchip(&chip->gpio_chip,
539 &max732x_irq_chip,
540 client->irq,
541 NULL);
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700542 }
543
544 return 0;
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700545}
546
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700547#else /* CONFIG_GPIO_MAX732X_IRQ */
548static int max732x_irq_setup(struct max732x_chip *chip,
549 const struct i2c_device_id *id)
550{
551 struct i2c_client *client = chip->client;
Jingoo Hane56aee12013-07-30 17:08:05 +0900552 struct max732x_platform_data *pdata = dev_get_platdata(&client->dev);
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700553 int has_irq = max732x_features[id->driver_data] >> 32;
554
Semen Protsenko43c4bcf2015-01-13 15:41:42 +0200555 if (((pdata && pdata->irq_base) || client->irq) && has_irq != INT_NONE)
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700556 dev_warn(&client->dev, "interrupt support not compiled in\n");
557
558 return 0;
559}
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700560#endif
561
Bill Pemberton38363092012-11-19 13:22:34 -0500562static int max732x_setup_gpio(struct max732x_chip *chip,
Eric Miaobbcd6d52008-07-25 01:46:14 -0700563 const struct i2c_device_id *id,
564 unsigned gpio_start)
565{
566 struct gpio_chip *gc = &chip->gpio_chip;
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700567 uint32_t id_data = (uint32_t)max732x_features[id->driver_data];
Eric Miaobbcd6d52008-07-25 01:46:14 -0700568 int i, port = 0;
569
570 for (i = 0; i < 16; i++, id_data >>= 2) {
571 unsigned int mask = 1 << port;
572
573 switch (id_data & 0x3) {
574 case PORT_OUTPUT:
575 chip->dir_output |= mask;
576 break;
577 case PORT_INPUT:
578 chip->dir_input |= mask;
579 break;
580 case PORT_OPENDRAIN:
581 chip->dir_output |= mask;
582 chip->dir_input |= mask;
583 break;
584 default:
585 continue;
586 }
587
588 if (i < 8)
589 chip->mask_group_a |= mask;
590 port++;
591 }
592
593 if (chip->dir_input)
594 gc->direction_input = max732x_gpio_direction_input;
595 if (chip->dir_output) {
596 gc->direction_output = max732x_gpio_direction_output;
597 gc->set = max732x_gpio_set_value;
Mans Rullgard161af6c2015-01-21 17:17:49 +0000598 gc->set_multiple = max732x_gpio_set_multiple;
Eric Miaobbcd6d52008-07-25 01:46:14 -0700599 }
600 gc->get = max732x_gpio_get_value;
Linus Walleij9fb1f392013-12-04 14:42:46 +0100601 gc->can_sleep = true;
Eric Miaobbcd6d52008-07-25 01:46:14 -0700602
603 gc->base = gpio_start;
604 gc->ngpio = port;
605 gc->label = chip->client->name;
Marek Vasut34ab54e2015-06-30 20:04:18 +0200606 gc->dev = &chip->client->dev;
Eric Miaobbcd6d52008-07-25 01:46:14 -0700607 gc->owner = THIS_MODULE;
608
609 return port;
610}
611
Semen Protsenko43c4bcf2015-01-13 15:41:42 +0200612static struct max732x_platform_data *of_gpio_max732x(struct device *dev)
613{
614 struct max732x_platform_data *pdata;
615
616 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
617 if (!pdata)
618 return NULL;
619
620 pdata->gpio_base = -1;
621
622 return pdata;
623}
624
Bill Pemberton38363092012-11-19 13:22:34 -0500625static int max732x_probe(struct i2c_client *client,
Eric Miaobbcd6d52008-07-25 01:46:14 -0700626 const struct i2c_device_id *id)
627{
628 struct max732x_platform_data *pdata;
Semen Protsenko43c4bcf2015-01-13 15:41:42 +0200629 struct device_node *node;
Eric Miaobbcd6d52008-07-25 01:46:14 -0700630 struct max732x_chip *chip;
631 struct i2c_client *c;
632 uint16_t addr_a, addr_b;
633 int ret, nr_port;
634
Jingoo Hane56aee12013-07-30 17:08:05 +0900635 pdata = dev_get_platdata(&client->dev);
Semen Protsenko43c4bcf2015-01-13 15:41:42 +0200636 node = client->dev.of_node;
637
638 if (!pdata && node)
639 pdata = of_gpio_max732x(&client->dev);
640
641 if (!pdata) {
Ben Dooksa342d212009-01-15 13:50:45 -0800642 dev_dbg(&client->dev, "no platform data\n");
643 return -EINVAL;
644 }
Eric Miaobbcd6d52008-07-25 01:46:14 -0700645
Semen Protsenko43c4bcf2015-01-13 15:41:42 +0200646 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
Eric Miaobbcd6d52008-07-25 01:46:14 -0700647 if (chip == NULL)
648 return -ENOMEM;
649 chip->client = client;
650
651 nr_port = max732x_setup_gpio(chip, id, pdata->gpio_base);
Semen Protsenko43c4bcf2015-01-13 15:41:42 +0200652 chip->gpio_chip.dev = &client->dev;
Eric Miaobbcd6d52008-07-25 01:46:14 -0700653
654 addr_a = (client->addr & 0x0f) | 0x60;
655 addr_b = (client->addr & 0x0f) | 0x50;
656
657 switch (client->addr & 0x70) {
658 case 0x60:
659 chip->client_group_a = client;
Axel Lin5535cb62010-05-26 14:42:20 -0700660 if (nr_port > 8) {
Eric Miaobbcd6d52008-07-25 01:46:14 -0700661 c = i2c_new_dummy(client->adapter, addr_b);
662 chip->client_group_b = chip->client_dummy = c;
663 }
664 break;
665 case 0x50:
666 chip->client_group_b = client;
Axel Lin5535cb62010-05-26 14:42:20 -0700667 if (nr_port > 8) {
Eric Miaobbcd6d52008-07-25 01:46:14 -0700668 c = i2c_new_dummy(client->adapter, addr_a);
669 chip->client_group_a = chip->client_dummy = c;
670 }
671 break;
672 default:
673 dev_err(&client->dev, "invalid I2C address specified %02x\n",
674 client->addr);
675 ret = -EINVAL;
676 goto out_failed;
677 }
678
Krzysztof Kozlowskif561b422014-03-06 10:31:16 +0100679 if (nr_port > 8 && !chip->client_dummy) {
680 dev_err(&client->dev,
681 "Failed to allocate second group I2C device\n");
682 ret = -ENODEV;
683 goto out_failed;
684 }
685
Eric Miaobbcd6d52008-07-25 01:46:14 -0700686 mutex_init(&chip->lock);
687
Nicholas Krause78de5d52015-08-18 09:55:44 -0400688 ret = max732x_readb(chip, is_group_a(chip, 0), &chip->reg_out[0]);
689 if (ret)
690 goto out_failed;
691 if (nr_port > 8) {
692 ret = max732x_readb(chip, is_group_a(chip, 8), &chip->reg_out[1]);
693 if (ret)
694 goto out_failed;
695 }
Marc Zyngiera80a0bb2010-05-26 14:42:16 -0700696
Eric Miaobbcd6d52008-07-25 01:46:14 -0700697 ret = gpiochip_add(&chip->gpio_chip);
698 if (ret)
699 goto out_failed;
700
Linus Walleij984f6642015-01-30 11:32:01 +0100701 ret = max732x_irq_setup(chip, id);
702 if (ret) {
703 gpiochip_remove(&chip->gpio_chip);
704 goto out_failed;
705 }
706
Semen Protsenko43c4bcf2015-01-13 15:41:42 +0200707 if (pdata && pdata->setup) {
Eric Miaobbcd6d52008-07-25 01:46:14 -0700708 ret = pdata->setup(client, chip->gpio_chip.base,
709 chip->gpio_chip.ngpio, pdata->context);
710 if (ret < 0)
711 dev_warn(&client->dev, "setup failed, %d\n", ret);
712 }
713
714 i2c_set_clientdata(client, chip);
715 return 0;
716
717out_failed:
Krzysztof Kozlowskic75793d2014-03-06 10:31:15 +0100718 if (chip->client_dummy)
719 i2c_unregister_device(chip->client_dummy);
Eric Miaobbcd6d52008-07-25 01:46:14 -0700720 return ret;
721}
722
Bill Pemberton206210c2012-11-19 13:25:50 -0500723static int max732x_remove(struct i2c_client *client)
Eric Miaobbcd6d52008-07-25 01:46:14 -0700724{
Jingoo Hane56aee12013-07-30 17:08:05 +0900725 struct max732x_platform_data *pdata = dev_get_platdata(&client->dev);
Eric Miaobbcd6d52008-07-25 01:46:14 -0700726 struct max732x_chip *chip = i2c_get_clientdata(client);
Eric Miaobbcd6d52008-07-25 01:46:14 -0700727
Semen Protsenko43c4bcf2015-01-13 15:41:42 +0200728 if (pdata && pdata->teardown) {
729 int ret;
730
Eric Miaobbcd6d52008-07-25 01:46:14 -0700731 ret = pdata->teardown(client, chip->gpio_chip.base,
732 chip->gpio_chip.ngpio, pdata->context);
733 if (ret < 0) {
734 dev_err(&client->dev, "%s failed, %d\n",
735 "teardown", ret);
736 return ret;
737 }
738 }
739
abdoulaye berthe9f5132a2014-07-12 22:30:12 +0200740 gpiochip_remove(&chip->gpio_chip);
Eric Miaobbcd6d52008-07-25 01:46:14 -0700741
742 /* unregister any dummy i2c_client */
743 if (chip->client_dummy)
744 i2c_unregister_device(chip->client_dummy);
745
Eric Miaobbcd6d52008-07-25 01:46:14 -0700746 return 0;
747}
748
749static struct i2c_driver max732x_driver = {
750 .driver = {
Semen Protsenko43c4bcf2015-01-13 15:41:42 +0200751 .name = "max732x",
752 .owner = THIS_MODULE,
753 .of_match_table = of_match_ptr(max732x_of_table),
Eric Miaobbcd6d52008-07-25 01:46:14 -0700754 },
755 .probe = max732x_probe,
Bill Pemberton8283c4f2012-11-19 13:20:08 -0500756 .remove = max732x_remove,
Eric Miaobbcd6d52008-07-25 01:46:14 -0700757 .id_table = max732x_id,
758};
759
760static int __init max732x_init(void)
761{
762 return i2c_add_driver(&max732x_driver);
763}
David Brownell2f8d1192008-10-15 22:03:13 -0700764/* register after i2c postcore initcall and before
765 * subsys initcalls that may rely on these GPIOs
766 */
767subsys_initcall(max732x_init);
Eric Miaobbcd6d52008-07-25 01:46:14 -0700768
769static void __exit max732x_exit(void)
770{
771 i2c_del_driver(&max732x_driver);
772}
773module_exit(max732x_exit);
774
775MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>");
776MODULE_DESCRIPTION("GPIO expander driver for MAX732X");
777MODULE_LICENSE("GPL");