gpio: tegra: Iterate over the correct number of banks
[linux-2.6.git] / drivers / gpio / gpio-pca953x.c
1 /*
2  *  PCA953x 4/8/16 bit I/O ports
3  *
4  *  Copyright (C) 2005 Ben Gardner <bgardner@wabtec.com>
5  *  Copyright (C) 2007 Marvell International Ltd.
6  *
7  *  Derived from drivers/i2c/chips/pca9539.c
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; version 2 of the License.
12  */
13
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/gpio.h>
17 #include <linux/interrupt.h>
18 #include <linux/irq.h>
19 #include <linux/i2c.h>
20 #include <linux/i2c/pca953x.h>
21 #include <linux/slab.h>
22 #ifdef CONFIG_OF_GPIO
23 #include <linux/of_platform.h>
24 #endif
25
26 #define PCA953X_INPUT           0
27 #define PCA953X_OUTPUT          1
28 #define PCA953X_INVERT          2
29 #define PCA953X_DIRECTION       3
30
31 #define PCA957X_IN              0
32 #define PCA957X_INVRT           1
33 #define PCA957X_BKEN            2
34 #define PCA957X_PUPD            3
35 #define PCA957X_CFG             4
36 #define PCA957X_OUT             5
37 #define PCA957X_MSK             6
38 #define PCA957X_INTS            7
39
40 #define PCA_GPIO_MASK           0x00FF
41 #define PCA_INT                 0x0100
42 #define PCA953X_TYPE            0x1000
43 #define PCA957X_TYPE            0x2000
44
45 static const struct i2c_device_id pca953x_id[] = {
46         { "pca9534", 8  | PCA953X_TYPE | PCA_INT, },
47         { "pca9535", 16 | PCA953X_TYPE | PCA_INT, },
48         { "pca9536", 4  | PCA953X_TYPE, },
49         { "pca9537", 4  | PCA953X_TYPE | PCA_INT, },
50         { "pca9538", 8  | PCA953X_TYPE | PCA_INT, },
51         { "pca9539", 16 | PCA953X_TYPE | PCA_INT, },
52         { "pca9554", 8  | PCA953X_TYPE | PCA_INT, },
53         { "pca9555", 16 | PCA953X_TYPE | PCA_INT, },
54         { "pca9556", 8  | PCA953X_TYPE, },
55         { "pca9557", 8  | PCA953X_TYPE, },
56         { "pca9574", 8  | PCA957X_TYPE | PCA_INT, },
57         { "pca9575", 16 | PCA957X_TYPE | PCA_INT, },
58
59         { "max7310", 8  | PCA953X_TYPE, },
60         { "max7312", 16 | PCA953X_TYPE | PCA_INT, },
61         { "max7313", 16 | PCA953X_TYPE | PCA_INT, },
62         { "max7315", 8  | PCA953X_TYPE | PCA_INT, },
63         { "pca6107", 8  | PCA953X_TYPE | PCA_INT, },
64         { "tca6408", 8  | PCA953X_TYPE | PCA_INT, },
65         { "tca6416", 16 | PCA953X_TYPE | PCA_INT, },
66         /* NYET:  { "tca6424", 24, }, */
67         { }
68 };
69 MODULE_DEVICE_TABLE(i2c, pca953x_id);
70
71 struct pca953x_chip {
72         unsigned gpio_start;
73         uint16_t reg_output;
74         uint16_t reg_direction;
75         struct mutex i2c_lock;
76
77 #ifdef CONFIG_GPIO_PCA953X_IRQ
78         struct mutex irq_lock;
79         uint16_t irq_mask;
80         uint16_t irq_stat;
81         uint16_t irq_trig_raise;
82         uint16_t irq_trig_fall;
83         int      irq_base;
84 #endif
85
86         struct i2c_client *client;
87         struct gpio_chip gpio_chip;
88         const char *const *names;
89         int     chip_type;
90 };
91
92 static int pca953x_write_reg(struct pca953x_chip *chip, int reg, uint16_t val)
93 {
94         int ret = 0;
95
96         if (chip->gpio_chip.ngpio <= 8)
97                 ret = i2c_smbus_write_byte_data(chip->client, reg, val);
98         else {
99                 switch (chip->chip_type) {
100                 case PCA953X_TYPE:
101                         ret = i2c_smbus_write_word_data(chip->client,
102                                                         reg << 1, val);
103                         break;
104                 case PCA957X_TYPE:
105                         ret = i2c_smbus_write_byte_data(chip->client, reg << 1,
106                                                         val & 0xff);
107                         if (ret < 0)
108                                 break;
109                         ret = i2c_smbus_write_byte_data(chip->client,
110                                                         (reg << 1) + 1,
111                                                         (val & 0xff00) >> 8);
112                         break;
113                 }
114         }
115
116         if (ret < 0) {
117                 dev_err(&chip->client->dev, "failed writing register\n");
118                 return ret;
119         }
120
121         return 0;
122 }
123
124 static int pca953x_read_reg(struct pca953x_chip *chip, int reg, uint16_t *val)
125 {
126         int ret;
127
128         if (chip->gpio_chip.ngpio <= 8)
129                 ret = i2c_smbus_read_byte_data(chip->client, reg);
130         else
131                 ret = i2c_smbus_read_word_data(chip->client, reg << 1);
132
133         if (ret < 0) {
134                 dev_err(&chip->client->dev, "failed reading register\n");
135                 return ret;
136         }
137
138         *val = (uint16_t)ret;
139         return 0;
140 }
141
142 static int pca953x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
143 {
144         struct pca953x_chip *chip;
145         uint16_t reg_val;
146         int ret, offset = 0;
147
148         chip = container_of(gc, struct pca953x_chip, gpio_chip);
149
150         mutex_lock(&chip->i2c_lock);
151         reg_val = chip->reg_direction | (1u << off);
152
153         switch (chip->chip_type) {
154         case PCA953X_TYPE:
155                 offset = PCA953X_DIRECTION;
156                 break;
157         case PCA957X_TYPE:
158                 offset = PCA957X_CFG;
159                 break;
160         }
161         ret = pca953x_write_reg(chip, offset, reg_val);
162         if (ret)
163                 goto exit;
164
165         chip->reg_direction = reg_val;
166         ret = 0;
167 exit:
168         mutex_unlock(&chip->i2c_lock);
169         return ret;
170 }
171
172 static int pca953x_gpio_direction_output(struct gpio_chip *gc,
173                 unsigned off, int val)
174 {
175         struct pca953x_chip *chip;
176         uint16_t reg_val;
177         int ret, offset = 0;
178
179         chip = container_of(gc, struct pca953x_chip, gpio_chip);
180
181         mutex_lock(&chip->i2c_lock);
182         /* set output level */
183         if (val)
184                 reg_val = chip->reg_output | (1u << off);
185         else
186                 reg_val = chip->reg_output & ~(1u << off);
187
188         switch (chip->chip_type) {
189         case PCA953X_TYPE:
190                 offset = PCA953X_OUTPUT;
191                 break;
192         case PCA957X_TYPE:
193                 offset = PCA957X_OUT;
194                 break;
195         }
196         ret = pca953x_write_reg(chip, offset, reg_val);
197         if (ret)
198                 goto exit;
199
200         chip->reg_output = reg_val;
201
202         /* then direction */
203         reg_val = chip->reg_direction & ~(1u << off);
204         switch (chip->chip_type) {
205         case PCA953X_TYPE:
206                 offset = PCA953X_DIRECTION;
207                 break;
208         case PCA957X_TYPE:
209                 offset = PCA957X_CFG;
210                 break;
211         }
212         ret = pca953x_write_reg(chip, offset, reg_val);
213         if (ret)
214                 goto exit;
215
216         chip->reg_direction = reg_val;
217         ret = 0;
218 exit:
219         mutex_unlock(&chip->i2c_lock);
220         return ret;
221 }
222
223 static int pca953x_gpio_get_value(struct gpio_chip *gc, unsigned off)
224 {
225         struct pca953x_chip *chip;
226         uint16_t reg_val;
227         int ret, offset = 0;
228
229         chip = container_of(gc, struct pca953x_chip, gpio_chip);
230
231         mutex_lock(&chip->i2c_lock);
232         switch (chip->chip_type) {
233         case PCA953X_TYPE:
234                 offset = PCA953X_INPUT;
235                 break;
236         case PCA957X_TYPE:
237                 offset = PCA957X_IN;
238                 break;
239         }
240         ret = pca953x_read_reg(chip, offset, &reg_val);
241         mutex_unlock(&chip->i2c_lock);
242         if (ret < 0) {
243                 /* NOTE:  diagnostic already emitted; that's all we should
244                  * do unless gpio_*_value_cansleep() calls become different
245                  * from their nonsleeping siblings (and report faults).
246                  */
247                 return 0;
248         }
249
250         return (reg_val & (1u << off)) ? 1 : 0;
251 }
252
253 static void pca953x_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
254 {
255         struct pca953x_chip *chip;
256         uint16_t reg_val;
257         int ret, offset = 0;
258
259         chip = container_of(gc, struct pca953x_chip, gpio_chip);
260
261         mutex_lock(&chip->i2c_lock);
262         if (val)
263                 reg_val = chip->reg_output | (1u << off);
264         else
265                 reg_val = chip->reg_output & ~(1u << off);
266
267         switch (chip->chip_type) {
268         case PCA953X_TYPE:
269                 offset = PCA953X_OUTPUT;
270                 break;
271         case PCA957X_TYPE:
272                 offset = PCA957X_OUT;
273                 break;
274         }
275         ret = pca953x_write_reg(chip, offset, reg_val);
276         if (ret)
277                 goto exit;
278
279         chip->reg_output = reg_val;
280 exit:
281         mutex_unlock(&chip->i2c_lock);
282 }
283
284 static void pca953x_setup_gpio(struct pca953x_chip *chip, int gpios)
285 {
286         struct gpio_chip *gc;
287
288         gc = &chip->gpio_chip;
289
290         gc->direction_input  = pca953x_gpio_direction_input;
291         gc->direction_output = pca953x_gpio_direction_output;
292         gc->get = pca953x_gpio_get_value;
293         gc->set = pca953x_gpio_set_value;
294         gc->can_sleep = 1;
295
296         gc->base = chip->gpio_start;
297         gc->ngpio = gpios;
298         gc->label = chip->client->name;
299         gc->dev = &chip->client->dev;
300         gc->owner = THIS_MODULE;
301         gc->names = chip->names;
302 }
303
304 #ifdef CONFIG_GPIO_PCA953X_IRQ
305 static 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
313 static void pca953x_irq_mask(struct irq_data *d)
314 {
315         struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
316
317         chip->irq_mask &= ~(1 << (d->irq - chip->irq_base));
318 }
319
320 static void pca953x_irq_unmask(struct irq_data *d)
321 {
322         struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
323
324         chip->irq_mask |= 1 << (d->irq - chip->irq_base);
325 }
326
327 static void pca953x_irq_bus_lock(struct irq_data *d)
328 {
329         struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
330
331         mutex_lock(&chip->irq_lock);
332 }
333
334 static void pca953x_irq_bus_sync_unlock(struct irq_data *d)
335 {
336         struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
337         uint16_t new_irqs;
338         uint16_t level;
339
340         /* Look for any newly setup interrupt */
341         new_irqs = chip->irq_trig_fall | chip->irq_trig_raise;
342         new_irqs &= ~chip->reg_direction;
343
344         while (new_irqs) {
345                 level = __ffs(new_irqs);
346                 pca953x_gpio_direction_input(&chip->gpio_chip, level);
347                 new_irqs &= ~(1 << level);
348         }
349
350         mutex_unlock(&chip->irq_lock);
351 }
352
353 static int pca953x_irq_set_type(struct irq_data *d, unsigned int type)
354 {
355         struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
356         uint16_t level = d->irq - chip->irq_base;
357         uint16_t mask = 1 << level;
358
359         if (!(type & IRQ_TYPE_EDGE_BOTH)) {
360                 dev_err(&chip->client->dev, "irq %d: unsupported type %d\n",
361                         d->irq, type);
362                 return -EINVAL;
363         }
364
365         if (type & IRQ_TYPE_EDGE_FALLING)
366                 chip->irq_trig_fall |= mask;
367         else
368                 chip->irq_trig_fall &= ~mask;
369
370         if (type & IRQ_TYPE_EDGE_RISING)
371                 chip->irq_trig_raise |= mask;
372         else
373                 chip->irq_trig_raise &= ~mask;
374
375         return 0;
376 }
377
378 static struct irq_chip pca953x_irq_chip = {
379         .name                   = "pca953x",
380         .irq_mask               = pca953x_irq_mask,
381         .irq_unmask             = pca953x_irq_unmask,
382         .irq_bus_lock           = pca953x_irq_bus_lock,
383         .irq_bus_sync_unlock    = pca953x_irq_bus_sync_unlock,
384         .irq_set_type           = pca953x_irq_set_type,
385 };
386
387 static uint16_t pca953x_irq_pending(struct pca953x_chip *chip)
388 {
389         uint16_t cur_stat;
390         uint16_t old_stat;
391         uint16_t pending;
392         uint16_t trigger;
393         int ret, offset = 0;
394
395         switch (chip->chip_type) {
396         case PCA953X_TYPE:
397                 offset = PCA953X_INPUT;
398                 break;
399         case PCA957X_TYPE:
400                 offset = PCA957X_IN;
401                 break;
402         }
403         ret = pca953x_read_reg(chip, offset, &cur_stat);
404         if (ret)
405                 return 0;
406
407         /* Remove output pins from the equation */
408         cur_stat &= chip->reg_direction;
409
410         old_stat = chip->irq_stat;
411         trigger = (cur_stat ^ old_stat) & chip->irq_mask;
412
413         if (!trigger)
414                 return 0;
415
416         chip->irq_stat = cur_stat;
417
418         pending = (old_stat & chip->irq_trig_fall) |
419                   (cur_stat & chip->irq_trig_raise);
420         pending &= trigger;
421
422         return pending;
423 }
424
425 static irqreturn_t pca953x_irq_handler(int irq, void *devid)
426 {
427         struct pca953x_chip *chip = devid;
428         uint16_t pending;
429         uint16_t level;
430
431         pending = pca953x_irq_pending(chip);
432
433         if (!pending)
434                 return IRQ_HANDLED;
435
436         do {
437                 level = __ffs(pending);
438                 handle_nested_irq(level + chip->irq_base);
439
440                 pending &= ~(1 << level);
441         } while (pending);
442
443         return IRQ_HANDLED;
444 }
445
446 static int pca953x_irq_setup(struct pca953x_chip *chip,
447                              const struct i2c_device_id *id,
448                              int irq_base)
449 {
450         struct i2c_client *client = chip->client;
451         int ret, offset = 0;
452
453         if (irq_base != -1
454                         && (id->driver_data & PCA_INT)) {
455                 int lvl;
456
457                 switch (chip->chip_type) {
458                 case PCA953X_TYPE:
459                         offset = PCA953X_INPUT;
460                         break;
461                 case PCA957X_TYPE:
462                         offset = PCA957X_IN;
463                         break;
464                 }
465                 ret = pca953x_read_reg(chip, offset, &chip->irq_stat);
466                 if (ret)
467                         goto out_failed;
468
469                 /*
470                  * There is no way to know which GPIO line generated the
471                  * interrupt.  We have to rely on the previous read for
472                  * this purpose.
473                  */
474                 chip->irq_stat &= chip->reg_direction;
475                 mutex_init(&chip->irq_lock);
476
477                 chip->irq_base = irq_alloc_descs(-1, irq_base, chip->gpio_chip.ngpio, -1);
478                 if (chip->irq_base < 0)
479                         goto out_failed;
480
481                 for (lvl = 0; lvl < chip->gpio_chip.ngpio; lvl++) {
482                         int irq = lvl + chip->irq_base;
483
484                         irq_clear_status_flags(irq, IRQ_NOREQUEST);
485                         irq_set_chip_data(irq, chip);
486                         irq_set_chip(irq, &pca953x_irq_chip);
487                         irq_set_nested_thread(irq, true);
488 #ifdef CONFIG_ARM
489                         set_irq_flags(irq, IRQF_VALID);
490 #else
491                         irq_set_noprobe(irq);
492 #endif
493                 }
494
495                 ret = request_threaded_irq(client->irq,
496                                            NULL,
497                                            pca953x_irq_handler,
498                                            IRQF_TRIGGER_LOW | IRQF_ONESHOT,
499                                            dev_name(&client->dev), chip);
500                 if (ret) {
501                         dev_err(&client->dev, "failed to request irq %d\n",
502                                 client->irq);
503                         goto out_failed;
504                 }
505
506                 chip->gpio_chip.to_irq = pca953x_gpio_to_irq;
507         }
508
509         return 0;
510
511 out_failed:
512         chip->irq_base = -1;
513         return ret;
514 }
515
516 static void pca953x_irq_teardown(struct pca953x_chip *chip)
517 {
518         if (chip->irq_base != -1) {
519                 irq_free_descs(chip->irq_base, chip->gpio_chip.ngpio);
520                 free_irq(chip->client->irq, chip);
521         }
522 }
523 #else /* CONFIG_GPIO_PCA953X_IRQ */
524 static int pca953x_irq_setup(struct pca953x_chip *chip,
525                              const struct i2c_device_id *id,
526                              int irq_base)
527 {
528         struct i2c_client *client = chip->client;
529
530         if (irq_base != -1 && (id->driver_data & PCA_INT))
531                 dev_warn(&client->dev, "interrupt support not compiled in\n");
532
533         return 0;
534 }
535
536 static void pca953x_irq_teardown(struct pca953x_chip *chip)
537 {
538 }
539 #endif
540
541 /*
542  * Handlers for alternative sources of platform_data
543  */
544 #ifdef CONFIG_OF_GPIO
545 /*
546  * Translate OpenFirmware node properties into platform_data
547  * WARNING: This is DEPRECATED and will be removed eventually!
548  */
549 static void
550 pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, int *invert)
551 {
552         struct device_node *node;
553         const __be32 *val;
554         int size;
555
556         node = client->dev.of_node;
557         if (node == NULL)
558                 return;
559
560         *gpio_base = -1;
561         val = of_get_property(node, "linux,gpio-base", &size);
562         WARN(val, "%s: device-tree property 'linux,gpio-base' is deprecated!", __func__);
563         if (val) {
564                 if (size != sizeof(*val))
565                         dev_warn(&client->dev, "%s: wrong linux,gpio-base\n",
566                                  node->full_name);
567                 else
568                         *gpio_base = be32_to_cpup(val);
569         }
570
571         val = of_get_property(node, "polarity", NULL);
572         WARN(val, "%s: device-tree property 'polarity' is deprecated!", __func__);
573         if (val)
574                 *invert = *val;
575 }
576 #else
577 static void
578 pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, int *invert)
579 {
580         *gpio_base = -1;
581 }
582 #endif
583
584 static int __devinit device_pca953x_init(struct pca953x_chip *chip, int invert)
585 {
586         int ret;
587
588         ret = pca953x_read_reg(chip, PCA953X_OUTPUT, &chip->reg_output);
589         if (ret)
590                 goto out;
591
592         ret = pca953x_read_reg(chip, PCA953X_DIRECTION,
593                                &chip->reg_direction);
594         if (ret)
595                 goto out;
596
597         /* set platform specific polarity inversion */
598         ret = pca953x_write_reg(chip, PCA953X_INVERT, invert);
599 out:
600         return ret;
601 }
602
603 static 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;
630 out:
631         return ret;
632 }
633
634 static int __devinit pca953x_probe(struct i2c_client *client,
635                                    const struct i2c_device_id *id)
636 {
637         struct pca953x_platform_data *pdata;
638         struct pca953x_chip *chip;
639         int irq_base=0, invert=0;
640         int ret;
641
642         chip = kzalloc(sizeof(struct pca953x_chip), GFP_KERNEL);
643         if (chip == NULL)
644                 return -ENOMEM;
645
646         pdata = client->dev.platform_data;
647         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);
654 #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
659         }
660
661         chip->client = client;
662
663         chip->chip_type = id->driver_data & (PCA953X_TYPE | PCA957X_TYPE);
664
665         mutex_init(&chip->i2c_lock);
666
667         /* initialize cached registers from their original values.
668          * we can't share this chip with another i2c master.
669          */
670         pca953x_setup_gpio(chip, id->driver_data & PCA_GPIO_MASK);
671
672         if (chip->chip_type == PCA953X_TYPE)
673                 ret = device_pca953x_init(chip, invert);
674         else
675                 ret = device_pca957x_init(chip, invert);
676         if (ret)
677                 goto out_failed;
678
679         ret = pca953x_irq_setup(chip, id, irq_base);
680         if (ret)
681                 goto out_failed;
682
683         ret = gpiochip_add(&chip->gpio_chip);
684         if (ret)
685                 goto out_failed_irq;
686
687         if (pdata && pdata->setup) {
688                 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
697 out_failed_irq:
698         pca953x_irq_teardown(chip);
699 out_failed:
700         kfree(chip);
701         return ret;
702 }
703
704 static int pca953x_remove(struct i2c_client *client)
705 {
706         struct pca953x_platform_data *pdata = client->dev.platform_data;
707         struct pca953x_chip *chip = i2c_get_clientdata(client);
708         int ret = 0;
709
710         if (pdata && pdata->teardown) {
711                 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
727         pca953x_irq_teardown(chip);
728         kfree(chip);
729         return 0;
730 }
731
732 static struct i2c_driver pca953x_driver = {
733         .driver = {
734                 .name   = "pca953x",
735         },
736         .probe          = pca953x_probe,
737         .remove         = pca953x_remove,
738         .id_table       = pca953x_id,
739 };
740
741 static int __init pca953x_init(void)
742 {
743         return i2c_add_driver(&pca953x_driver);
744 }
745 /* register after i2c postcore initcall and before
746  * subsys initcalls that may rely on these GPIOs
747  */
748 subsys_initcall(pca953x_init);
749
750 static void __exit pca953x_exit(void)
751 {
752         i2c_del_driver(&pca953x_driver);
753 }
754 module_exit(pca953x_exit);
755
756 MODULE_AUTHOR("eric miao <eric.miao@marvell.com>");
757 MODULE_DESCRIPTION("GPIO expander driver for PCA953x");
758 MODULE_LICENSE("GPL");