blob: 1d4d9bc8b69db5cbacd1280fb5ff8c58fe25eea0 [file] [log] [blame]
David Brownell15fae372008-02-04 22:28:24 -08001/*
Grant Likelyc103de22011-06-04 18:38:28 -06002 * Driver for pcf857x, pca857x, and pca967x I2C GPIO expanders
David Brownell15fae372008-02-04 22:28:24 -08003 *
4 * Copyright (C) 2007 David Brownell
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
H Hartley Sweetend120c172009-09-22 16:46:37 -070021#include <linux/gpio.h>
David Brownell15fae372008-02-04 22:28:24 -080022#include <linux/i2c.h>
23#include <linux/i2c/pcf857x.h>
Kuninori Morimoto6e20a0a2012-06-14 19:40:41 -070024#include <linux/interrupt.h>
25#include <linux/irq.h>
26#include <linux/irqdomain.h>
Laurent Pinchartc990d6c2013-08-20 01:04:52 +020027#include <linux/kernel.h>
Paul Gortmakerbb207ef2011-07-03 13:38:09 -040028#include <linux/module.h>
Laurent Pinchart63f57cd2013-09-21 20:39:49 +020029#include <linux/of.h>
30#include <linux/of_device.h>
Laurent Pinchartc990d6c2013-08-20 01:04:52 +020031#include <linux/slab.h>
Kuninori Morimoto6e20a0a2012-06-14 19:40:41 -070032#include <linux/spinlock.h>
David Brownell15fae372008-02-04 22:28:24 -080033
David Brownell15fae372008-02-04 22:28:24 -080034
Jean Delvare3760f732008-04-29 23:11:40 +020035static const struct i2c_device_id pcf857x_id[] = {
36 { "pcf8574", 8 },
Wolfram Sang4ba2ccb2009-09-18 22:45:47 +020037 { "pcf8574a", 8 },
Jean Delvare3760f732008-04-29 23:11:40 +020038 { "pca8574", 8 },
39 { "pca9670", 8 },
40 { "pca9672", 8 },
41 { "pca9674", 8 },
42 { "pcf8575", 16 },
43 { "pca8575", 16 },
44 { "pca9671", 16 },
45 { "pca9673", 16 },
46 { "pca9675", 16 },
David Brownell1673ad52008-07-21 14:21:34 -070047 { "max7328", 8 },
48 { "max7329", 8 },
Nikolay Balandin02130492013-03-06 15:06:44 +040049 { "tca9554", 8 },
Jean Delvare3760f732008-04-29 23:11:40 +020050 { }
51};
52MODULE_DEVICE_TABLE(i2c, pcf857x_id);
53
Laurent Pinchart63f57cd2013-09-21 20:39:49 +020054#ifdef CONFIG_OF
55static const struct of_device_id pcf857x_of_table[] = {
56 { .compatible = "nxp,pcf8574" },
57 { .compatible = "nxp,pcf8574a" },
58 { .compatible = "nxp,pca8574" },
59 { .compatible = "nxp,pca9670" },
60 { .compatible = "nxp,pca9672" },
61 { .compatible = "nxp,pca9674" },
62 { .compatible = "nxp,pcf8575" },
63 { .compatible = "nxp,pca8575" },
64 { .compatible = "nxp,pca9671" },
65 { .compatible = "nxp,pca9673" },
66 { .compatible = "nxp,pca9675" },
67 { .compatible = "maxim,max7328" },
68 { .compatible = "maxim,max7329" },
69 { .compatible = "ti,tca9554" },
70 { }
71};
72MODULE_DEVICE_TABLE(of, pcf857x_of_table);
73#endif
74
David Brownell15fae372008-02-04 22:28:24 -080075/*
76 * The pcf857x, pca857x, and pca967x chips only expose one read and one
77 * write register. Writing a "one" bit (to match the reset state) lets
78 * that pin be used as an input; it's not an open-drain model, but acts
79 * a bit like one. This is described as "quasi-bidirectional"; read the
80 * chip documentation for details.
81 *
82 * Many other I2C GPIO expander chips (like the pca953x models) have
83 * more complex register models and more conventional circuitry using
84 * push/pull drivers. They often use the same 0x20..0x27 addresses as
85 * pcf857x parts, making the "legacy" I2C driver model problematic.
86 */
87struct pcf857x {
88 struct gpio_chip chip;
89 struct i2c_client *client;
David Brownell1673ad52008-07-21 14:21:34 -070090 struct mutex lock; /* protect 'out' */
David Brownell15fae372008-02-04 22:28:24 -080091 unsigned out; /* software latch */
Kuninori Morimoto6e20a0a2012-06-14 19:40:41 -070092 unsigned status; /* current status */
Geert Uytterhoevenffb8e442015-05-26 13:34:02 +020093 unsigned int irq_parent;
Grygorii Strashko84f28992015-06-11 00:01:09 +030094 unsigned irq_enabled; /* enabled irqs */
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -070095
96 int (*write)(struct i2c_client *client, unsigned data);
97 int (*read)(struct i2c_client *client);
David Brownell15fae372008-02-04 22:28:24 -080098};
99
100/*-------------------------------------------------------------------------*/
101
102/* Talk to 8-bit I/O expander */
103
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700104static int i2c_write_le8(struct i2c_client *client, unsigned data)
David Brownell15fae372008-02-04 22:28:24 -0800105{
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700106 return i2c_smbus_write_byte(client, data);
David Brownell15fae372008-02-04 22:28:24 -0800107}
108
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700109static int i2c_read_le8(struct i2c_client *client)
David Brownell15fae372008-02-04 22:28:24 -0800110{
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700111 return (int)i2c_smbus_read_byte(client);
David Brownell15fae372008-02-04 22:28:24 -0800112}
113
David Brownell15fae372008-02-04 22:28:24 -0800114/* Talk to 16-bit I/O expander */
115
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700116static int i2c_write_le16(struct i2c_client *client, unsigned word)
David Brownell15fae372008-02-04 22:28:24 -0800117{
118 u8 buf[2] = { word & 0xff, word >> 8, };
119 int status;
120
121 status = i2c_master_send(client, buf, 2);
122 return (status < 0) ? status : 0;
123}
124
125static int i2c_read_le16(struct i2c_client *client)
126{
127 u8 buf[2];
128 int status;
129
130 status = i2c_master_recv(client, buf, 2);
131 if (status < 0)
132 return status;
133 return (buf[1] << 8) | buf[0];
134}
135
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700136/*-------------------------------------------------------------------------*/
137
138static int pcf857x_input(struct gpio_chip *chip, unsigned offset)
David Brownell15fae372008-02-04 22:28:24 -0800139{
140 struct pcf857x *gpio = container_of(chip, struct pcf857x, chip);
David Brownell1673ad52008-07-21 14:21:34 -0700141 int status;
David Brownell15fae372008-02-04 22:28:24 -0800142
David Brownell1673ad52008-07-21 14:21:34 -0700143 mutex_lock(&gpio->lock);
David Brownell15fae372008-02-04 22:28:24 -0800144 gpio->out |= (1 << offset);
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700145 status = gpio->write(gpio->client, gpio->out);
David Brownell1673ad52008-07-21 14:21:34 -0700146 mutex_unlock(&gpio->lock);
147
148 return status;
David Brownell15fae372008-02-04 22:28:24 -0800149}
150
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700151static int pcf857x_get(struct gpio_chip *chip, unsigned offset)
David Brownell15fae372008-02-04 22:28:24 -0800152{
153 struct pcf857x *gpio = container_of(chip, struct pcf857x, chip);
154 int value;
155
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700156 value = gpio->read(gpio->client);
David Brownell15fae372008-02-04 22:28:24 -0800157 return (value < 0) ? 0 : (value & (1 << offset));
158}
159
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700160static int pcf857x_output(struct gpio_chip *chip, unsigned offset, int value)
David Brownell15fae372008-02-04 22:28:24 -0800161{
162 struct pcf857x *gpio = container_of(chip, struct pcf857x, chip);
163 unsigned bit = 1 << offset;
David Brownell1673ad52008-07-21 14:21:34 -0700164 int status;
David Brownell15fae372008-02-04 22:28:24 -0800165
David Brownell1673ad52008-07-21 14:21:34 -0700166 mutex_lock(&gpio->lock);
David Brownell15fae372008-02-04 22:28:24 -0800167 if (value)
168 gpio->out |= bit;
169 else
170 gpio->out &= ~bit;
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700171 status = gpio->write(gpio->client, gpio->out);
David Brownell1673ad52008-07-21 14:21:34 -0700172 mutex_unlock(&gpio->lock);
173
174 return status;
David Brownell15fae372008-02-04 22:28:24 -0800175}
176
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700177static void pcf857x_set(struct gpio_chip *chip, unsigned offset, int value)
David Brownell15fae372008-02-04 22:28:24 -0800178{
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700179 pcf857x_output(chip, offset, value);
David Brownell15fae372008-02-04 22:28:24 -0800180}
181
182/*-------------------------------------------------------------------------*/
183
George Cherian5c21d002013-09-04 12:33:01 +0530184static irqreturn_t pcf857x_irq(int irq, void *data)
185{
186 struct pcf857x *gpio = data;
Grygorii Strashko049aaf92015-06-25 18:18:11 +0300187 unsigned long change, i, status;
George Cherian5c21d002013-09-04 12:33:01 +0530188
189 status = gpio->read(gpio->client);
190
George Cherian21fd3cd2013-09-04 12:33:03 +0530191 /*
192 * call the interrupt handler iff gpio is used as
193 * interrupt source, just to avoid bad irqs
194 */
Grygorii Strashko049aaf92015-06-25 18:18:11 +0300195 mutex_lock(&gpio->lock);
Grygorii Strashko84f28992015-06-11 00:01:09 +0300196 change = (gpio->status ^ status) & gpio->irq_enabled;
Grygorii Strashko049aaf92015-06-25 18:18:11 +0300197 gpio->status = status;
198 mutex_unlock(&gpio->lock);
199
George Cherian5c21d002013-09-04 12:33:01 +0530200 for_each_set_bit(i, &change, gpio->chip.ngpio)
Geert Uytterhoevena39294b2015-02-05 16:49:08 +0100201 handle_nested_irq(irq_find_mapping(gpio->chip.irqdomain, i));
George Cherian5c21d002013-09-04 12:33:01 +0530202
203 return IRQ_HANDLED;
204}
205
Geert Uytterhoevenb80eef92015-02-05 16:49:09 +0100206/*
207 * NOP functions
208 */
209static void noop(struct irq_data *data) { }
210
Geert Uytterhoevenb80eef92015-02-05 16:49:09 +0100211static int pcf857x_irq_set_wake(struct irq_data *data, unsigned int on)
212{
213 struct pcf857x *gpio = irq_data_get_irq_chip_data(data);
Grygorii Strashko84f28992015-06-11 00:01:09 +0300214
Geert Uytterhoevenffb8e442015-05-26 13:34:02 +0200215 int error = 0;
Geert Uytterhoevenb80eef92015-02-05 16:49:09 +0100216
Geert Uytterhoevenffb8e442015-05-26 13:34:02 +0200217 if (gpio->irq_parent) {
218 error = irq_set_irq_wake(gpio->irq_parent, on);
219 if (error) {
220 dev_dbg(&gpio->client->dev,
221 "irq %u doesn't support irq_set_wake\n",
222 gpio->irq_parent);
223 gpio->irq_parent = 0;
224 }
225 }
Geert Uytterhoevenffb8e442015-05-26 13:34:02 +0200226 return error;
Geert Uytterhoevenb80eef92015-02-05 16:49:09 +0100227}
228
Grygorii Strashko84f28992015-06-11 00:01:09 +0300229static void pcf857x_irq_enable(struct irq_data *data)
230{
231 struct pcf857x *gpio = irq_data_get_irq_chip_data(data);
232
233 gpio->irq_enabled |= (1 << data->hwirq);
234}
235
236static void pcf857x_irq_disable(struct irq_data *data)
237{
238 struct pcf857x *gpio = irq_data_get_irq_chip_data(data);
239
240 gpio->irq_enabled &= ~(1 << data->hwirq);
241}
242
243static void pcf857x_irq_bus_lock(struct irq_data *data)
244{
245 struct pcf857x *gpio = irq_data_get_irq_chip_data(data);
246
247 mutex_lock(&gpio->lock);
248}
249
250static void pcf857x_irq_bus_sync_unlock(struct irq_data *data)
251{
252 struct pcf857x *gpio = irq_data_get_irq_chip_data(data);
253
254 mutex_unlock(&gpio->lock);
255}
256
Geert Uytterhoevenb80eef92015-02-05 16:49:09 +0100257static struct irq_chip pcf857x_irq_chip = {
258 .name = "pcf857x",
Grygorii Strashko84f28992015-06-11 00:01:09 +0300259 .irq_enable = pcf857x_irq_enable,
260 .irq_disable = pcf857x_irq_disable,
Geert Uytterhoevenb80eef92015-02-05 16:49:09 +0100261 .irq_ack = noop,
262 .irq_mask = noop,
263 .irq_unmask = noop,
264 .irq_set_wake = pcf857x_irq_set_wake,
Grygorii Strashko84f28992015-06-11 00:01:09 +0300265 .irq_bus_lock = pcf857x_irq_bus_lock,
266 .irq_bus_sync_unlock = pcf857x_irq_bus_sync_unlock,
Geert Uytterhoevenb80eef92015-02-05 16:49:09 +0100267};
268
Kuninori Morimoto6e20a0a2012-06-14 19:40:41 -0700269/*-------------------------------------------------------------------------*/
270
Jean Delvared2653e92008-04-29 23:11:39 +0200271static int pcf857x_probe(struct i2c_client *client,
272 const struct i2c_device_id *id)
David Brownell15fae372008-02-04 22:28:24 -0800273{
Laurent Pinchart63f57cd2013-09-21 20:39:49 +0200274 struct pcf857x_platform_data *pdata = dev_get_platdata(&client->dev);
275 struct device_node *np = client->dev.of_node;
David Brownell15fae372008-02-04 22:28:24 -0800276 struct pcf857x *gpio;
Laurent Pinchart63f57cd2013-09-21 20:39:49 +0200277 unsigned int n_latch = 0;
David Brownell15fae372008-02-04 22:28:24 -0800278 int status;
279
Laurent Pinchart63f57cd2013-09-21 20:39:49 +0200280 if (IS_ENABLED(CONFIG_OF) && np)
281 of_property_read_u32(np, "lines-initial-states", &n_latch);
282 else if (pdata)
283 n_latch = pdata->n_latch;
284 else
Ben Dooksa342d212009-01-15 13:50:45 -0800285 dev_dbg(&client->dev, "no platform data\n");
David Brownell15fae372008-02-04 22:28:24 -0800286
287 /* Allocate, initialize, and register this gpio_chip. */
Jingoo Hanf39f54a2013-03-15 18:16:11 +0900288 gpio = devm_kzalloc(&client->dev, sizeof(*gpio), GFP_KERNEL);
David Brownell15fae372008-02-04 22:28:24 -0800289 if (!gpio)
290 return -ENOMEM;
291
David Brownell1673ad52008-07-21 14:21:34 -0700292 mutex_init(&gpio->lock);
293
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700294 gpio->chip.base = pdata ? pdata->gpio_base : -1;
Linus Walleij9fb1f392013-12-04 14:42:46 +0100295 gpio->chip.can_sleep = true;
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700296 gpio->chip.dev = &client->dev;
297 gpio->chip.owner = THIS_MODULE;
298 gpio->chip.get = pcf857x_get;
299 gpio->chip.set = pcf857x_set;
300 gpio->chip.direction_input = pcf857x_input;
301 gpio->chip.direction_output = pcf857x_output;
302 gpio->chip.ngpio = id->driver_data;
David Brownell15fae372008-02-04 22:28:24 -0800303
304 /* NOTE: the OnSemi jlc1562b is also largely compatible with
305 * these parts, notably for output. It has a low-resolution
306 * DAC instead of pin change IRQs; and its inputs can be the
307 * result of comparators.
308 */
309
310 /* 8574 addresses are 0x20..0x27; 8574a uses 0x38..0x3f;
311 * 9670, 9672, 9764, and 9764a use quite a variety.
312 *
313 * NOTE: we don't distinguish here between *4 and *4a parts.
314 */
Jean Delvare3760f732008-04-29 23:11:40 +0200315 if (gpio->chip.ngpio == 8) {
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700316 gpio->write = i2c_write_le8;
317 gpio->read = i2c_read_le8;
David Brownell15fae372008-02-04 22:28:24 -0800318
319 if (!i2c_check_functionality(client->adapter,
320 I2C_FUNC_SMBUS_BYTE))
321 status = -EIO;
322
323 /* fail if there's no chip present */
324 else
325 status = i2c_smbus_read_byte(client);
326
327 /* '75/'75c addresses are 0x20..0x27, just like the '74;
328 * the '75c doesn't have a current source pulling high.
329 * 9671, 9673, and 9765 use quite a variety of addresses.
330 *
331 * NOTE: we don't distinguish here between '75 and '75c parts.
332 */
Jean Delvare3760f732008-04-29 23:11:40 +0200333 } else if (gpio->chip.ngpio == 16) {
Kuninori Morimoto0c65ddd2012-06-13 21:58:08 -0700334 gpio->write = i2c_write_le16;
335 gpio->read = i2c_read_le16;
David Brownell15fae372008-02-04 22:28:24 -0800336
337 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
338 status = -EIO;
339
340 /* fail if there's no chip present */
341 else
342 status = i2c_read_le16(client);
343
Ben Dooksa342d212009-01-15 13:50:45 -0800344 } else {
345 dev_dbg(&client->dev, "unsupported number of gpios\n");
346 status = -EINVAL;
347 }
David Brownell15fae372008-02-04 22:28:24 -0800348
349 if (status < 0)
350 goto fail;
351
352 gpio->chip.label = client->name;
353
354 gpio->client = client;
355 i2c_set_clientdata(client, gpio);
356
357 /* NOTE: these chips have strange "quasi-bidirectional" I/O pins.
358 * We can't actually know whether a pin is configured (a) as output
359 * and driving the signal low, or (b) as input and reporting a low
360 * value ... without knowing the last value written since the chip
361 * came out of reset (if any). We can't read the latched output.
362 *
363 * In short, the only reliable solution for setting up pin direction
364 * is to do it explicitly. The setup() method can do that, but it
365 * may cause transient glitching since it can't know the last value
366 * written (some pins may need to be driven low).
367 *
Laurent Pinchart63f57cd2013-09-21 20:39:49 +0200368 * Using n_latch avoids that trouble. When left initialized to zero,
369 * our software copy of the "latch" then matches the chip's all-ones
370 * reset state. Otherwise it flags pins to be driven low.
David Brownell15fae372008-02-04 22:28:24 -0800371 */
Laurent Pinchart63f57cd2013-09-21 20:39:49 +0200372 gpio->out = ~n_latch;
Kuninori Morimoto6e20a0a2012-06-14 19:40:41 -0700373 gpio->status = gpio->out;
David Brownell15fae372008-02-04 22:28:24 -0800374
375 status = gpiochip_add(&gpio->chip);
376 if (status < 0)
377 goto fail;
378
Geert Uytterhoevena39294b2015-02-05 16:49:08 +0100379 /* Enable irqchip if we have an interrupt */
380 if (client->irq) {
Geert Uytterhoevenb80eef92015-02-05 16:49:09 +0100381 status = gpiochip_irqchip_add(&gpio->chip, &pcf857x_irq_chip,
382 0, handle_level_irq,
383 IRQ_TYPE_NONE);
Geert Uytterhoevena39294b2015-02-05 16:49:08 +0100384 if (status) {
385 dev_err(&client->dev, "cannot add irqchip\n");
386 goto fail_irq;
387 }
388
389 status = devm_request_threaded_irq(&client->dev, client->irq,
390 NULL, pcf857x_irq, IRQF_ONESHOT |
391 IRQF_TRIGGER_FALLING | IRQF_SHARED,
392 dev_name(&client->dev), gpio);
393 if (status)
394 goto fail_irq;
395
Geert Uytterhoevenb80eef92015-02-05 16:49:09 +0100396 gpiochip_set_chained_irqchip(&gpio->chip, &pcf857x_irq_chip,
Geert Uytterhoevena39294b2015-02-05 16:49:08 +0100397 client->irq, NULL);
Geert Uytterhoevenffb8e442015-05-26 13:34:02 +0200398 gpio->irq_parent = client->irq;
Geert Uytterhoevena39294b2015-02-05 16:49:08 +0100399 }
400
David Brownell15fae372008-02-04 22:28:24 -0800401 /* Let platform code set up the GPIOs and their users.
402 * Now is the first time anyone could use them.
403 */
Dmitry Eremin-Solenikov49946f62010-08-10 18:02:24 -0700404 if (pdata && pdata->setup) {
David Brownell15fae372008-02-04 22:28:24 -0800405 status = pdata->setup(client,
406 gpio->chip.base, gpio->chip.ngpio,
407 pdata->context);
408 if (status < 0)
409 dev_warn(&client->dev, "setup --> %d\n", status);
410 }
411
Kuninori Morimoto805f8642012-12-06 01:10:28 -0800412 dev_info(&client->dev, "probed\n");
413
David Brownell15fae372008-02-04 22:28:24 -0800414 return 0;
415
Geert Uytterhoevena39294b2015-02-05 16:49:08 +0100416fail_irq:
417 gpiochip_remove(&gpio->chip);
Kuninori Morimoto6e20a0a2012-06-14 19:40:41 -0700418
Geert Uytterhoevena39294b2015-02-05 16:49:08 +0100419fail:
420 dev_dbg(&client->dev, "probe error %d for '%s'\n", status,
421 client->name);
George Cheriane6b698f2014-05-23 11:27:26 +0530422
David Brownell15fae372008-02-04 22:28:24 -0800423 return status;
424}
425
426static int pcf857x_remove(struct i2c_client *client)
427{
Jingoo Hane56aee12013-07-30 17:08:05 +0900428 struct pcf857x_platform_data *pdata = dev_get_platdata(&client->dev);
David Brownell15fae372008-02-04 22:28:24 -0800429 struct pcf857x *gpio = i2c_get_clientdata(client);
430 int status = 0;
431
Dmitry Eremin-Solenikov49946f62010-08-10 18:02:24 -0700432 if (pdata && pdata->teardown) {
David Brownell15fae372008-02-04 22:28:24 -0800433 status = pdata->teardown(client,
434 gpio->chip.base, gpio->chip.ngpio,
435 pdata->context);
436 if (status < 0) {
437 dev_err(&client->dev, "%s --> %d\n",
438 "teardown", status);
439 return status;
440 }
441 }
442
abdoulaye berthe9f5132a2014-07-12 22:30:12 +0200443 gpiochip_remove(&gpio->chip);
David Brownell15fae372008-02-04 22:28:24 -0800444 return status;
445}
446
447static struct i2c_driver pcf857x_driver = {
448 .driver = {
449 .name = "pcf857x",
450 .owner = THIS_MODULE,
Laurent Pinchart63f57cd2013-09-21 20:39:49 +0200451 .of_match_table = of_match_ptr(pcf857x_of_table),
David Brownell15fae372008-02-04 22:28:24 -0800452 },
453 .probe = pcf857x_probe,
454 .remove = pcf857x_remove,
Jean Delvare3760f732008-04-29 23:11:40 +0200455 .id_table = pcf857x_id,
David Brownell15fae372008-02-04 22:28:24 -0800456};
457
458static int __init pcf857x_init(void)
459{
460 return i2c_add_driver(&pcf857x_driver);
461}
David Brownell2f8d1192008-10-15 22:03:13 -0700462/* register after i2c postcore initcall and before
463 * subsys initcalls that may rely on these GPIOs
464 */
465subsys_initcall(pcf857x_init);
David Brownell15fae372008-02-04 22:28:24 -0800466
467static void __exit pcf857x_exit(void)
468{
469 i2c_del_driver(&pcf857x_driver);
470}
471module_exit(pcf857x_exit);
472
473MODULE_LICENSE("GPL");
474MODULE_AUTHOR("David Brownell");