mfd: ricoh583: Update with new IRQ API
[linux-2.6.git] / drivers / mfd / ricoh583.c
1 /*
2  * driver/mfd/ricoh583.c
3  *
4  * Core driver implementation to access RICOH583 power management chip.
5  *
6  * Copyright (C) 2011 NVIDIA Corporation
7  *
8  * Copyright (C) 2011 RICOH COMPANY,LTD
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful, but WITHOUT
16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
18  * more details.
19  *
20  * You should have received a copy of the GNU General Public License along
21  * with this program; if not, write to the Free Software Foundation, Inc.,
22  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
23  *
24  */
25 /*#define DEBUG                 1*/
26 /*#define VERBOSE_DEBUG         1*/
27 #include <linux/interrupt.h>
28 #include <linux/irq.h>
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/slab.h>
33 #include <linux/gpio.h>
34 #include <linux/i2c.h>
35 #include <linux/mfd/core.h>
36 #include <linux/mfd/ricoh583.h>
37
38 #define RICOH_ONOFFSEL_REG      0x10
39
40 /* Interrupt enable register */
41 #define RICOH583_INT_EN_SYS1    0x19
42 #define RICOH583_INT_EN_SYS2    0x1D
43 #define RICOH583_INT_EN_DCDC    0x41
44 #define RICOH583_INT_EN_RTC     0xED
45 #define RICOH583_INT_EN_ADC1    0x90
46 #define RICOH583_INT_EN_ADC2    0x91
47 #define RICOH583_INT_EN_ADC3    0x92
48 #define RICOH583_INT_EN_GPIO    0xA8
49
50 /* interrupt status registers (monitor regs in Ricoh)*/
51 #define RICOH583_INTC_INTPOL    0xAD
52 #define RICOH583_INTC_INTEN     0xAE
53 #define RICOH583_INTC_INTMON    0xAF
54
55 #define RICOH583_INT_MON_GRP    0xAF
56 #define RICOH583_INT_MON_SYS1   0x1B
57 #define RICOH583_INT_MON_SYS2   0x1F
58 #define RICOH583_INT_MON_DCDC   0x43
59 #define RICOH583_INT_MON_RTC    0xEE
60
61 /* interrupt clearing registers */
62 #define RICOH583_INT_IR_SYS1    0x1A
63 #define RICOH583_INT_IR_SYS2    0x1E
64 #define RICOH583_INT_IR_DCDC    0x42
65 #define RICOH583_INT_IR_RTC     0xEE
66 #define RICOH583_INT_IR_ADCL    0x94
67 #define RICOH583_INT_IR_ADCH    0x95
68 #define RICOH583_INT_IR_ADCEND  0x96
69 #define RICOH583_INT_IR_GPIOR   0xA9
70 #define RICOH583_INT_IR_GPIOF   0xAA
71
72 /* GPIO register base address */
73 #define RICOH583_GPIO_IOSEL     0xA0
74 #define RICOH583_GPIO_PDEN      0xA1
75 #define RICOH583_GPIO_IOOUT     0xA2
76 #define RICOH583_GPIO_PGSEL     0xA3
77 #define RICOH583_GPIO_GPINV     0xA4
78 #define RICOH583_GPIO_GPDEB     0xA5
79 #define RICOH583_GPIO_GPEDGE1   0xA6
80 #define RICOH583_GPIO_GPEDGE2   0xA7
81 #define RICOH583_GPIO_EN_GPIR   0xA8
82 #define RICOH583_GPIO_MON_IOIN  0xAB
83 #define RICOH583_GPIO_GPOFUNC   0xAC
84 #define RICOH583_INTC_INTEN     0xAE
85
86 enum int_type {
87         SYS_INT  = 0x1,
88         DCDC_INT = 0x2,
89         RTC_INT  = 0x4,
90         ADC_INT  = 0x8,
91         GPIO_INT = 0x10,
92 };
93
94 struct ricoh583_irq_data {
95         u8      int_type;
96         u8      master_bit;
97         u8      int_en_bit;
98         u8      mask_reg_index;
99         int     grp_index;
100 };
101
102 struct deepsleep_control_data {
103         u8 reg_add;
104         u8 ds_pos_bit;
105 };
106
107 #define RICOH583_IRQ(_int_type, _master_bit, _grp_index, _int_bit, _mask_ind) \
108         {                                               \
109                 .int_type       = _int_type,            \
110                 .master_bit     = _master_bit,          \
111                 .grp_index      = _grp_index,           \
112                 .int_en_bit     = _int_bit,             \
113                 .mask_reg_index = _mask_ind,            \
114         }
115
116 static const struct ricoh583_irq_data ricoh583_irqs[] = {
117         [RICOH583_IRQ_ONKEY]            = RICOH583_IRQ(SYS_INT,  0, 0, 0, 0),
118         [RICOH583_IRQ_ACOK]             = RICOH583_IRQ(SYS_INT,  0, 1, 1, 0),
119         [RICOH583_IRQ_LIDOPEN]          = RICOH583_IRQ(SYS_INT,  0, 2, 2, 0),
120         [RICOH583_IRQ_PREOT]            = RICOH583_IRQ(SYS_INT,  0, 3, 3, 0),
121         [RICOH583_IRQ_CLKSTP]           = RICOH583_IRQ(SYS_INT,  0, 4, 4, 0),
122         [RICOH583_IRQ_ONKEY_OFF]        = RICOH583_IRQ(SYS_INT,  0, 5, 5, 0),
123         [RICOH583_IRQ_WD]               = RICOH583_IRQ(SYS_INT,  0, 7, 7, 0),
124         [RICOH583_IRQ_EN_PWRREQ1]       = RICOH583_IRQ(SYS_INT,  0, 8, 0, 1),
125         [RICOH583_IRQ_EN_PWRREQ2]       = RICOH583_IRQ(SYS_INT,  0, 9, 1, 1),
126         [RICOH583_IRQ_PRE_VINDET]       = RICOH583_IRQ(SYS_INT,  0, 10, 2, 1),
127
128         [RICOH583_IRQ_DC0LIM]           = RICOH583_IRQ(DCDC_INT, 1, 0, 0, 2),
129         [RICOH583_IRQ_DC1LIM]           = RICOH583_IRQ(DCDC_INT, 1, 1, 1, 2),
130         [RICOH583_IRQ_DC2LIM]           = RICOH583_IRQ(DCDC_INT, 1, 2, 2, 2),
131         [RICOH583_IRQ_DC3LIM]           = RICOH583_IRQ(DCDC_INT, 1, 3, 3, 2),
132
133         [RICOH583_IRQ_CTC]              = RICOH583_IRQ(RTC_INT,  2, 0, 0, 3),
134         [RICOH583_IRQ_YALE]             = RICOH583_IRQ(RTC_INT,  2, 5, 5, 3),
135         [RICOH583_IRQ_DALE]             = RICOH583_IRQ(RTC_INT,  2, 6, 6, 3),
136         [RICOH583_IRQ_WALE]             = RICOH583_IRQ(RTC_INT,  2, 7, 7, 3),
137
138         [RICOH583_IRQ_AIN1L]            = RICOH583_IRQ(ADC_INT,  3, 0, 0, 4),
139         [RICOH583_IRQ_AIN2L]            = RICOH583_IRQ(ADC_INT,  3, 1, 1, 4),
140         [RICOH583_IRQ_AIN3L]            = RICOH583_IRQ(ADC_INT,  3, 2, 2, 4),
141         [RICOH583_IRQ_VBATL]            = RICOH583_IRQ(ADC_INT,  3, 3, 3, 4),
142         [RICOH583_IRQ_VIN3L]            = RICOH583_IRQ(ADC_INT,  3, 4, 4, 4),
143         [RICOH583_IRQ_VIN8L]            = RICOH583_IRQ(ADC_INT,  3, 5, 5, 4),
144         [RICOH583_IRQ_AIN1H]            = RICOH583_IRQ(ADC_INT,  3, 6, 0, 5),
145         [RICOH583_IRQ_AIN2H]            = RICOH583_IRQ(ADC_INT,  3, 7, 1, 5),
146         [RICOH583_IRQ_AIN3H]            = RICOH583_IRQ(ADC_INT,  3, 8, 2, 5),
147         [RICOH583_IRQ_VBATH]            = RICOH583_IRQ(ADC_INT,  3, 9, 3, 5),
148         [RICOH583_IRQ_VIN3H]            = RICOH583_IRQ(ADC_INT,  3, 10, 4, 5),
149         [RICOH583_IRQ_VIN8H]            = RICOH583_IRQ(ADC_INT,  3, 11, 5, 5),
150         [RICOH583_IRQ_ADCEND]           = RICOH583_IRQ(ADC_INT,  3, 12, 0, 6),
151
152         [RICOH583_IRQ_GPIO0]            = RICOH583_IRQ(GPIO_INT, 4, 0, 0, 7),
153         [RICOH583_IRQ_GPIO1]            = RICOH583_IRQ(GPIO_INT, 4, 1, 1, 7),
154         [RICOH583_IRQ_GPIO2]            = RICOH583_IRQ(GPIO_INT, 4, 2, 2, 7),
155         [RICOH583_IRQ_GPIO3]            = RICOH583_IRQ(GPIO_INT, 4, 3, 3, 7),
156         [RICOH583_IRQ_GPIO4]            = RICOH583_IRQ(GPIO_INT, 4, 4, 4, 7),
157         [RICOH583_IRQ_GPIO5]            = RICOH583_IRQ(GPIO_INT, 4, 5, 5, 7),
158         [RICOH583_IRQ_GPIO6]            = RICOH583_IRQ(GPIO_INT, 4, 6, 6, 7),
159         [RICOH583_IRQ_GPIO7]            = RICOH583_IRQ(GPIO_INT, 4, 7, 7, 7),
160         [RICOH583_NR_IRQS]              = RICOH583_IRQ(GPIO_INT, 4, 8, 8, 7),
161 };
162
163 #define DEEPSLEEP_INIT(_id, _reg, _pos)         \
164         [RICOH583_DS_##_id] = {.reg_add = _reg, .ds_pos_bit = _pos}
165
166 static struct deepsleep_control_data deepsleep_data[] = {
167         DEEPSLEEP_INIT(DC1, 0x21, 4),
168         DEEPSLEEP_INIT(DC2, 0x22, 0),
169         DEEPSLEEP_INIT(DC3, 0x22, 4),
170         DEEPSLEEP_INIT(LDO0, 0x23, 0),
171         DEEPSLEEP_INIT(LDO1, 0x23, 4),
172         DEEPSLEEP_INIT(LDO2, 0x24, 0),
173         DEEPSLEEP_INIT(LDO3, 0x24, 4),
174         DEEPSLEEP_INIT(LDO4, 0x25, 0),
175         DEEPSLEEP_INIT(LDO5, 0x25, 4),
176         DEEPSLEEP_INIT(LDO6, 0x26, 0),
177         DEEPSLEEP_INIT(LDO7, 0x26, 4),
178         DEEPSLEEP_INIT(LDO8, 0x27, 0),
179         DEEPSLEEP_INIT(LDO9, 0x27, 4),
180         DEEPSLEEP_INIT(PSO0, 0x28, 0),
181         DEEPSLEEP_INIT(PSO1, 0x28, 4),
182         DEEPSLEEP_INIT(PSO2, 0x29, 0),
183         DEEPSLEEP_INIT(PSO3, 0x29, 4),
184         DEEPSLEEP_INIT(PSO4, 0x2A, 0),
185         DEEPSLEEP_INIT(PSO5, 0x2A, 4),
186         DEEPSLEEP_INIT(PSO6, 0x2B, 0),
187         DEEPSLEEP_INIT(PSO7, 0x2B, 4),
188 };
189
190 #define MAX_INTERRUPT_MASKS     8
191 #define MAX_MAIN_INTERRUPT      5
192 #define EXT_PWR_REQ             \
193         (RICOH583_EXT_PWRREQ1_CONTROL | RICOH583_EXT_PWRREQ2_CONTROL)
194
195 struct ricoh583 {
196         struct device           *dev;
197         struct i2c_client       *client;
198         struct mutex            io_lock;
199         int                     gpio_base;
200         struct gpio_chip        gpio;
201         int                     irq_base;
202         struct irq_chip         irq_chip;
203         struct mutex            irq_lock;
204         unsigned long           group_irq_en[MAX_MAIN_INTERRUPT];
205
206         /* For main interrupt bits in INTC */
207         u8                      intc_inten_cache;
208         u8                      intc_inten_reg;
209
210         /* For group interrupt bits and address */
211         u8                      irq_en_cache[MAX_INTERRUPT_MASKS];
212         u8                      irq_en_reg[MAX_INTERRUPT_MASKS];
213         u8                      irq_en_add[MAX_INTERRUPT_MASKS];
214
215         /* Interrupt monitor and clear register */
216         u8                      irq_mon_add[MAX_INTERRUPT_MASKS + 1];
217         u8                      irq_clr_add[MAX_INTERRUPT_MASKS + 1];
218         u8                      main_int_type[MAX_INTERRUPT_MASKS + 1];
219
220         /* For gpio edge */
221         u8                      gpedge_cache[2];
222         u8                      gpedge_reg[2];
223         u8                      gpedge_add[2];
224 };
225
226 static inline int __ricoh583_read(struct i2c_client *client,
227                                   u8 reg, uint8_t *val)
228 {
229         int ret;
230
231         ret = i2c_smbus_read_byte_data(client, reg);
232         if (ret < 0) {
233                 dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
234                 return ret;
235         }
236
237         *val = (uint8_t)ret;
238         dev_dbg(&client->dev, "ricoh583: reg read  reg=%x, val=%x\n",
239                                 reg, *val);
240         return 0;
241 }
242
243 static inline int __ricoh583_bulk_reads(struct i2c_client *client, u8 reg,
244                                 int len, uint8_t *val)
245 {
246         int ret;
247         int i;
248
249         ret = i2c_smbus_read_i2c_block_data(client, reg, len, val);
250         if (ret < 0) {
251                 dev_err(&client->dev, "failed reading from 0x%02x\n", reg);
252                 return ret;
253         }
254         for (i = 0; i < len; ++i) {
255                 dev_dbg(&client->dev, "ricoh583: reg read  reg=%x, val=%x\n",
256                                 reg + i, *(val + i));
257         }
258         return 0;
259 }
260
261 static inline int __ricoh583_write(struct i2c_client *client,
262                                  u8 reg, uint8_t val)
263 {
264         int ret;
265
266         dev_dbg(&client->dev, "ricoh583: reg write  reg=%x, val=%x\n",
267                                 reg, val);
268         ret = i2c_smbus_write_byte_data(client, reg, val);
269         if (ret < 0) {
270                 dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n",
271                                 val, reg);
272                 return ret;
273         }
274
275         return 0;
276 }
277
278 static inline int __ricoh583_bulk_writes(struct i2c_client *client, u8 reg,
279                                   int len, uint8_t *val)
280 {
281         int ret;
282         int i;
283
284         for (i = 0; i < len; ++i) {
285                 dev_dbg(&client->dev, "ricoh583: reg write  reg=%x, val=%x\n",
286                                 reg + i, *(val + i));
287         }
288
289         ret = i2c_smbus_write_i2c_block_data(client, reg, len, val);
290         if (ret < 0) {
291                 dev_err(&client->dev, "failed writings to 0x%02x\n", reg);
292                 return ret;
293         }
294
295         return 0;
296 }
297
298 int ricoh583_write(struct device *dev, u8 reg, uint8_t val)
299 {
300         struct ricoh583 *ricoh583 = dev_get_drvdata(dev);
301         int ret = 0;
302
303         mutex_lock(&ricoh583->io_lock);
304         ret = __ricoh583_write(to_i2c_client(dev), reg, val);
305         mutex_unlock(&ricoh583->io_lock);
306
307         return ret;
308 }
309 EXPORT_SYMBOL_GPL(ricoh583_write);
310
311 int ricoh583_bulk_writes(struct device *dev, u8 reg, int len, uint8_t *val)
312 {
313         struct ricoh583 *ricoh583 = dev_get_drvdata(dev);
314         int ret = 0;
315
316         mutex_lock(&ricoh583->io_lock);
317         ret = __ricoh583_bulk_writes(to_i2c_client(dev), reg, len, val);
318         mutex_unlock(&ricoh583->io_lock);
319
320         return ret;
321 }
322 EXPORT_SYMBOL_GPL(ricoh583_bulk_writes);
323
324 int ricoh583_read(struct device *dev, u8 reg, uint8_t *val)
325 {
326         return __ricoh583_read(to_i2c_client(dev), reg, val);
327 }
328 EXPORT_SYMBOL_GPL(ricoh583_read);
329
330 int ricoh583_bulk_reads(struct device *dev, u8 reg, int len, uint8_t *val)
331 {
332         return __ricoh583_bulk_reads(to_i2c_client(dev), reg, len, val);
333 }
334 EXPORT_SYMBOL_GPL(ricoh583_bulk_reads);
335
336 int ricoh583_set_bits(struct device *dev, u8 reg, uint8_t bit_mask)
337 {
338         struct ricoh583 *ricoh583 = dev_get_drvdata(dev);
339         uint8_t reg_val;
340         int ret = 0;
341
342         mutex_lock(&ricoh583->io_lock);
343
344         ret = __ricoh583_read(to_i2c_client(dev), reg, &reg_val);
345         if (ret)
346                 goto out;
347
348         if ((reg_val & bit_mask) != bit_mask) {
349                 reg_val |= bit_mask;
350                 ret = __ricoh583_write(to_i2c_client(dev), reg, reg_val);
351         }
352 out:
353         mutex_unlock(&ricoh583->io_lock);
354         return ret;
355 }
356 EXPORT_SYMBOL_GPL(ricoh583_set_bits);
357
358 int ricoh583_clr_bits(struct device *dev, u8 reg, uint8_t bit_mask)
359 {
360         struct ricoh583 *ricoh583 = dev_get_drvdata(dev);
361         uint8_t reg_val;
362         int ret = 0;
363
364         mutex_lock(&ricoh583->io_lock);
365
366         ret = __ricoh583_read(to_i2c_client(dev), reg, &reg_val);
367         if (ret)
368                 goto out;
369
370         if (reg_val & bit_mask) {
371                 reg_val &= ~bit_mask;
372                 ret = __ricoh583_write(to_i2c_client(dev), reg, reg_val);
373         }
374 out:
375         mutex_unlock(&ricoh583->io_lock);
376         return ret;
377 }
378 EXPORT_SYMBOL_GPL(ricoh583_clr_bits);
379
380 int ricoh583_update(struct device *dev, u8 reg, uint8_t val, uint8_t mask)
381 {
382         struct ricoh583 *ricoh583 = dev_get_drvdata(dev);
383         uint8_t reg_val;
384         int ret = 0;
385
386         mutex_lock(&ricoh583->io_lock);
387
388         ret = __ricoh583_read(ricoh583->client, reg, &reg_val);
389         if (ret)
390                 goto out;
391
392         if ((reg_val & mask) != val) {
393                 reg_val = (reg_val & ~mask) | (val & mask);
394                 ret = __ricoh583_write(ricoh583->client, reg, reg_val);
395         }
396 out:
397         mutex_unlock(&ricoh583->io_lock);
398         return ret;
399 }
400 EXPORT_SYMBOL_GPL(ricoh583_update);
401
402 static int __ricoh583_set_ext_pwrreq1_control(struct device *dev,
403         enum ricoh583_deepsleep_control_id id,
404         enum ricoh583_ext_pwrreq_control ext_pwr, int slots)
405 {
406         int ret;
407         uint8_t sleepseq_val;
408         u8 en_bit;
409         u8 slot_bit;
410
411         if (!(ext_pwr & RICOH583_EXT_PWRREQ1_CONTROL))
412                 return 0;
413
414         if (id == RICOH583_DS_DC0) {
415                 dev_err(dev, "PWRREQ1 is invalid control for rail %d\n", id);
416                 return -EINVAL;
417         }
418
419         en_bit = deepsleep_data[id].ds_pos_bit;
420         slot_bit = en_bit + 1;
421         ret = ricoh583_read(dev, deepsleep_data[id].reg_add, &sleepseq_val);
422         if (ret < 0) {
423                 dev_err(dev, "Error in reading reg 0x%x\n",
424                                 deepsleep_data[id].reg_add);
425                 return ret;
426         }
427
428         sleepseq_val &= ~(0xF << en_bit);
429         sleepseq_val |= (1 << en_bit);
430         sleepseq_val |= ((slots & 0x7) << slot_bit);
431         ret = ricoh583_set_bits(dev, RICOH_ONOFFSEL_REG, (1 << 1));
432         if (ret < 0) {
433                 dev_err(dev, "Error in updating the 0x%02x register\n",
434                                 RICOH_ONOFFSEL_REG);
435                 return ret;
436         }
437
438         ret = ricoh583_write(dev, deepsleep_data[id].reg_add, sleepseq_val);
439         if (ret < 0)
440                 dev_err(dev, "Error in writing reg 0x%x\n",
441                                 deepsleep_data[id].reg_add);
442         return ret;
443 }
444
445 static int __ricoh583_set_ext_pwrreq2_control(struct device *dev,
446         enum ricoh583_deepsleep_control_id id,
447         enum ricoh583_ext_pwrreq_control ext_pwr)
448 {
449         int ret;
450
451         if (!(ext_pwr & RICOH583_EXT_PWRREQ2_CONTROL))
452                 return 0;
453
454         if (id != RICOH583_DS_DC0) {
455                 dev_err(dev, "PWRREQ2 is invalid control for rail %d\n", id);
456                 return -EINVAL;
457         }
458
459         ret = ricoh583_set_bits(dev, RICOH_ONOFFSEL_REG, (1 << 2));
460         if (ret < 0)
461                 dev_err(dev, "Error in updating the ONOFFSEL 0x10 register\n");
462         return ret;
463 }
464
465 int ricoh583_ext_power_req_config(struct device *dev,
466         enum ricoh583_deepsleep_control_id id,
467         enum ricoh583_ext_pwrreq_control ext_pwr_req,
468         int deepsleep_slot_nr)
469 {
470         if ((ext_pwr_req & EXT_PWR_REQ) == EXT_PWR_REQ)
471                 return -EINVAL;
472
473         if (ext_pwr_req & RICOH583_EXT_PWRREQ1_CONTROL)
474                 return __ricoh583_set_ext_pwrreq1_control(dev, id,
475                                 ext_pwr_req, deepsleep_slot_nr);
476
477         if (ext_pwr_req & RICOH583_EXT_PWRREQ2_CONTROL)
478                 return __ricoh583_set_ext_pwrreq2_control(dev,
479                         id, ext_pwr_req);
480         return 0;
481 }
482 EXPORT_SYMBOL_GPL(ricoh583_ext_power_req_config);
483
484 static int __devinit ricoh583_ext_power_init(struct ricoh583 *ricoh583,
485         struct ricoh583_platform_data *pdata)
486 {
487         int ret;
488         int i;
489
490         /*  Clear ONOFFSEL register */
491         mutex_lock(&ricoh583->io_lock);
492         ret = __ricoh583_write(ricoh583->client, RICOH_ONOFFSEL_REG, 0x0);
493         if (ret < 0)
494                 dev_err(ricoh583->dev, "Error in writing reg %d error: "
495                                 "%d\n", RICOH_ONOFFSEL_REG, ret);
496
497         /* Clear sleepseq register */
498         for (i = 0x21; i < 0x2B; ++i) {
499                 ret = __ricoh583_write(ricoh583->client, i, 0x0);
500                 if (ret < 0)
501                         dev_err(ricoh583->dev, "Error in writing reg 0x%02x "
502                                 "error: %d\n", i, ret);
503         }
504         mutex_unlock(&ricoh583->io_lock);
505         return 0;
506 }
507
508 static struct i2c_client *ricoh583_i2c_client;
509 int ricoh583_power_off(void)
510 {
511         if (!ricoh583_i2c_client)
512                 return -EINVAL;
513
514         return 0;
515 }
516
517 static int ricoh583_gpio_get(struct gpio_chip *gc, unsigned offset)
518 {
519         struct ricoh583 *ricoh583 = container_of(gc, struct ricoh583, gpio);
520         uint8_t val;
521         int ret;
522
523         ret = __ricoh583_read(ricoh583->client, RICOH583_GPIO_MON_IOIN, &val);
524         if (ret < 0)
525                 return ret;
526
527         return ((val & (0x1 << offset)) != 0);
528 }
529
530 static void ricoh583_gpio_set(struct gpio_chip *chip, unsigned offset,
531                         int value)
532 {
533         struct ricoh583 *ricoh583 = container_of(chip, struct ricoh583, gpio);
534         if (value)
535                 ricoh583_set_bits(ricoh583->dev, RICOH583_GPIO_IOOUT,
536                                                 1 << offset);
537         else
538                 ricoh583_clr_bits(ricoh583->dev, RICOH583_GPIO_IOOUT,
539                                                 1 << offset);
540 }
541
542 static int ricoh583_gpio_input(struct gpio_chip *chip, unsigned offset)
543 {
544         struct ricoh583 *ricoh583 = container_of(chip, struct ricoh583, gpio);
545
546         return ricoh583_clr_bits(ricoh583->dev, RICOH583_GPIO_IOSEL,
547                                                 1 << offset);
548 }
549
550 static int ricoh583_gpio_output(struct gpio_chip *chip, unsigned offset,
551                                 int value)
552 {
553         struct ricoh583 *ricoh583 = container_of(chip, struct ricoh583, gpio);
554
555         ricoh583_gpio_set(chip, offset, value);
556         return ricoh583_set_bits(ricoh583->dev, RICOH583_GPIO_IOSEL,
557                                                 1 << offset);
558 }
559
560 static int ricoh583_gpio_to_irq(struct gpio_chip *chip, unsigned off)
561 {
562         struct ricoh583 *ricoh583 = container_of(chip, struct ricoh583, gpio);
563
564         if ((off >= 0) && (off < 8))
565                 return ricoh583->irq_base + RICOH583_IRQ_GPIO0 + off;
566
567         return -EIO;
568 }
569
570 static int ricoh583_gpio_request(struct gpio_chip *chip, unsigned offset)
571 {
572         struct ricoh583 *ricoh583 = container_of(chip, struct ricoh583, gpio);
573         int ret;
574
575         ret = ricoh583_clr_bits(ricoh583->dev, RICOH583_GPIO_PGSEL,
576                         1 << offset);
577         if (ret < 0)
578                 dev_err(ricoh583->dev, "%s(): The error in writing register "
579                         "0x%02x\n", __func__, RICOH583_GPIO_PGSEL);
580         return ret;
581 }
582
583 static void ricoh583_gpio_free(struct gpio_chip *chip, unsigned offset)
584 {
585         struct ricoh583 *ricoh583 = container_of(chip, struct ricoh583, gpio);
586         int ret;
587
588         ret = ricoh583_set_bits(ricoh583->dev, RICOH583_GPIO_PGSEL,
589                                 1 << offset);
590         if (ret < 0)
591                 dev_err(ricoh583->dev, "%s(): The error in writing register "
592                         "0x%02x\n", __func__, RICOH583_GPIO_PGSEL);
593 }
594
595 static void __devinit ricoh583_gpio_init(struct ricoh583 *ricoh583,
596         struct ricoh583_platform_data *pdata)
597 {
598         int ret;
599         int i;
600         struct ricoh583_gpio_init_data *ginit;
601
602         if (pdata->gpio_base  <= 0)
603                 return;
604
605         ret = ricoh583_write(ricoh583->dev, RICOH583_GPIO_PGSEL, 0xEF);
606         if (ret < 0) {
607                 dev_err(ricoh583->dev, "%s(): The error in writing register "
608                         "0x%02x\n", __func__, RICOH583_GPIO_PGSEL);
609                 return;
610         }
611
612         for (i = 0; i < pdata->num_gpioinit_data; ++i) {
613                 ginit = &pdata->gpio_init_data[i];
614                 if (!ginit->init_apply)
615                         continue;
616                 if (ginit->pulldn_en)
617                         ret = ricoh583_set_bits(ricoh583->dev,
618                                         RICOH583_GPIO_PDEN, 1 << i);
619                 else
620                         ret = ricoh583_clr_bits(ricoh583->dev,
621                                         RICOH583_GPIO_PDEN, 1 << i);
622                 if (ret < 0)
623                         dev_err(ricoh583->dev, "Gpio %d init "
624                                 "pden configuration failed: %d\n", i, ret);
625
626                 if (ginit->output_mode_en) {
627                         if (ginit->output_val)
628                                 ret = ricoh583_set_bits(ricoh583->dev,
629                                         RICOH583_GPIO_IOOUT, 1 << i);
630                         else
631                                 ret = ricoh583_clr_bits(ricoh583->dev,
632                                         RICOH583_GPIO_IOOUT, 1 << i);
633                         if (!ret)
634                                 ret = ricoh583_set_bits(ricoh583->dev,
635                                         RICOH583_GPIO_IOSEL, 1 << i);
636                 } else
637                         ret = ricoh583_clr_bits(ricoh583->dev,
638                                         RICOH583_GPIO_IOSEL, 1 << i);
639
640                 if (ret < 0)
641                         dev_err(ricoh583->dev, "Gpio %d init "
642                                 "dir configuration failed: %d\n", i, ret);
643
644                 ret = ricoh583_clr_bits(ricoh583->dev, RICOH583_GPIO_PGSEL,
645                                         1 << i);
646                 if (ret < 0)
647                         dev_err(ricoh583->dev, "%s(): The error in writing "
648                                 "register 0x%02x\n", __func__,
649                                 RICOH583_GPIO_PGSEL);
650         }
651
652         ricoh583->gpio.owner            = THIS_MODULE;
653         ricoh583->gpio.label            = ricoh583->client->name;
654         ricoh583->gpio.dev              = ricoh583->dev;
655         ricoh583->gpio.base             = pdata->gpio_base;
656         ricoh583->gpio.ngpio            = RICOH583_NR_GPIO;
657         ricoh583->gpio.can_sleep        = 1;
658
659         ricoh583->gpio.request  = ricoh583_gpio_request;
660         ricoh583->gpio.free     = ricoh583_gpio_free;
661         ricoh583->gpio.direction_input  = ricoh583_gpio_input;
662         ricoh583->gpio.direction_output = ricoh583_gpio_output;
663         ricoh583->gpio.set              = ricoh583_gpio_set;
664         ricoh583->gpio.get              = ricoh583_gpio_get;
665         ricoh583->gpio.to_irq      = ricoh583_gpio_to_irq;
666
667         ret = gpiochip_add(&ricoh583->gpio);
668         if (ret)
669                 dev_warn(ricoh583->dev, "GPIO registration failed: %d\n", ret);
670 }
671
672 static void ricoh583_irq_lock(struct irq_data *irq_data)
673 {
674         struct ricoh583 *ricoh583 = irq_data_get_irq_chip_data(irq_data);
675
676         mutex_lock(&ricoh583->irq_lock);
677 }
678
679 static void ricoh583_irq_unmask(struct irq_data *irq_data)
680 {
681         struct ricoh583 *ricoh583 = irq_data_get_irq_chip_data(irq_data);
682         unsigned int __irq = irq_data->irq - ricoh583->irq_base;
683         const struct ricoh583_irq_data *data = &ricoh583_irqs[__irq];
684
685         ricoh583->group_irq_en[data->grp_index] |= (1 << data->grp_index);
686         if (ricoh583->group_irq_en[data->grp_index])
687                 ricoh583->intc_inten_reg |= 1 << data->master_bit;
688
689         ricoh583->irq_en_reg[data->mask_reg_index] |= 1 << data->int_en_bit;
690 }
691
692 static void ricoh583_irq_mask(struct irq_data *irq_data)
693 {
694         struct ricoh583 *ricoh583 = irq_data_get_irq_chip_data(irq_data);
695         unsigned int __irq = irq_data->irq - ricoh583->irq_base;
696         const struct ricoh583_irq_data *data = &ricoh583_irqs[__irq];
697
698         ricoh583->group_irq_en[data->grp_index] &= ~(1 << data->grp_index);
699         if (!ricoh583->group_irq_en[data->grp_index])
700                 ricoh583->intc_inten_reg &= ~(1 << data->master_bit);
701
702         ricoh583->irq_en_reg[data->mask_reg_index] &= ~(1 << data->int_en_bit);
703 }
704
705 static void ricoh583_irq_sync_unlock(struct irq_data *irq_data)
706 {
707         struct ricoh583 *ricoh583 = irq_data_get_irq_chip_data(irq_data);
708         int i;
709
710         for (i = 0; i < ARRAY_SIZE(ricoh583->gpedge_reg); i++) {
711                 if (ricoh583->gpedge_reg[i] != ricoh583->gpedge_cache[i]) {
712                         if (!WARN_ON(__ricoh583_write(ricoh583->client,
713                                                     ricoh583->gpedge_add[i],
714                                                     ricoh583->gpedge_reg[i])))
715                                 ricoh583->gpedge_cache[i] =
716                                                 ricoh583->gpedge_reg[i];
717                 }
718         }
719
720         for (i = 0; i < ARRAY_SIZE(ricoh583->irq_en_reg); i++) {
721                 if (ricoh583->irq_en_reg[i] != ricoh583->irq_en_cache[i]) {
722                         if (!WARN_ON(__ricoh583_write(ricoh583->client,
723                                             ricoh583->irq_en_add[i],
724                                                     ricoh583->irq_en_reg[i])))
725                                 ricoh583->irq_en_cache[i] =
726                                                 ricoh583->irq_en_reg[i];
727                 }
728         }
729
730         if (ricoh583->intc_inten_reg != ricoh583->intc_inten_cache) {
731                 if (!WARN_ON(__ricoh583_write(ricoh583->client,
732                                 RICOH583_INTC_INTEN, ricoh583->intc_inten_reg)))
733                         ricoh583->intc_inten_reg = ricoh583->intc_inten_cache;
734         }
735
736         mutex_unlock(&ricoh583->irq_lock);
737 }
738
739 static int ricoh583_irq_set_type(struct irq_data *irq_data, unsigned int type)
740 {
741         struct ricoh583 *ricoh583 = irq_data_get_irq_chip_data(irq_data);
742         unsigned int __irq = irq_data->irq - ricoh583->irq_base;
743         const struct ricoh583_irq_data *data = &ricoh583_irqs[__irq];
744         int val = 0;
745         int gpedge_index;
746         int gpedge_bit_pos;
747
748         if (data->int_type & GPIO_INT) {
749                 gpedge_index = data->int_en_bit / 4;
750                 gpedge_bit_pos = data->int_en_bit % 4;
751
752                 if (type & IRQ_TYPE_EDGE_FALLING)
753                         val |= 0x2;
754
755                 if (type & IRQ_TYPE_EDGE_RISING)
756                         val |= 0x1;
757
758                 ricoh583->gpedge_reg[gpedge_index] &= ~(3 << gpedge_bit_pos);
759                 ricoh583->gpedge_reg[gpedge_index] |= (val << gpedge_bit_pos);
760                 ricoh583_irq_unmask(irq_data);
761         }
762         return 0;
763 }
764
765 static irqreturn_t ricoh583_irq(int irq, void *data)
766 {
767         struct ricoh583 *ricoh583 = data;
768         u8 int_sts[9];
769         u8 master_int;
770         int i;
771         int ret;
772         u8 rtc_int_sts = 0;
773
774         /* Clear the status */
775         for (i = 0; i < 9; i++)
776                 int_sts[i] = 0;
777
778         ret  = __ricoh583_read(ricoh583->client, RICOH583_INTC_INTMON,
779                                                 &master_int);
780         if (ret < 0) {
781                 dev_err(ricoh583->dev, "Error in reading reg 0x%02x "
782                         "error: %d\n", RICOH583_INTC_INTMON, ret);
783                 return IRQ_HANDLED;
784         }
785
786         for (i = 0; i < 9; ++i) {
787                 if (!(master_int & ricoh583->main_int_type[i]))
788                         continue;
789                 ret = __ricoh583_read(ricoh583->client,
790                                 ricoh583->irq_mon_add[i], &int_sts[i]);
791                 if (ret < 0) {
792                         dev_err(ricoh583->dev, "Error in reading reg 0x%02x "
793                                 "error: %d\n", ricoh583->irq_mon_add[i], ret);
794                         int_sts[i] = 0;
795                         continue;
796                 }
797
798                 if (ricoh583->main_int_type[i] & RTC_INT) {
799                         rtc_int_sts = 0;
800                         if (int_sts[i] & 0x1)
801                                 rtc_int_sts |= BIT(6);
802                         if (int_sts[i] & 0x2)
803                                 rtc_int_sts |= BIT(7);
804                         if (int_sts[i] & 0x4)
805                                 rtc_int_sts |= BIT(0);
806                         if (int_sts[i] & 0x8)
807                                 rtc_int_sts |= BIT(5);
808                 }
809
810                 ret = __ricoh583_write(ricoh583->client,
811                                 ricoh583->irq_clr_add[i], ~int_sts[i]);
812                 if (ret < 0) {
813                         dev_err(ricoh583->dev, "Error in reading reg 0x%02x "
814                                 "error: %d\n", ricoh583->irq_clr_add[i], ret);
815                 }
816                 if (ricoh583->main_int_type[i] & RTC_INT)
817                         int_sts[i] = rtc_int_sts;
818         }
819
820         /* Merge gpio interrupts  for rising and falling case*/
821         int_sts[7] |= int_sts[8];
822
823         /* Call interrupt handler if enabled */
824         for (i = 0; i < RICOH583_NR_IRQS; ++i) {
825                 const struct ricoh583_irq_data *data = &ricoh583_irqs[i];
826                 if ((int_sts[data->mask_reg_index] & (1 << data->int_en_bit)) &&
827                         (ricoh583->group_irq_en[data->master_bit] &
828                                         (1 << data->grp_index)))
829                         handle_nested_irq(ricoh583->irq_base + i);
830         }
831         return IRQ_HANDLED;
832 }
833
834 static int __devinit ricoh583_irq_init(struct ricoh583 *ricoh583, int irq,
835                                 int irq_base)
836 {
837         int i, ret;
838
839         if (!irq_base) {
840                 dev_warn(ricoh583->dev, "No interrupt support on IRQ base\n");
841                 return -EINVAL;
842         }
843
844         mutex_init(&ricoh583->irq_lock);
845
846         /* Initialize all locals to 0 */
847         for (i = 0; i < MAX_INTERRUPT_MASKS; i++) {
848                 ricoh583->irq_en_cache[i] = 0;
849                 ricoh583->irq_en_reg[i] = 0;
850         }
851         ricoh583->intc_inten_cache = 0;
852         ricoh583->intc_inten_reg = 0;
853         for (i = 0; i < 2; i++) {
854                 ricoh583->gpedge_cache[i] = 0;
855                 ricoh583->gpedge_reg[i] = 0;
856         }
857
858         /* Interrupt enable register */
859         ricoh583->gpedge_add[0] = RICOH583_GPIO_GPEDGE2;
860         ricoh583->gpedge_add[1] = RICOH583_GPIO_GPEDGE1;
861         ricoh583->irq_en_add[0] = RICOH583_INT_EN_SYS1;
862         ricoh583->irq_en_add[1] = RICOH583_INT_EN_SYS2;
863         ricoh583->irq_en_add[2] = RICOH583_INT_EN_DCDC;
864         ricoh583->irq_en_add[3] = RICOH583_INT_EN_RTC;
865         ricoh583->irq_en_add[4] = RICOH583_INT_EN_ADC1;
866         ricoh583->irq_en_add[5] = RICOH583_INT_EN_ADC2;
867         ricoh583->irq_en_add[6] = RICOH583_INT_EN_ADC3;
868         ricoh583->irq_en_add[7] = RICOH583_INT_EN_GPIO;
869
870         /* Interrupt status monitor register */
871         ricoh583->irq_mon_add[0] = RICOH583_INT_MON_SYS1;
872         ricoh583->irq_mon_add[1] = RICOH583_INT_MON_SYS2;
873         ricoh583->irq_mon_add[2] = RICOH583_INT_MON_DCDC;
874         ricoh583->irq_mon_add[3] = RICOH583_INT_MON_RTC;
875         ricoh583->irq_mon_add[4] = RICOH583_INT_IR_ADCL;
876         ricoh583->irq_mon_add[5] = RICOH583_INT_IR_ADCH;
877         ricoh583->irq_mon_add[6] = RICOH583_INT_IR_ADCEND;
878         ricoh583->irq_mon_add[7] = RICOH583_INT_IR_GPIOF;
879         ricoh583->irq_mon_add[8] = RICOH583_INT_IR_GPIOR;
880
881         /* Interrupt status clear register */
882         ricoh583->irq_clr_add[0] = RICOH583_INT_IR_SYS1;
883         ricoh583->irq_clr_add[1] = RICOH583_INT_IR_SYS2;
884         ricoh583->irq_clr_add[2] = RICOH583_INT_IR_DCDC;
885         ricoh583->irq_clr_add[3] = RICOH583_INT_IR_RTC;
886         ricoh583->irq_clr_add[4] = RICOH583_INT_IR_ADCL;
887         ricoh583->irq_clr_add[5] = RICOH583_INT_IR_ADCH;
888         ricoh583->irq_clr_add[6] = RICOH583_INT_IR_ADCEND;
889         ricoh583->irq_clr_add[7] = RICOH583_INT_IR_GPIOF;
890         ricoh583->irq_clr_add[8] = RICOH583_INT_IR_GPIOR;
891
892         ricoh583->main_int_type[0] = SYS_INT;
893         ricoh583->main_int_type[1] = SYS_INT;
894         ricoh583->main_int_type[2] = DCDC_INT;
895         ricoh583->main_int_type[3] = RTC_INT;
896         ricoh583->main_int_type[4] = ADC_INT;
897         ricoh583->main_int_type[5] = ADC_INT;
898         ricoh583->main_int_type[6] = ADC_INT;
899         ricoh583->main_int_type[7] = GPIO_INT;
900         ricoh583->main_int_type[8] = GPIO_INT;
901
902         /* Initailize all int register to 0 */
903         for (i = 0; i < MAX_INTERRUPT_MASKS; i++)  {
904                 ret = __ricoh583_write(ricoh583->client,
905                                 ricoh583->irq_en_add[i],
906                                 ricoh583->irq_en_reg[i]);
907                 if (ret < 0)
908                         dev_err(ricoh583->dev, "Error in writing reg 0x%02x "
909                                 "error: %d\n", ricoh583->irq_en_add[i], ret);
910         }
911
912         for (i = 0; i < 2; i++)  {
913                 ret = __ricoh583_write(ricoh583->client,
914                                 ricoh583->gpedge_add[i],
915                                 ricoh583->gpedge_reg[i]);
916                 if (ret < 0)
917                         dev_err(ricoh583->dev, "Error in writing reg 0x%02x "
918                                 "error: %d\n", ricoh583->gpedge_add[i], ret);
919         }
920
921         ret = __ricoh583_write(ricoh583->client, RICOH583_INTC_INTEN, 0x0);
922         if (ret < 0)
923                 dev_err(ricoh583->dev, "Error in writing reg 0x%02x "
924                                 "error: %d\n", RICOH583_INTC_INTEN, ret);
925
926         /* Clear all interrupts in case they woke up active. */
927         for (i = 0; i < 9; i++)  {
928                 ret = __ricoh583_write(ricoh583->client,
929                                         ricoh583->irq_clr_add[i], 0);
930                 if (ret < 0)
931                         dev_err(ricoh583->dev, "Error in writing reg 0x%02x "
932                                 "error: %d\n", ricoh583->irq_clr_add[i], ret);
933         }
934
935         ricoh583->irq_base = irq_base;
936         ricoh583->irq_chip.name = "ricoh583";
937         ricoh583->irq_chip.irq_mask = ricoh583_irq_mask;
938         ricoh583->irq_chip.irq_unmask = ricoh583_irq_unmask;
939         ricoh583->irq_chip.irq_bus_lock = ricoh583_irq_lock;
940         ricoh583->irq_chip.irq_bus_sync_unlock = ricoh583_irq_sync_unlock;
941         ricoh583->irq_chip.irq_set_type = ricoh583_irq_set_type;
942
943         for (i = 0; i < RICOH583_NR_IRQS; i++) {
944                 int __irq = i + ricoh583->irq_base;
945                 irq_set_chip_data(__irq, ricoh583);
946                 irq_set_chip_and_handler(__irq, &ricoh583->irq_chip,
947                                          handle_simple_irq);
948                 irq_set_nested_thread(__irq, 1);
949 #ifdef CONFIG_ARM
950                 set_irq_flags(__irq, IRQF_VALID);
951 #endif
952         }
953
954         ret = request_threaded_irq(irq, NULL, ricoh583_irq, IRQF_ONESHOT,
955                                    "ricoh583", ricoh583);
956         if (ret < 0)
957                 dev_err(ricoh583->dev, "Error in registering interrupt "
958                                 "error: %d\n", ret);
959         if (!ret) {
960                 device_init_wakeup(ricoh583->dev, 1);
961                 enable_irq_wake(irq);
962         }
963         return ret;
964 }
965
966 static int ricoh583_remove_subdev(struct device *dev, void *unused)
967 {
968         platform_device_unregister(to_platform_device(dev));
969         return 0;
970 }
971
972 static int ricoh583_remove_subdevs(struct ricoh583 *ricoh583)
973 {
974         return device_for_each_child(ricoh583->dev, NULL,
975                                      ricoh583_remove_subdev);
976 }
977
978 static int __devinit ricoh583_add_subdevs(struct ricoh583 *ricoh583,
979                                 struct ricoh583_platform_data *pdata)
980 {
981         struct ricoh583_subdev_info *subdev;
982         struct platform_device *pdev;
983         int i, ret = 0;
984
985         for (i = 0; i < pdata->num_subdevs; i++) {
986                 subdev = &pdata->subdevs[i];
987
988                 pdev = platform_device_alloc(subdev->name, subdev->id);
989
990                 pdev->dev.parent = ricoh583->dev;
991                 pdev->dev.platform_data = subdev->platform_data;
992
993                 ret = platform_device_add(pdev);
994                 if (ret)
995                         goto failed;
996         }
997         return 0;
998
999 failed:
1000         ricoh583_remove_subdevs(ricoh583);
1001         return ret;
1002 }
1003
1004 #ifdef CONFIG_DEBUG_FS
1005 #include <linux/debugfs.h>
1006 #include <linux/seq_file.h>
1007 static void print_regs(const char *header, struct seq_file *s,
1008                 struct i2c_client *client, int start_offset,
1009                 int end_offset)
1010 {
1011         uint8_t reg_val;
1012         int i;
1013         int ret;
1014
1015         seq_printf(s, "%s\n", header);
1016         for (i = start_offset; i <= end_offset; ++i) {
1017                 ret = __ricoh583_read(client, i, &reg_val);
1018                 if (ret >= 0)
1019                         seq_printf(s, "Reg 0x%02x Value 0x%02x\n", i, reg_val);
1020         }
1021         seq_printf(s, "------------------\n");
1022 }
1023
1024 static int dbg_tps_show(struct seq_file *s, void *unused)
1025 {
1026         struct ricoh583 *tps = s->private;
1027         struct i2c_client *client = tps->client;
1028
1029         seq_printf(s, "RICOH583 Registers\n");
1030         seq_printf(s, "------------------\n");
1031
1032         print_regs("System Regs",              s, client, 0x0, 0xF);
1033         print_regs("Power Control Regs",        s, client, 0x10, 0x2B);
1034         print_regs("DCDC1 Regs",                s, client, 0x30, 0x43);
1035         print_regs("DCDC1 Regs",                s, client, 0x60, 0x63);
1036         print_regs("LDO   Regs",                s, client, 0x50, 0x5F);
1037         print_regs("LDO   Regs",                s, client, 0x64, 0x6D);
1038         print_regs("ADC  Regs",          s, client, 0x70, 0x72);
1039         print_regs("ADC  Regs",          s, client, 0x74, 0x8B);
1040         print_regs("ADC  Regs",          s, client, 0x90, 0x96);
1041         print_regs("GPIO Regs",          s, client, 0xA0, 0xAC);
1042         print_regs("INTC Regs",          s, client, 0xAD, 0xAF);
1043         print_regs("RTC  Regs",          s, client, 0xE0, 0xEE);
1044         print_regs("RTC  Regs",          s, client, 0xF0, 0xF4);
1045         return 0;
1046 }
1047
1048 static int dbg_tps_open(struct inode *inode, struct file *file)
1049 {
1050         return single_open(file, dbg_tps_show, inode->i_private);
1051 }
1052
1053 static const struct file_operations debug_fops = {
1054         .open      = dbg_tps_open,
1055         .read      = seq_read,
1056         .llseek  = seq_lseek,
1057         .release        = single_release,
1058 };
1059 static void __init ricoh583_debuginit(struct ricoh583 *tps)
1060 {
1061         (void)debugfs_create_file("ricoh583", S_IRUGO, NULL,
1062                         tps, &debug_fops);
1063 }
1064 #else
1065 static void __init ricoh583_debuginit(struct ricoh583 *tpsi)
1066 {
1067         return;
1068 }
1069 #endif
1070
1071 static int ricoh583_i2c_probe(struct i2c_client *i2c,
1072                               const struct i2c_device_id *id)
1073 {
1074         struct ricoh583 *ricoh583;
1075         struct ricoh583_platform_data *pdata = i2c->dev.platform_data;
1076         int ret;
1077
1078         ricoh583 = kzalloc(sizeof(struct ricoh583), GFP_KERNEL);
1079         if (ricoh583 == NULL)
1080                 return -ENOMEM;
1081
1082         ricoh583->client = i2c;
1083         ricoh583->dev = &i2c->dev;
1084         i2c_set_clientdata(i2c, ricoh583);
1085
1086         mutex_init(&ricoh583->io_lock);
1087
1088         ret = ricoh583_ext_power_init(ricoh583, pdata);
1089         if (ret < 0)
1090                 goto err_irq_init;
1091
1092         if (i2c->irq) {
1093                 ret = ricoh583_irq_init(ricoh583, i2c->irq, pdata->irq_base);
1094                 if (ret) {
1095                         dev_err(&i2c->dev, "IRQ init failed: %d\n", ret);
1096                         goto err_irq_init;
1097                 }
1098         }
1099
1100         ret = ricoh583_add_subdevs(ricoh583, pdata);
1101         if (ret) {
1102                 dev_err(&i2c->dev, "add devices failed: %d\n", ret);
1103                 goto err_add_devs;
1104         }
1105
1106         ricoh583_gpio_init(ricoh583, pdata);
1107
1108         ricoh583_debuginit(ricoh583);
1109
1110         ricoh583_i2c_client = i2c;
1111         return 0;
1112
1113 err_add_devs:
1114         if (i2c->irq)
1115                 free_irq(i2c->irq, ricoh583);
1116 err_irq_init:
1117         kfree(ricoh583);
1118         return ret;
1119 }
1120
1121 static int  __devexit ricoh583_i2c_remove(struct i2c_client *i2c)
1122 {
1123         struct ricoh583 *ricoh583 = i2c_get_clientdata(i2c);
1124
1125         if (i2c->irq)
1126                 free_irq(i2c->irq, ricoh583);
1127
1128         ricoh583_remove_subdevs(ricoh583);
1129         kfree(ricoh583);
1130         return 0;
1131 }
1132
1133 #ifdef CONFIG_PM
1134 static int ricoh583_i2c_suspend(struct i2c_client *i2c, pm_message_t state)
1135 {
1136         if (i2c->irq)
1137                 disable_irq(i2c->irq);
1138         return 0;
1139 }
1140
1141
1142 static int ricoh583_i2c_resume(struct i2c_client *i2c)
1143 {
1144         if (i2c->irq)
1145                 enable_irq(i2c->irq);
1146         return 0;
1147 }
1148
1149 #endif
1150
1151 static const struct i2c_device_id ricoh583_i2c_id[] = {
1152         {"ricoh583", 0},
1153         {}
1154 };
1155
1156 MODULE_DEVICE_TABLE(i2c, ricoh583_i2c_id);
1157
1158 static struct i2c_driver ricoh583_i2c_driver = {
1159         .driver = {
1160                    .name = "ricoh583",
1161                    .owner = THIS_MODULE,
1162                    },
1163         .probe = ricoh583_i2c_probe,
1164         .remove = __devexit_p(ricoh583_i2c_remove),
1165 #ifdef CONFIG_PM
1166         .suspend = ricoh583_i2c_suspend,
1167         .resume = ricoh583_i2c_resume,
1168 #endif
1169         .id_table = ricoh583_i2c_id,
1170 };
1171
1172
1173 static int __init ricoh583_i2c_init(void)
1174 {
1175         int ret = -ENODEV;
1176         ret = i2c_add_driver(&ricoh583_i2c_driver);
1177         if (ret != 0)
1178                 pr_err("Failed to register I2C driver: %d\n", ret);
1179
1180         return ret;
1181 }
1182
1183 subsys_initcall(ricoh583_i2c_init);
1184
1185 static void __exit ricoh583_i2c_exit(void)
1186 {
1187         i2c_del_driver(&ricoh583_i2c_driver);
1188 }
1189
1190 module_exit(ricoh583_i2c_exit);
1191
1192 MODULE_DESCRIPTION("RICOH583 multi-function core driver");
1193 MODULE_LICENSE("GPL");