blob: d3f3e8f5456129e7036fc3737181d37b40b8c642 [file] [log] [blame]
eric miao9e60fdc2008-02-04 22:28:26 -08001/*
Grant Likelyc103de22011-06-04 18:38:28 -06002 * PCA953x 4/8/16 bit I/O ports
eric miao9e60fdc2008-02-04 22:28:26 -08003 *
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>
H Hartley Sweetend120c172009-09-22 16:46:37 -070016#include <linux/gpio.h>
Marc Zyngier89ea8bb2010-03-05 13:44:36 -080017#include <linux/interrupt.h>
18#include <linux/irq.h>
eric miao9e60fdc2008-02-04 22:28:26 -080019#include <linux/i2c.h>
Guennadi Liakhovetskid1c057e32008-02-06 01:39:02 -080020#include <linux/i2c/pca953x.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090021#include <linux/slab.h>
Nate Case1965d302009-06-17 16:26:17 -070022#ifdef CONFIG_OF_GPIO
23#include <linux/of_platform.h>
Nate Case1965d302009-06-17 16:26:17 -070024#endif
eric miao9e60fdc2008-02-04 22:28:26 -080025
Haojian Zhuang33226ff2011-04-18 22:12:46 +080026#define PCA953X_INPUT 0
27#define PCA953X_OUTPUT 1
28#define PCA953X_INVERT 2
29#define PCA953X_DIRECTION 3
eric miao9e60fdc2008-02-04 22:28:26 -080030
Haojian Zhuang33226ff2011-04-18 22:12:46 +080031#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
Marc Zyngier89ea8bb2010-03-05 13:44:36 -080044
Jean Delvare3760f732008-04-29 23:11:40 +020045static const struct i2c_device_id pca953x_id[] = {
Haojian Zhuang33226ff2011-04-18 22:12:46 +080046 { "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, },
David Brownellab5dc372009-01-06 14:42:27 -080058
Haojian Zhuang33226ff2011-04-18 22:12:46 +080059 { "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, },
David Brownellab5dc372009-01-06 14:42:27 -080066 /* NYET: { "tca6424", 24, }, */
Jean Delvare3760f732008-04-29 23:11:40 +020067 { }
Guennadi Liakhovetskif5e8ff42008-02-06 01:39:04 -080068};
Jean Delvare3760f732008-04-29 23:11:40 +020069MODULE_DEVICE_TABLE(i2c, pca953x_id);
eric miao9e60fdc2008-02-04 22:28:26 -080070
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -080071struct pca953x_chip {
eric miao9e60fdc2008-02-04 22:28:26 -080072 unsigned gpio_start;
73 uint16_t reg_output;
74 uint16_t reg_direction;
Roland Stigge6e20fb12011-02-10 15:01:23 -080075 struct mutex i2c_lock;
eric miao9e60fdc2008-02-04 22:28:26 -080076
Marc Zyngier89ea8bb2010-03-05 13:44:36 -080077#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
eric miao9e60fdc2008-02-04 22:28:26 -080086 struct i2c_client *client;
87 struct gpio_chip gpio_chip;
Uwe Kleine-König62154992010-05-26 14:42:17 -070088 const char *const *names;
Haojian Zhuang33226ff2011-04-18 22:12:46 +080089 int chip_type;
eric miao9e60fdc2008-02-04 22:28:26 -080090};
91
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -080092static int pca953x_write_reg(struct pca953x_chip *chip, int reg, uint16_t val)
eric miao9e60fdc2008-02-04 22:28:26 -080093{
Haojian Zhuang33226ff2011-04-18 22:12:46 +080094 int ret = 0;
Guennadi Liakhovetskif5e8ff42008-02-06 01:39:04 -080095
96 if (chip->gpio_chip.ngpio <= 8)
97 ret = i2c_smbus_write_byte_data(chip->client, reg, val);
Haojian Zhuang33226ff2011-04-18 22:12:46 +080098 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 }
Guennadi Liakhovetskif5e8ff42008-02-06 01:39:04 -0800115
116 if (ret < 0) {
117 dev_err(&chip->client->dev, "failed writing register\n");
David Brownellab5dc372009-01-06 14:42:27 -0800118 return ret;
Guennadi Liakhovetskif5e8ff42008-02-06 01:39:04 -0800119 }
120
121 return 0;
eric miao9e60fdc2008-02-04 22:28:26 -0800122}
123
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800124static int pca953x_read_reg(struct pca953x_chip *chip, int reg, uint16_t *val)
eric miao9e60fdc2008-02-04 22:28:26 -0800125{
126 int ret;
127
Guennadi Liakhovetskif5e8ff42008-02-06 01:39:04 -0800128 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
eric miao9e60fdc2008-02-04 22:28:26 -0800133 if (ret < 0) {
134 dev_err(&chip->client->dev, "failed reading register\n");
David Brownellab5dc372009-01-06 14:42:27 -0800135 return ret;
eric miao9e60fdc2008-02-04 22:28:26 -0800136 }
137
138 *val = (uint16_t)ret;
139 return 0;
140}
141
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800142static int pca953x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
eric miao9e60fdc2008-02-04 22:28:26 -0800143{
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800144 struct pca953x_chip *chip;
eric miao9e60fdc2008-02-04 22:28:26 -0800145 uint16_t reg_val;
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800146 int ret, offset = 0;
eric miao9e60fdc2008-02-04 22:28:26 -0800147
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800148 chip = container_of(gc, struct pca953x_chip, gpio_chip);
eric miao9e60fdc2008-02-04 22:28:26 -0800149
Roland Stigge6e20fb12011-02-10 15:01:23 -0800150 mutex_lock(&chip->i2c_lock);
eric miao9e60fdc2008-02-04 22:28:26 -0800151 reg_val = chip->reg_direction | (1u << off);
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800152
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);
eric miao9e60fdc2008-02-04 22:28:26 -0800162 if (ret)
Roland Stigge6e20fb12011-02-10 15:01:23 -0800163 goto exit;
eric miao9e60fdc2008-02-04 22:28:26 -0800164
165 chip->reg_direction = reg_val;
Roland Stigge6e20fb12011-02-10 15:01:23 -0800166 ret = 0;
167exit:
168 mutex_unlock(&chip->i2c_lock);
169 return ret;
eric miao9e60fdc2008-02-04 22:28:26 -0800170}
171
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800172static int pca953x_gpio_direction_output(struct gpio_chip *gc,
eric miao9e60fdc2008-02-04 22:28:26 -0800173 unsigned off, int val)
174{
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800175 struct pca953x_chip *chip;
eric miao9e60fdc2008-02-04 22:28:26 -0800176 uint16_t reg_val;
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800177 int ret, offset = 0;
eric miao9e60fdc2008-02-04 22:28:26 -0800178
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800179 chip = container_of(gc, struct pca953x_chip, gpio_chip);
eric miao9e60fdc2008-02-04 22:28:26 -0800180
Roland Stigge6e20fb12011-02-10 15:01:23 -0800181 mutex_lock(&chip->i2c_lock);
eric miao9e60fdc2008-02-04 22:28:26 -0800182 /* 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
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800188 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);
eric miao9e60fdc2008-02-04 22:28:26 -0800197 if (ret)
Roland Stigge6e20fb12011-02-10 15:01:23 -0800198 goto exit;
eric miao9e60fdc2008-02-04 22:28:26 -0800199
200 chip->reg_output = reg_val;
201
202 /* then direction */
203 reg_val = chip->reg_direction & ~(1u << off);
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800204 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);
eric miao9e60fdc2008-02-04 22:28:26 -0800213 if (ret)
Roland Stigge6e20fb12011-02-10 15:01:23 -0800214 goto exit;
eric miao9e60fdc2008-02-04 22:28:26 -0800215
216 chip->reg_direction = reg_val;
Roland Stigge6e20fb12011-02-10 15:01:23 -0800217 ret = 0;
218exit:
219 mutex_unlock(&chip->i2c_lock);
220 return ret;
eric miao9e60fdc2008-02-04 22:28:26 -0800221}
222
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800223static int pca953x_gpio_get_value(struct gpio_chip *gc, unsigned off)
eric miao9e60fdc2008-02-04 22:28:26 -0800224{
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800225 struct pca953x_chip *chip;
eric miao9e60fdc2008-02-04 22:28:26 -0800226 uint16_t reg_val;
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800227 int ret, offset = 0;
eric miao9e60fdc2008-02-04 22:28:26 -0800228
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800229 chip = container_of(gc, struct pca953x_chip, gpio_chip);
eric miao9e60fdc2008-02-04 22:28:26 -0800230
Roland Stigge6e20fb12011-02-10 15:01:23 -0800231 mutex_lock(&chip->i2c_lock);
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800232 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);
Roland Stigge6e20fb12011-02-10 15:01:23 -0800241 mutex_unlock(&chip->i2c_lock);
eric miao9e60fdc2008-02-04 22:28:26 -0800242 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
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800253static void pca953x_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
eric miao9e60fdc2008-02-04 22:28:26 -0800254{
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800255 struct pca953x_chip *chip;
eric miao9e60fdc2008-02-04 22:28:26 -0800256 uint16_t reg_val;
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800257 int ret, offset = 0;
eric miao9e60fdc2008-02-04 22:28:26 -0800258
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800259 chip = container_of(gc, struct pca953x_chip, gpio_chip);
eric miao9e60fdc2008-02-04 22:28:26 -0800260
Roland Stigge6e20fb12011-02-10 15:01:23 -0800261 mutex_lock(&chip->i2c_lock);
eric miao9e60fdc2008-02-04 22:28:26 -0800262 if (val)
263 reg_val = chip->reg_output | (1u << off);
264 else
265 reg_val = chip->reg_output & ~(1u << off);
266
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800267 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);
eric miao9e60fdc2008-02-04 22:28:26 -0800276 if (ret)
Roland Stigge6e20fb12011-02-10 15:01:23 -0800277 goto exit;
eric miao9e60fdc2008-02-04 22:28:26 -0800278
279 chip->reg_output = reg_val;
Roland Stigge6e20fb12011-02-10 15:01:23 -0800280exit:
281 mutex_unlock(&chip->i2c_lock);
eric miao9e60fdc2008-02-04 22:28:26 -0800282}
283
Guennadi Liakhovetskif5e8ff42008-02-06 01:39:04 -0800284static void pca953x_setup_gpio(struct pca953x_chip *chip, int gpios)
eric miao9e60fdc2008-02-04 22:28:26 -0800285{
286 struct gpio_chip *gc;
287
288 gc = &chip->gpio_chip;
289
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800290 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;
Arnaud Patard84207802008-03-10 11:43:48 -0700294 gc->can_sleep = 1;
eric miao9e60fdc2008-02-04 22:28:26 -0800295
296 gc->base = chip->gpio_start;
Guennadi Liakhovetskif5e8ff42008-02-06 01:39:04 -0800297 gc->ngpio = gpios;
298 gc->label = chip->client->name;
David Brownelld8f388d2008-07-25 01:46:07 -0700299 gc->dev = &chip->client->dev;
Guennadi Liakhovetskid72cbed2008-04-28 02:14:45 -0700300 gc->owner = THIS_MODULE;
Daniel Silverstone77906a542009-06-17 16:26:15 -0700301 gc->names = chip->names;
eric miao9e60fdc2008-02-04 22:28:26 -0800302}
303
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800304#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
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800313static void pca953x_irq_mask(struct irq_data *d)
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800314{
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800315 struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800316
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800317 chip->irq_mask &= ~(1 << (d->irq - chip->irq_base));
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800318}
319
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800320static void pca953x_irq_unmask(struct irq_data *d)
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800321{
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800322 struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800323
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800324 chip->irq_mask |= 1 << (d->irq - chip->irq_base);
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800325}
326
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800327static void pca953x_irq_bus_lock(struct irq_data *d)
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800328{
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800329 struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800330
331 mutex_lock(&chip->irq_lock);
332}
333
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800334static void pca953x_irq_bus_sync_unlock(struct irq_data *d)
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800335{
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800336 struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
Marc Zyngiera2cb9ae2010-04-27 13:13:07 -0700337 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 }
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800349
350 mutex_unlock(&chip->irq_lock);
351}
352
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800353static int pca953x_irq_set_type(struct irq_data *d, unsigned int type)
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800354{
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800355 struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
356 uint16_t level = d->irq - chip->irq_base;
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800357 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",
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800361 d->irq, type);
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800362 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
Marc Zyngiera2cb9ae2010-04-27 13:13:07 -0700375 return 0;
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800376}
377
378static struct irq_chip pca953x_irq_chip = {
379 .name = "pca953x",
Lennert Buytenhek6f5cfc02011-01-12 17:00:15 -0800380 .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,
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800385};
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;
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800393 int ret, offset = 0;
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800394
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800395 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);
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800404 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);
David Jander6dd599f2011-06-08 11:37:45 -0600438 handle_nested_irq(level + chip->irq_base);
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800439
440 pending &= ~(1 << level);
441 } while (pending);
442
443 return IRQ_HANDLED;
444}
445
446static int pca953x_irq_setup(struct pca953x_chip *chip,
David Janderc6dcf592011-06-14 11:00:55 +0200447 const struct i2c_device_id *id,
448 int irq_base)
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800449{
450 struct i2c_client *client = chip->client;
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800451 int ret, offset = 0;
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800452
David Janderc6dcf592011-06-14 11:00:55 +0200453 if (irq_base != -1
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800454 && (id->driver_data & PCA_INT)) {
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800455 int lvl;
456
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800457 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);
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800466 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;
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800475 mutex_init(&chip->irq_lock);
476
David Janderc6dcf592011-06-14 11:00:55 +0200477 chip->irq_base = irq_alloc_descs(-1, irq_base, chip->gpio_chip.ngpio, -1);
David Jander910c8fb2011-06-08 11:34:37 -0600478 if (chip->irq_base < 0)
479 goto out_failed;
480
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800481 for (lvl = 0; lvl < chip->gpio_chip.ngpio; lvl++) {
482 int irq = lvl + chip->irq_base;
483
David Jander910c8fb2011-06-08 11:34:37 -0600484 irq_clear_status_flags(irq, IRQ_NOREQUEST);
Thomas Gleixnerb51804b2011-03-24 21:27:36 +0000485 irq_set_chip_data(irq, chip);
David Jander6dd599f2011-06-08 11:37:45 -0600486 irq_set_chip(irq, &pca953x_irq_chip);
487 irq_set_nested_thread(irq, true);
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800488#ifdef CONFIG_ARM
489 set_irq_flags(irq, IRQF_VALID);
490#else
Thomas Gleixnerb51804b2011-03-24 21:27:36 +0000491 irq_set_noprobe(irq);
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800492#endif
493 }
494
495 ret = request_threaded_irq(client->irq,
496 NULL,
497 pca953x_irq_handler,
David Jander17e8b422011-06-08 11:34:41 -0600498 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800499 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:
Alek Du8a233f012010-10-26 14:22:41 -0700512 chip->irq_base = -1;
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800513 return ret;
514}
515
516static void pca953x_irq_teardown(struct pca953x_chip *chip)
517{
David Janderc609c052011-06-14 11:00:54 +0200518 if (chip->irq_base != -1) {
519 irq_free_descs(chip->irq_base, chip->gpio_chip.ngpio);
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800520 free_irq(chip->client->irq, chip);
David Janderc609c052011-06-14 11:00:54 +0200521 }
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800522}
523#else /* CONFIG_GPIO_PCA953X_IRQ */
524static int pca953x_irq_setup(struct pca953x_chip *chip,
David Janderc6dcf592011-06-14 11:00:55 +0200525 const struct i2c_device_id *id,
526 int irq_base)
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800527{
528 struct i2c_client *client = chip->client;
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800529
David Janderc6dcf592011-06-14 11:00:55 +0200530 if (irq_base != -1 && (id->driver_data & PCA_INT))
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800531 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
Nate Case1965d302009-06-17 16:26:17 -0700541/*
542 * Handlers for alternative sources of platform_data
543 */
544#ifdef CONFIG_OF_GPIO
545/*
546 * Translate OpenFirmware node properties into platform_data
David Jandera57339b2011-06-14 11:00:56 +0200547 * WARNING: This is DEPRECATED and will be removed eventually!
Nate Case1965d302009-06-17 16:26:17 -0700548 */
Mark Brown404ba2b2011-11-21 17:57:25 +0000549static void
David Janderc6dcf592011-06-14 11:00:55 +0200550pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, int *invert)
Nate Case1965d302009-06-17 16:26:17 -0700551{
Nate Case1965d302009-06-17 16:26:17 -0700552 struct device_node *node;
Dirk Eibach16482372011-02-24 10:20:43 +0100553 const __be32 *val;
554 int size;
Nate Case1965d302009-06-17 16:26:17 -0700555
Grant Likely61c7a082010-04-13 16:12:29 -0700556 node = client->dev.of_node;
Nate Case1965d302009-06-17 16:26:17 -0700557 if (node == NULL)
David Janderc6dcf592011-06-14 11:00:55 +0200558 return;
Nate Case1965d302009-06-17 16:26:17 -0700559
David Janderc6dcf592011-06-14 11:00:55 +0200560 *gpio_base = -1;
Dirk Eibach16482372011-02-24 10:20:43 +0100561 val = of_get_property(node, "linux,gpio-base", &size);
David Jandera57339b2011-06-14 11:00:56 +0200562 WARN(val, "%s: device-tree property 'linux,gpio-base' is deprecated!", __func__);
Nate Case1965d302009-06-17 16:26:17 -0700563 if (val) {
Dirk Eibach16482372011-02-24 10:20:43 +0100564 if (size != sizeof(*val))
565 dev_warn(&client->dev, "%s: wrong linux,gpio-base\n",
566 node->full_name);
Nate Case1965d302009-06-17 16:26:17 -0700567 else
David Janderc6dcf592011-06-14 11:00:55 +0200568 *gpio_base = be32_to_cpup(val);
Nate Case1965d302009-06-17 16:26:17 -0700569 }
570
571 val = of_get_property(node, "polarity", NULL);
David Jandera57339b2011-06-14 11:00:56 +0200572 WARN(val, "%s: device-tree property 'polarity' is deprecated!", __func__);
Nate Case1965d302009-06-17 16:26:17 -0700573 if (val)
David Janderc6dcf592011-06-14 11:00:55 +0200574 *invert = *val;
Nate Case1965d302009-06-17 16:26:17 -0700575}
576#else
Mark Brown404ba2b2011-11-21 17:57:25 +0000577static void
David Janderc6dcf592011-06-14 11:00:55 +0200578pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, int *invert)
Nate Case1965d302009-06-17 16:26:17 -0700579{
Hartmut Knaack25fcf2b2011-10-11 00:22:45 +0200580 *gpio_base = -1;
Nate Case1965d302009-06-17 16:26:17 -0700581}
582#endif
583
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800584static 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);
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800599out:
600 return ret;
601}
602
603static int __devinit device_pca957x_init(struct pca953x_chip *chip, int invert)
604{
605 int ret;
606 uint16_t val = 0;
607
608 /* Let every port in proper state, that could save power */
609 pca953x_write_reg(chip, PCA957X_PUPD, 0x0);
610 pca953x_write_reg(chip, PCA957X_CFG, 0xffff);
611 pca953x_write_reg(chip, PCA957X_OUT, 0x0);
612
613 ret = pca953x_read_reg(chip, PCA957X_IN, &val);
614 if (ret)
615 goto out;
616 ret = pca953x_read_reg(chip, PCA957X_OUT, &chip->reg_output);
617 if (ret)
618 goto out;
619 ret = pca953x_read_reg(chip, PCA957X_CFG, &chip->reg_direction);
620 if (ret)
621 goto out;
622
623 /* set platform specific polarity inversion */
624 pca953x_write_reg(chip, PCA957X_INVRT, invert);
625
626 /* To enable register 6, 7 to controll pull up and pull down */
627 pca953x_write_reg(chip, PCA957X_BKEN, 0x202);
628
629 return 0;
630out:
631 return ret;
632}
633
Jean Delvared2653e92008-04-29 23:11:39 +0200634static int __devinit pca953x_probe(struct i2c_client *client,
Jean Delvare3760f732008-04-29 23:11:40 +0200635 const struct i2c_device_id *id)
eric miao9e60fdc2008-02-04 22:28:26 -0800636{
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800637 struct pca953x_platform_data *pdata;
638 struct pca953x_chip *chip;
David Jandera57339b2011-06-14 11:00:56 +0200639 int irq_base=0, invert=0;
Wolfram Sang7ea2aa22011-10-14 15:32:00 +0200640 int ret;
eric miao9e60fdc2008-02-04 22:28:26 -0800641
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800642 chip = kzalloc(sizeof(struct pca953x_chip), GFP_KERNEL);
eric miao9e60fdc2008-02-04 22:28:26 -0800643 if (chip == NULL)
644 return -ENOMEM;
645
Nate Case1965d302009-06-17 16:26:17 -0700646 pdata = client->dev.platform_data;
David Janderc6dcf592011-06-14 11:00:55 +0200647 if (pdata) {
648 irq_base = pdata->irq_base;
649 chip->gpio_start = pdata->gpio_base;
650 invert = pdata->invert;
651 chip->names = pdata->names;
652 } else {
653 pca953x_get_alt_pdata(client, &chip->gpio_start, &invert);
David Jandera57339b2011-06-14 11:00:56 +0200654#ifdef CONFIG_OF_GPIO
655 /* If I2C node has no interrupts property, disable GPIO interrupts */
656 if (of_find_property(client->dev.of_node, "interrupts", NULL) == NULL)
657 irq_base = -1;
658#endif
Nate Case1965d302009-06-17 16:26:17 -0700659 }
660
eric miao9e60fdc2008-02-04 22:28:26 -0800661 chip->client = client;
662
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800663 chip->chip_type = id->driver_data & (PCA953X_TYPE | PCA957X_TYPE);
Daniel Silverstone77906a542009-06-17 16:26:15 -0700664
Roland Stigge6e20fb12011-02-10 15:01:23 -0800665 mutex_init(&chip->i2c_lock);
666
eric miao9e60fdc2008-02-04 22:28:26 -0800667 /* initialize cached registers from their original values.
668 * we can't share this chip with another i2c master.
669 */
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800670 pca953x_setup_gpio(chip, id->driver_data & PCA_GPIO_MASK);
Guennadi Liakhovetskif5e8ff42008-02-06 01:39:04 -0800671
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800672 if (chip->chip_type == PCA953X_TYPE)
Wolfram Sang7ea2aa22011-10-14 15:32:00 +0200673 ret = device_pca953x_init(chip, invert);
Haojian Zhuang33226ff2011-04-18 22:12:46 +0800674 else
Wolfram Sang7ea2aa22011-10-14 15:32:00 +0200675 ret = device_pca957x_init(chip, invert);
676 if (ret)
eric miao9e60fdc2008-02-04 22:28:26 -0800677 goto out_failed;
678
David Janderc6dcf592011-06-14 11:00:55 +0200679 ret = pca953x_irq_setup(chip, id, irq_base);
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800680 if (ret)
681 goto out_failed;
Guennadi Liakhovetskif5e8ff42008-02-06 01:39:04 -0800682
683 ret = gpiochip_add(&chip->gpio_chip);
eric miao9e60fdc2008-02-04 22:28:26 -0800684 if (ret)
Ben Dooks272df502011-03-31 07:18:46 +0900685 goto out_failed_irq;
eric miao9e60fdc2008-02-04 22:28:26 -0800686
David Janderc6dcf592011-06-14 11:00:55 +0200687 if (pdata && pdata->setup) {
eric miao9e60fdc2008-02-04 22:28:26 -0800688 ret = pdata->setup(client, chip->gpio_chip.base,
689 chip->gpio_chip.ngpio, pdata->context);
690 if (ret < 0)
691 dev_warn(&client->dev, "setup failed, %d\n", ret);
692 }
693
694 i2c_set_clientdata(client, chip);
695 return 0;
696
Ben Dooks272df502011-03-31 07:18:46 +0900697out_failed_irq:
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800698 pca953x_irq_teardown(chip);
Ben Dooks272df502011-03-31 07:18:46 +0900699out_failed:
eric miao9e60fdc2008-02-04 22:28:26 -0800700 kfree(chip);
701 return ret;
702}
703
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800704static int pca953x_remove(struct i2c_client *client)
eric miao9e60fdc2008-02-04 22:28:26 -0800705{
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800706 struct pca953x_platform_data *pdata = client->dev.platform_data;
707 struct pca953x_chip *chip = i2c_get_clientdata(client);
eric miao9e60fdc2008-02-04 22:28:26 -0800708 int ret = 0;
709
David Janderc6dcf592011-06-14 11:00:55 +0200710 if (pdata && pdata->teardown) {
eric miao9e60fdc2008-02-04 22:28:26 -0800711 ret = pdata->teardown(client, chip->gpio_chip.base,
712 chip->gpio_chip.ngpio, pdata->context);
713 if (ret < 0) {
714 dev_err(&client->dev, "%s failed, %d\n",
715 "teardown", ret);
716 return ret;
717 }
718 }
719
720 ret = gpiochip_remove(&chip->gpio_chip);
721 if (ret) {
722 dev_err(&client->dev, "%s failed, %d\n",
723 "gpiochip_remove()", ret);
724 return ret;
725 }
726
Marc Zyngier89ea8bb2010-03-05 13:44:36 -0800727 pca953x_irq_teardown(chip);
eric miao9e60fdc2008-02-04 22:28:26 -0800728 kfree(chip);
729 return 0;
730}
731
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800732static struct i2c_driver pca953x_driver = {
eric miao9e60fdc2008-02-04 22:28:26 -0800733 .driver = {
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800734 .name = "pca953x",
eric miao9e60fdc2008-02-04 22:28:26 -0800735 },
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800736 .probe = pca953x_probe,
737 .remove = pca953x_remove,
Jean Delvare3760f732008-04-29 23:11:40 +0200738 .id_table = pca953x_id,
eric miao9e60fdc2008-02-04 22:28:26 -0800739};
740
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800741static int __init pca953x_init(void)
eric miao9e60fdc2008-02-04 22:28:26 -0800742{
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800743 return i2c_add_driver(&pca953x_driver);
eric miao9e60fdc2008-02-04 22:28:26 -0800744}
David Brownell2f8d1192008-10-15 22:03:13 -0700745/* register after i2c postcore initcall and before
746 * subsys initcalls that may rely on these GPIOs
747 */
748subsys_initcall(pca953x_init);
eric miao9e60fdc2008-02-04 22:28:26 -0800749
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800750static void __exit pca953x_exit(void)
eric miao9e60fdc2008-02-04 22:28:26 -0800751{
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800752 i2c_del_driver(&pca953x_driver);
eric miao9e60fdc2008-02-04 22:28:26 -0800753}
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800754module_exit(pca953x_exit);
eric miao9e60fdc2008-02-04 22:28:26 -0800755
756MODULE_AUTHOR("eric miao <eric.miao@marvell.com>");
Guennadi Liakhovetskif3dc3632008-02-06 01:39:03 -0800757MODULE_DESCRIPTION("GPIO expander driver for PCA953x");
eric miao9e60fdc2008-02-04 22:28:26 -0800758MODULE_LICENSE("GPL");