projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[rb532] refresh 2.6.24 patches
[openwrt.git] / target / linux / s3c24xx / patches-2.6.26 / 1006-gta01-pcf50606.patch.patch
1 From cb7ab7ce6ad690be5f71bde73a9369d3640985e8 Mon Sep 17 00:00:00 2001
2 From: mokopatches <mokopatches@openmoko.org>
3 Date: Wed, 16 Jul 2008 14:44:11 +0100
4 Subject: [PATCH] gta01-pcf50606.patch
5 This is a NXP PCF50606 power management unit driver.
6
7 The PCF50606 is used in the FIC/OpenMoko Neo1973 GTA01 GSM phone.
8
9 Signed-off-by: Harald Welte <laforge@openmoko.org>
10 ---
11 drivers/i2c/chips/Kconfig | 11 +
12 drivers/i2c/chips/Makefile | 1 +
13 drivers/i2c/chips/pcf50606.c | 1945 ++++++++++++++++++++++++++++++++++++++++++
14 drivers/i2c/chips/pcf50606.h | 302 +++++++
15 include/linux/i2c-id.h | 1 +
16 include/linux/pcf50606.h | 108 +++
17 6 files changed, 2368 insertions(+), 0 deletions(-)
18 create mode 100644 drivers/i2c/chips/pcf50606.c
19 create mode 100644 drivers/i2c/chips/pcf50606.h
20 create mode 100644 include/linux/pcf50606.h
21
22 diff --git a/drivers/i2c/chips/Kconfig b/drivers/i2c/chips/Kconfig
23 index 2da2edf..e8e64aa 100644
24 --- a/drivers/i2c/chips/Kconfig
25 +++ b/drivers/i2c/chips/Kconfig
26 @@ -25,6 +25,17 @@ config SENSORS_EEPROM
27 This driver can also be built as a module. If so, the module
28 will be called eeprom.
29
30 +config SENSORS_PCF50606
31 + tristate "Philips/NXP PCF50606"
32 + depends on I2C
33 + help
34 + If you say yes here you get support for Philips/NXP PCF50606
35 + PMU (Power Management Unit) chips.
36 +
37 + This driver can also be built as a module. If so, the module
38 + will be called pcf50606.
39 +
40 +
41 config SENSORS_PCF8574
42 tristate "Philips PCF8574 and PCF8574A"
43 depends on EXPERIMENTAL
44 diff --git a/drivers/i2c/chips/Makefile b/drivers/i2c/chips/Makefile
45 index e47aca0..60d3d5a 100644
46 --- a/drivers/i2c/chips/Makefile
47 +++ b/drivers/i2c/chips/Makefile
48 @@ -13,6 +13,7 @@ obj-$(CONFIG_DS1682) += ds1682.o
49 obj-$(CONFIG_SENSORS_EEPROM) += eeprom.o
50 obj-$(CONFIG_SENSORS_MAX6875) += max6875.o
51 obj-$(CONFIG_SENSORS_PCA9539) += pca9539.o
52 +obj-$(CONFIG_SENSORS_PCF50606) += pcf50606.o
53 obj-$(CONFIG_SENSORS_PCF8574) += pcf8574.o
54 obj-$(CONFIG_PCF8575) += pcf8575.o
55 obj-$(CONFIG_SENSORS_PCF8591) += pcf8591.o
56 diff --git a/drivers/i2c/chips/pcf50606.c b/drivers/i2c/chips/pcf50606.c
57 new file mode 100644
58 index 0000000..6626c68
59 --- /dev/null
60 +++ b/drivers/i2c/chips/pcf50606.c
61 @@ -0,0 +1,1945 @@
62 +/* Philips/NXP PCF50606 Power Management Unit (PMU) driver
63 + *
64 + * (C) 2006-2007 by OpenMoko, Inc.
65 + * Authors: Harald Welte <laforge@openmoko.org>,
66 + * Matt Hsu <matt@openmoko.org>
67 + * All rights reserved.
68 + *
69 + * This program is free software; you can redistribute it and/or
70 + * modify it under the terms of the GNU General Public License as
71 + * published by the Free Software Foundation; either version 2 of
72 + * the License, or (at your option) any later version.
73 + *
74 + * This program is distributed in the hope that it will be useful,
75 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
76 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
77 + * GNU General Public License for more details.
78 + *
79 + * You should have received a copy of the GNU General Public License
80 + * along with this program; if not, write to the Free Software
81 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
82 + * MA 02111-1307 USA
83 + *
84 + * This driver is a monster ;) It provides the following features
85 + * - voltage control for a dozen different voltage domains
86 + * - charging control for main and backup battery
87 + * - rtc / alarm
88 + * - watchdog
89 + * - adc driver (hw_sensors like)
90 + * - pwm driver
91 + * - backlight
92 + *
93 + */
94 +
95 +#include <linux/module.h>
96 +#include <linux/init.h>
97 +#include <linux/i2c.h>
98 +#include <linux/types.h>
99 +#include <linux/interrupt.h>
100 +#include <linux/irq.h>
101 +#include <linux/workqueue.h>
102 +#include <linux/rtc.h>
103 +#include <linux/bcd.h>
104 +#include <linux/watchdog.h>
105 +#include <linux/miscdevice.h>
106 +#include <linux/input.h>
107 +#include <linux/fb.h>
108 +#include <linux/backlight.h>
109 +#include <linux/sched.h>
110 +#include <linux/platform_device.h>
111 +#include <linux/pcf50606.h>
112 +#include <linux/apm-emulation.h>
113 +
114 +#include <asm/mach-types.h>
115 +#include <asm/arch/gta01.h>
116 +
117 +#include "pcf50606.h"
118 +
119 +/* we use dev_dbg() throughout the code, but sometimes don't want to
120 + * write an entire line of debug related information. This DEBUGPC
121 + * macro is a continuation for dev_dbg() */
122 +#ifdef DEBUG
123 +#define DEBUGPC(x, args ...) printk(x, ## args)
124 +#else
125 +#define DEBUGPC(x, args ...)
126 +#endif
127 +
128 +/***********************************************************************
129 + * Static data / structures
130 + ***********************************************************************/
131 +
132 +static unsigned short normal_i2c[] = { 0x08, I2C_CLIENT_END };
133 +
134 +I2C_CLIENT_INSMOD_1(pcf50606);
135 +
136 +#define PCF50606_F_CHG_FAST 0x00000001 /* Charger Fast allowed */
137 +#define PCF50606_F_CHG_PRESENT 0x00000002 /* Charger present */
138 +#define PCF50606_F_CHG_FOK 0x00000004 /* Fast OK for battery */
139 +#define PCF50606_F_CHG_ERR 0x00000008 /* Charger Error */
140 +#define PCF50606_F_CHG_PROT 0x00000010 /* Charger Protection */
141 +#define PCF50606_F_CHG_READY 0x00000020 /* Charging completed */
142 +#define PCF50606_F_CHG_MASK 0x000000fc
143 +
144 +#define PCF50606_F_PWR_PRESSED 0x00000100
145 +#define PCF50606_F_RTC_SECOND 0x00000200
146 +
147 +enum close_state {
148 + CLOSE_STATE_NOT,
149 + CLOSE_STATE_ALLOW = 0x2342,
150 +};
151 +
152 +struct pcf50606_data {
153 + struct i2c_client client;
154 + struct pcf50606_platform_data *pdata;
155 + struct backlight_device *backlight;
156 + struct mutex lock;
157 + unsigned int flags;
158 + unsigned int working;
159 + struct mutex working_lock;
160 + struct work_struct work;
161 + struct rtc_device *rtc;
162 + struct input_dev *input_dev;
163 + int allow_close;
164 + int onkey_seconds;
165 + int irq;
166 +#ifdef CONFIG_PM
167 + struct {
168 + u_int8_t dcdc1, dcdc2;
169 + u_int8_t dcdec1;
170 + u_int8_t dcudc1;
171 + u_int8_t ioregc;
172 + u_int8_t d1regc1;
173 + u_int8_t d2regc1;
174 + u_int8_t d3regc1;
175 + u_int8_t lpregc1;
176 + u_int8_t adcc1, adcc2;
177 + u_int8_t pwmc1;
178 + u_int8_t int1m, int2m, int3m;
179 + } standby_regs;
180 +#endif
181 +};
182 +
183 +static struct i2c_driver pcf50606_driver;
184 +
185 +/* This is an ugly construct on how to access the (currently single/global)
186 + * pcf50606 handle from other code in the kernel. I didn't really come up with
187 + * a more decent method of dynamically resolving this */
188 +struct pcf50606_data *pcf50606_global;
189 +EXPORT_SYMBOL_GPL(pcf50606_global);
190 +
191 +static struct platform_device *pcf50606_pdev;
192 +
193 +/* This is a 10k, B=3370 NTC Thermistor -10..79 centigrade */
194 +/* Table entries are offset by +0.5C so a properly rounded value is generated */
195 +static const u_int16_t ntc_table_10k_3370B[] = {
196 + /* -10 */
197 + 43888, 41819, 39862, 38010, 36257, 34596, 33024, 31534, 30121, 28781,
198 + 27510, 26304, 25159, 24071, 23038, 22056, 21122, 20234, 19390, 18586,
199 + 17821, 17093, 16399, 15738, 15107, 14506, 13933, 13387, 12865, 12367,
200 + 11891, 11437, 11003, 10588, 10192, 9813, 9450, 9103, 8771, 8453,
201 + 8149, 7857, 7578, 7310, 7054, 6808, 6572, 6346, 6129, 5920,
202 + 5720, 5528, 5344, 5167, 4996, 4833, 4675, 4524, 4379, 4239,
203 + 4104, 3975, 3850, 3730, 3614, 3503, 3396, 3292, 3193, 3097,
204 + 3004, 2915, 2829, 2745, 2665, 2588, 2513, 2441, 2371, 2304,
205 + 2239, 2176, 2116, 2057, 2000, 1945, 1892, 1841, 1791, 1743,
206 +};
207 +
208 +
209 +/***********************************************************************
210 + * Low-Level routines
211 + ***********************************************************************/
212 +
213 +static inline int __reg_write(struct pcf50606_data *pcf, u_int8_t reg,
214 + u_int8_t val)
215 +{
216 + return i2c_smbus_write_byte_data(&pcf->client, reg, val);
217 +}
218 +
219 +static int reg_write(struct pcf50606_data *pcf, u_int8_t reg, u_int8_t val)
220 +{
221 + int ret;
222 +
223 + mutex_lock(&pcf->lock);
224 + ret = __reg_write(pcf, reg, val);
225 + mutex_unlock(&pcf->lock);
226 +
227 + return ret;
228 +}
229 +
230 +static inline int32_t __reg_read(struct pcf50606_data *pcf, u_int8_t reg)
231 +{
232 + int32_t ret;
233 +
234 + ret = i2c_smbus_read_byte_data(&pcf->client, reg);
235 +
236 + return ret;
237 +}
238 +
239 +static u_int8_t reg_read(struct pcf50606_data *pcf, u_int8_t reg)
240 +{
241 + int32_t ret;
242 +
243 + mutex_lock(&pcf->lock);
244 + ret = __reg_read(pcf, reg);
245 + mutex_unlock(&pcf->lock);
246 +
247 + return ret & 0xff;
248 +}
249 +
250 +static int reg_set_bit_mask(struct pcf50606_data *pcf,
251 + u_int8_t reg, u_int8_t mask, u_int8_t val)
252 +{
253 + int ret;
254 + u_int8_t tmp;
255 +
256 + val &= mask;
257 +
258 + mutex_lock(&pcf->lock);
259 +
260 + tmp = __reg_read(pcf, reg);
261 + tmp &= ~mask;
262 + tmp |= val;
263 + ret = __reg_write(pcf, reg, tmp);
264 +
265 + mutex_unlock(&pcf->lock);
266 +
267 + return ret;
268 +}
269 +
270 +static int reg_clear_bits(struct pcf50606_data *pcf, u_int8_t reg, u_int8_t val)
271 +{
272 + int ret;
273 + u_int8_t tmp;
274 +
275 + mutex_lock(&pcf->lock);
276 +
277 + tmp = __reg_read(pcf, reg);
278 + tmp &= ~val;
279 + ret = __reg_write(pcf, reg, tmp);
280 +
281 + mutex_unlock(&pcf->lock);
282 +
283 + return ret;
284 +}
285 +
286 +/* synchronously read one ADC channel (busy-wait for result to be complete) */
287 +static u_int16_t adc_read(struct pcf50606_data *pcf, int channel,
288 + u_int16_t *data2)
289 +{
290 + u_int8_t adcs2, adcs1;
291 + u_int16_t ret;
292 +
293 + dev_dbg(&pcf->client.dev, "entering (pcf=%p, channel=%u, data2=%p)\n",
294 + pcf, channel, data2);
295 +
296 + channel &= PCF50606_ADCC2_ADCMUX_MASK;
297 +
298 + mutex_lock(&pcf->lock);
299 +
300 + /* start ADC conversion of selected channel */
301 + __reg_write(pcf, PCF50606_REG_ADCC2, channel |
302 + PCF50606_ADCC2_ADCSTART | PCF50606_ADCC2_RES_10BIT);
303 +
304 + do {
305 + adcs2 = __reg_read(pcf, PCF50606_REG_ADCS2);
306 + } while (!(adcs2 & PCF50606_ADCS2_ADCRDY));
307 +
308 + adcs1 = __reg_read(pcf, PCF50606_REG_ADCS1);
309 + ret = (adcs1 << 2) | (adcs2 & 0x03);
310 +
311 + if (data2) {
312 + adcs1 = __reg_read(pcf, PCF50606_REG_ADCS3);
313 + *data2 = (adcs1 << 2) | ((adcs2 & 0x0c) >> 2);
314 + }
315 +
316 + mutex_unlock(&pcf->lock);
317 +
318 + dev_dbg(&pcf->client.dev, "returning %u %u\n", ret,
319 + data2 ? *data2 : 0);
320 +
321 + return ret;
322 +}
323 +
324 +/***********************************************************************
325 + * Voltage / ADC
326 + ***********************************************************************/
327 +
328 +static u_int8_t dcudc_voltage(unsigned int millivolts)
329 +{
330 + if (millivolts < 900)
331 + return 0;
332 + if (millivolts > 5500)
333 + return 0x1f;
334 + if (millivolts <= 3300) {
335 + millivolts -= 900;
336 + return millivolts/300;
337 + }
338 + if (millivolts < 4000)
339 + return 0x0f;
340 + else {
341 + millivolts -= 4000;
342 + return millivolts/100;
343 + }
344 +}
345 +
346 +static unsigned int dcudc_2voltage(u_int8_t bits)
347 +{
348 + bits &= 0x1f;
349 + if (bits < 0x08)
350 + return 900 + bits * 300;
351 + else if (bits < 0x10)
352 + return 3300;
353 + else
354 + return 4000 + bits * 100;
355 +}
356 +
357 +static u_int8_t dcdec_voltage(unsigned int millivolts)
358 +{
359 + if (millivolts < 900)
360 + return 0;
361 + else if (millivolts > 3300)
362 + return 0x0f;
363 +
364 + millivolts -= 900;
365 + return millivolts/300;
366 +}
367 +
368 +static unsigned int dcdec_2voltage(u_int8_t bits)
369 +{
370 + bits &= 0x0f;
371 + return 900 + bits*300;
372 +}
373 +
374 +static u_int8_t dcdc_voltage(unsigned int millivolts)
375 +{
376 + if (millivolts < 900)
377 + return 0;
378 + else if (millivolts > 3600)
379 + return 0x1f;
380 +
381 + if (millivolts < 1500) {
382 + millivolts -= 900;
383 + return millivolts/25;
384 + } else {
385 + millivolts -= 1500;
386 + return 0x18 + millivolts/300;
387 + }
388 +}
389 +
390 +static unsigned int dcdc_2voltage(u_int8_t bits)
391 +{
392 + bits &= 0x1f;
393 + if ((bits & 0x18) == 0x18)
394 + return 1500 + ((bits & 0x7) * 300);
395 + else
396 + return 900 + (bits * 25);
397 +}
398 +
399 +static u_int8_t dx_voltage(unsigned int millivolts)
400 +{
401 + if (millivolts < 900)
402 + return 0;
403 + else if (millivolts > 3300)
404 + return 0x18;
405 +
406 + millivolts -= 900;
407 + return millivolts/100;
408 +}
409 +
410 +static unsigned int dx_2voltage(u_int8_t bits)
411 +{
412 + bits &= 0x1f;
413 + return 900 + (bits * 100);
414 +}
415 +
416 +static const u_int8_t regulator_registers[__NUM_PCF50606_REGULATORS] = {
417 + [PCF50606_REGULATOR_DCD] = PCF50606_REG_DCDC1,
418 + [PCF50606_REGULATOR_DCDE] = PCF50606_REG_DCDEC1,
419 + [PCF50606_REGULATOR_DCUD] = PCF50606_REG_DCUDC1,
420 + [PCF50606_REGULATOR_D1REG] = PCF50606_REG_D1REGC1,
421 + [PCF50606_REGULATOR_D2REG] = PCF50606_REG_D2REGC1,
422 + [PCF50606_REGULATOR_D3REG] = PCF50606_REG_D3REGC1,
423 + [PCF50606_REGULATOR_LPREG] = PCF50606_REG_LPREGC1,
424 + [PCF50606_REGULATOR_IOREG] = PCF50606_REG_IOREGC,
425 +};
426 +
427 +int pcf50606_onoff_set(struct pcf50606_data *pcf,
428 + enum pcf50606_regulator_id reg, int on)
429 +{
430 + u_int8_t addr;
431 +
432 + if (reg >= __NUM_PCF50606_REGULATORS)
433 + return -EINVAL;
434 +
435 + /* IOREG cannot be powered off since it powers the PMU I2C */
436 + if (reg == PCF50606_REGULATOR_IOREG)
437 + return -EIO;
438 +
439 + addr = regulator_registers[reg];
440 +
441 + if (on == 0)
442 + reg_set_bit_mask(pcf, addr, 0xe0, 0x00);
443 + else
444 + reg_set_bit_mask(pcf, addr, 0xe0, 0xe0);
445 +
446 + return 0;
447 +}
448 +EXPORT_SYMBOL_GPL(pcf50606_onoff_set);
449 +
450 +int pcf50606_onoff_get(struct pcf50606_data *pcf,
451 + enum pcf50606_regulator_id reg)
452 +{
453 + u_int8_t val, addr;
454 +
455 + if (reg >= __NUM_PCF50606_REGULATORS)
456 + return -EINVAL;
457 +
458 + addr = regulator_registers[reg];
459 + val = (reg_read(pcf, addr) & 0xe0) >> 5;
460 +
461 + /* PWREN1 = 1, PWREN2 = 1, see table 16 of datasheet */
462 + switch (val) {
463 + case 0:
464 + case 5:
465 + return 0;
466 + default:
467 + return 1;
468 + }
469 +}
470 +EXPORT_SYMBOL_GPL(pcf50606_onoff_get);
471 +
472 +int pcf50606_voltage_set(struct pcf50606_data *pcf,
473 + enum pcf50606_regulator_id reg,
474 + unsigned int millivolts)
475 +{
476 + u_int8_t volt_bits;
477 + u_int8_t regnr;
478 + int rc;
479 +
480 + dev_dbg(&pcf->client.dev, "pcf=%p, reg=%d, mvolts=%d\n", pcf, reg,
481 + millivolts);
482 +
483 + if (reg >= __NUM_PCF50606_REGULATORS)
484 + return -EINVAL;
485 +
486 + if (millivolts > pcf->pdata->rails[reg].voltage.max)
487 + return -EINVAL;
488 +
489 + switch (reg) {
490 + case PCF50606_REGULATOR_DCD:
491 + volt_bits = dcdc_voltage(millivolts);
492 + rc = reg_set_bit_mask(pcf, PCF50606_REG_DCDC1, 0x1f,
493 + volt_bits);
494 + break;
495 + case PCF50606_REGULATOR_DCDE:
496 + volt_bits = dcdec_voltage(millivolts);
497 + rc = reg_set_bit_mask(pcf, PCF50606_REG_DCDEC1, 0x0f,
498 + volt_bits);
499 + break;
500 + case PCF50606_REGULATOR_DCUD:
501 + volt_bits = dcudc_voltage(millivolts);
502 + rc = reg_set_bit_mask(pcf, PCF50606_REG_DCUDC1, 0x1f,
503 + volt_bits);
504 + break;
505 + case PCF50606_REGULATOR_D1REG:
506 + case PCF50606_REGULATOR_D2REG:
507 + case PCF50606_REGULATOR_D3REG:
508 + regnr = PCF50606_REG_D1REGC1 + (reg - PCF50606_REGULATOR_D1REG);
509 + volt_bits = dx_voltage(millivolts);
510 + rc = reg_set_bit_mask(pcf, regnr, 0x1f, volt_bits);
511 + break;
512 + case PCF50606_REGULATOR_LPREG:
513 + volt_bits = dx_voltage(millivolts);
514 + rc = reg_set_bit_mask(pcf, PCF50606_REG_LPREGC1, 0x1f,
515 + volt_bits);
516 + break;
517 + case PCF50606_REGULATOR_IOREG:
518 + if (millivolts < 1800)
519 + return -EINVAL;
520 + volt_bits = dx_voltage(millivolts);
521 + rc = reg_set_bit_mask(pcf, PCF50606_REG_IOREGC, 0x1f,
522 + volt_bits);
523 + break;
524 + default:
525 + return -EINVAL;
526 + }
527 +
528 + return rc;
529 +}
530 +EXPORT_SYMBOL_GPL(pcf50606_voltage_set);
531 +
532 +unsigned int pcf50606_voltage_get(struct pcf50606_data *pcf,
533 + enum pcf50606_regulator_id reg)
534 +{
535 + u_int8_t volt_bits;
536 + u_int8_t regnr;
537 + unsigned int rc = 0;
538 +
539 + if (reg >= __NUM_PCF50606_REGULATORS)
540 + return -EINVAL;
541 +
542 + switch (reg) {
543 + case PCF50606_REGULATOR_DCD:
544 + volt_bits = reg_read(pcf, PCF50606_REG_DCDC1) & 0x1f;
545 + rc = dcdc_2voltage(volt_bits);
546 + break;
547 + case PCF50606_REGULATOR_DCDE:
548 + volt_bits = reg_read(pcf, PCF50606_REG_DCDEC1) & 0x0f;
549 + rc = dcdec_2voltage(volt_bits);
550 + break;
551 + case PCF50606_REGULATOR_DCUD:
552 + volt_bits = reg_read(pcf, PCF50606_REG_DCUDC1) & 0x1f;
553 + rc = dcudc_2voltage(volt_bits);
554 + break;
555 + case PCF50606_REGULATOR_D1REG:
556 + case PCF50606_REGULATOR_D2REG:
557 + case PCF50606_REGULATOR_D3REG:
558 + regnr = PCF50606_REG_D1REGC1 + (reg - PCF50606_REGULATOR_D1REG);
559 + volt_bits = reg_read(pcf, regnr) & 0x1f;
560 + if (volt_bits > 0x18)
561 + volt_bits = 0x18;
562 + rc = dx_2voltage(volt_bits);
563 + break;
564 + case PCF50606_REGULATOR_LPREG:
565 + volt_bits = reg_read(pcf, PCF50606_REG_LPREGC1) & 0x1f;
566 + if (volt_bits > 0x18)
567 + volt_bits = 0x18;
568 + rc = dx_2voltage(volt_bits);
569 + break;
570 + case PCF50606_REGULATOR_IOREG:
571 + volt_bits = reg_read(pcf, PCF50606_REG_IOREGC) & 0x1f;
572 + if (volt_bits > 0x18)
573 + volt_bits = 0x18;
574 + rc = dx_2voltage(volt_bits);
575 + break;
576 + default:
577 + return -EINVAL;
578 + }
579 +
580 + return rc;
581 +}
582 +EXPORT_SYMBOL_GPL(pcf50606_voltage_get);
583 +
584 +/* go into 'STANDBY' mode, i.e. power off the main CPU and peripherals */
585 +void pcf50606_go_standby(void)
586 +{
587 + reg_write(pcf50606_global, PCF50606_REG_OOCC1,
588 + PCF50606_OOCC1_GOSTDBY);
589 +}
590 +EXPORT_SYMBOL_GPL(pcf50606_go_standby);
591 +
592 +void pcf50606_gpo0_set(struct pcf50606_data *pcf, int on)
593 +{
594 + u_int8_t val;
595 +
596 + if (on)
597 + val = 0x07;
598 + else
599 + val = 0x0f;
600 +
601 + reg_set_bit_mask(pcf, PCF50606_REG_GPOC1, 0x0f, val);
602 +}
603 +EXPORT_SYMBOL_GPL(pcf50606_gpo0_set);
604 +
605 +int pcf50606_gpo0_get(struct pcf50606_data *pcf)
606 +{
607 + u_int8_t reg = reg_read(pcf, PCF50606_REG_GPOC1) & 0x0f;
608 +
609 + if (reg == 0x07 || reg == 0x08)
610 + return 1;
611 +
612 + return 0;
613 +}
614 +EXPORT_SYMBOL_GPL(pcf50606_gpo0_get);
615 +
616 +static void pcf50606_work(struct work_struct *work)
617 +{
618 + struct pcf50606_data *pcf =
619 + container_of(work, struct pcf50606_data, work);
620 + u_int8_t pcfirq[3];
621 + int ret;
622 +
623 + mutex_lock(&pcf->working_lock);
624 + pcf->working = 1;
625 + /*
626 + * p35 pcf50606 datasheet rev 2.2:
627 + * ''The system controller shall read all interrupt registers in
628 + * one I2C read action''
629 + * because if you don't INT# gets stuck asserted forever after a
630 + * while
631 + */
632 + ret = i2c_smbus_read_i2c_block_data(&pcf->client, PCF50606_REG_INT1, 3,
633 + pcfirq);
634 + if (ret != 3)
635 + DEBUGPC("Oh crap PMU IRQ register read failed %d\n", ret);
636 +
637 + dev_dbg(&pcf->client.dev, "INT1=0x%02x INT2=0x%02x INT3=0x%02x:",
638 + pcfirq[0], pcfirq[1], pcfirq[2]);
639 +
640 + if (pcfirq[0] & PCF50606_INT1_ONKEYF) {
641 + /* ONKEY falling edge (start of button press) */
642 + DEBUGPC("ONKEYF ");
643 + pcf->flags |= PCF50606_F_PWR_PRESSED;
644 + input_report_key(pcf->input_dev, KEY_POWER, 1);
645 + }
646 + if (pcfirq[0] & PCF50606_INT1_ONKEY1S) {
647 + /* ONKEY pressed for more than 1 second */
648 + pcf->onkey_seconds = 0;
649 + DEBUGPC("ONKEY1S ");
650 + /* Tell PMU we are taking care of this */
651 + reg_set_bit_mask(pcf, PCF50606_REG_OOCC1,
652 + PCF50606_OOCC1_TOTRST,
653 + PCF50606_OOCC1_TOTRST);
654 + /* enable SECOND interrupt (hz tick) */
655 + reg_clear_bits(pcf, PCF50606_REG_INT1M, PCF50606_INT1_SECOND);
656 + }
657 + if (pcfirq[0] & PCF50606_INT1_ONKEYR) {
658 + /* ONKEY rising edge (end of button press) */
659 + DEBUGPC("ONKEYR ");
660 + pcf->flags &= ~PCF50606_F_PWR_PRESSED;
661 + pcf->onkey_seconds = -1;
662 + input_report_key(pcf->input_dev, KEY_POWER, 0);
663 + /* disable SECOND interrupt in case RTC didn't
664 + * request it */
665 + if (!(pcf->flags & PCF50606_F_RTC_SECOND))
666 + reg_set_bit_mask(pcf, PCF50606_REG_INT1M,
667 + PCF50606_INT1_SECOND,
668 + PCF50606_INT1_SECOND);
669 + }
670 + if (pcfirq[0] & PCF50606_INT1_EXTONR) {
671 + DEBUGPC("EXTONR ");
672 + input_report_key(pcf->input_dev, KEY_POWER2, 1);
673 + }
674 + if (pcfirq[0] & PCF50606_INT1_EXTONF) {
675 + DEBUGPC("EXTONF ");
676 + input_report_key(pcf->input_dev, KEY_POWER2, 0);
677 + }
678 + if (pcfirq[0] & PCF50606_INT1_SECOND) {
679 + DEBUGPC("SECOND ");
680 + if (pcf->flags & PCF50606_F_RTC_SECOND)
681 + rtc_update_irq(pcf->rtc, 1,
682 + RTC_PF | RTC_IRQF);
683 +
684 + if (pcf->onkey_seconds >= 0 &&
685 + pcf->flags & PCF50606_F_PWR_PRESSED) {
686 + DEBUGPC("ONKEY_SECONDS(%u, OOCC1=0x%02x) ",
687 + pcf->onkey_seconds,
688 + reg_read(pcf, PCF50606_REG_OOCC1));
689 + pcf->onkey_seconds++;
690 + if (pcf->onkey_seconds >=
691 + pcf->pdata->onkey_seconds_required) {
692 + /* Ask init to do 'ctrlaltdel' */
693 + DEBUGPC("SIGINT(init) ");
694 + kill_proc(1, SIGINT, 1);
695 + /* FIXME: what to do if userspace doesn't
696 + * shut down? Do we want to force it? */
697 + }
698 + }
699 + }
700 + if (pcfirq[0] & PCF50606_INT1_ALARM) {
701 + DEBUGPC("ALARM ");
702 + if (pcf->pdata->used_features & PCF50606_FEAT_RTC)
703 + rtc_update_irq(pcf->rtc, 1,
704 + RTC_AF | RTC_IRQF);
705 + }
706 +
707 + if (pcfirq[1] & PCF50606_INT2_CHGINS) {
708 + /* Charger inserted */
709 + DEBUGPC("CHGINS ");
710 + input_report_key(pcf->input_dev, KEY_BATTERY, 1);
711 + apm_queue_event(APM_POWER_STATUS_CHANGE);
712 + pcf->flags |= PCF50606_F_CHG_PRESENT;
713 + if (pcf->pdata->cb)
714 + pcf->pdata->cb(&pcf->client.dev,
715 + PCF50606_FEAT_MBC, PMU_EVT_INSERT);
716 + /* FIXME: how to signal this to userspace */
717 + }
718 + if (pcfirq[1] & PCF50606_INT2_CHGRM) {
719 + /* Charger removed */
720 + DEBUGPC("CHGRM ");
721 + input_report_key(pcf->input_dev, KEY_BATTERY, 0);
722 + apm_queue_event(APM_POWER_STATUS_CHANGE);
723 + pcf->flags &= ~(PCF50606_F_CHG_MASK|PCF50606_F_CHG_PRESENT);
724 + if (pcf->pdata->cb)
725 + pcf->pdata->cb(&pcf->client.dev,
726 + PCF50606_FEAT_MBC, PMU_EVT_INSERT);
727 + /* FIXME: how signal this to userspace */
728 + }
729 + if (pcfirq[1] & PCF50606_INT2_CHGFOK) {
730 + /* Battery ready for fast charging */
731 + DEBUGPC("CHGFOK ");
732 + pcf->flags |= PCF50606_F_CHG_FOK;
733 + /* FIXME: how to signal this to userspace */
734 + }
735 + if (pcfirq[1] & PCF50606_INT2_CHGERR) {
736 + /* Error in charge mode */
737 + DEBUGPC("CHGERR ");
738 + pcf->flags |= PCF50606_F_CHG_ERR;
739 + pcf->flags &= ~(PCF50606_F_CHG_FOK|PCF50606_F_CHG_READY);
740 + /* FIXME: how to signal this to userspace */
741 + }
742 + if (pcfirq[1] & PCF50606_INT2_CHGFRDY) {
743 + /* Fast charge completed */
744 + DEBUGPC("CHGFRDY ");
745 + pcf->flags |= PCF50606_F_CHG_READY;
746 + pcf->flags &= ~PCF50606_F_CHG_FOK;
747 + /* FIXME: how to signal this to userspace */
748 + }
749 + if (pcfirq[1] & PCF50606_INT2_CHGPROT) {
750 + /* Charging protection interrupt */
751 + DEBUGPC("CHGPROT ");
752 + pcf->flags &= ~(PCF50606_F_CHG_FOK|PCF50606_F_CHG_READY);
753 + /* FIXME: signal this to userspace */
754 + }
755 + if (pcfirq[1] & PCF50606_INT2_CHGWD10S) {
756 + /* Charger watchdog will expire in 10 seconds */
757 + DEBUGPC("CHGWD10S ");
758 + reg_set_bit_mask(pcf, PCF50606_REG_OOCC1,
759 + PCF50606_OOCC1_WDTRST,
760 + PCF50606_OOCC1_WDTRST);
761 + }
762 + if (pcfirq[1] & PCF50606_INT2_CHGWDEXP) {
763 + /* Charger watchdog expires */
764 + DEBUGPC("CHGWDEXP ");
765 + /* FIXME: how to signal this to userspace */
766 + }
767 +
768 + if (pcfirq[2] & PCF50606_INT3_ADCRDY) {
769 + /* ADC result ready */
770 + DEBUGPC("ADCRDY ");
771 + }
772 + if (pcfirq[2] & PCF50606_INT3_ACDINS) {
773 + /* Accessory insertion detected */
774 + DEBUGPC("ACDINS ");
775 + if (pcf->pdata->cb)
776 + pcf->pdata->cb(&pcf->client.dev,
777 + PCF50606_FEAT_ACD, PMU_EVT_INSERT);
778 + }
779 + if (pcfirq[2] & PCF50606_INT3_ACDREM) {
780 + /* Accessory removal detected */
781 + DEBUGPC("ACDREM ");
782 + if (pcf->pdata->cb)
783 + pcf->pdata->cb(&pcf->client.dev,
784 + PCF50606_FEAT_ACD, PMU_EVT_REMOVE);
785 + }
786 + /* FIXME: TSCPRES */
787 + if (pcfirq[2] & PCF50606_INT3_LOWBAT) {
788 + /* Really low battery voltage, we have 8 seconds left */
789 + DEBUGPC("LOWBAT ");
790 + apm_queue_event(APM_LOW_BATTERY);
791 + DEBUGPC("SIGPWR(init) ");
792 + kill_proc(1, SIGPWR, 1);
793 + /* Tell PMU we are taking care of this */
794 + reg_set_bit_mask(pcf, PCF50606_REG_OOCC1,
795 + PCF50606_OOCC1_TOTRST,
796 + PCF50606_OOCC1_TOTRST);
797 + }
798 + if (pcfirq[2] & PCF50606_INT3_HIGHTMP) {
799 + /* High temperature */
800 + DEBUGPC("HIGHTMP ");
801 + apm_queue_event(APM_CRITICAL_SUSPEND);
802 + }
803 +
804 + DEBUGPC("\n");
805 +
806 + pcf->working = 0;
807 + input_sync(pcf->input_dev);
808 + put_device(&pcf->client.dev);
809 + mutex_unlock(&pcf->working_lock);
810 +}
811 +
812 +static irqreturn_t pcf50606_irq(int irq, void *_pcf)
813 +{
814 + struct pcf50606_data *pcf = _pcf;
815 +
816 + dev_dbg(&pcf->client.dev, "entering(irq=%u, pcf=%p): scheduling work\n",
817 + irq, _pcf);
818 + get_device(&pcf->client.dev);
819 + if (!schedule_work(&pcf->work) && !pcf->working)
820 + dev_dbg(&pcf->client.dev, "work item may be lost\n");
821 +
822 + return IRQ_HANDLED;
823 +}
824 +
825 +static u_int16_t adc_to_batt_millivolts(u_int16_t adc)
826 +{
827 + u_int16_t mvolts;
828 +
829 + mvolts = (adc * 6000) / 1024;
830 +
831 + return mvolts;
832 +}
833 +
834 +#define BATTVOLT_SCALE_START 2800
835 +#define BATTVOLT_SCALE_END 4200
836 +#define BATTVOLT_SCALE_DIVIDER ((BATTVOLT_SCALE_END - BATTVOLT_SCALE_START)/100)
837 +
838 +static u_int8_t battvolt_scale(u_int16_t battvolt)
839 +{
840 + /* FIXME: this linear scale is completely bogus */
841 + u_int16_t battvolt_relative = battvolt - BATTVOLT_SCALE_START;
842 + unsigned int percent = battvolt_relative / BATTVOLT_SCALE_DIVIDER;
843 +
844 + return percent;
845 +}
846 +
847 +u_int16_t pcf50606_battvolt(struct pcf50606_data *pcf)
848 +{
849 + u_int16_t adc;
850 + adc = adc_read(pcf, PCF50606_ADCMUX_BATVOLT_RES, NULL);
851 +
852 + return adc_to_batt_millivolts(adc);
853 +}
854 +EXPORT_SYMBOL_GPL(pcf50606_battvolt);
855 +
856 +static ssize_t show_battvolt(struct device *dev, struct device_attribute *attr,
857 + char *buf)
858 +{
859 + struct i2c_client *client = to_i2c_client(dev);
860 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
861 +
862 + return sprintf(buf, "%u\n", pcf50606_battvolt(pcf));
863 +}
864 +static DEVICE_ATTR(battvolt, S_IRUGO | S_IWUSR, show_battvolt, NULL);
865 +
866 +static int reg_id_by_name(const char *name)
867 +{
868 + int reg_id;
869 +
870 + if (!strcmp(name, "voltage_dcd"))
871 + reg_id = PCF50606_REGULATOR_DCD;
872 + else if (!strcmp(name, "voltage_dcde"))
873 + reg_id = PCF50606_REGULATOR_DCDE;
874 + else if (!strcmp(name, "voltage_dcud"))
875 + reg_id = PCF50606_REGULATOR_DCUD;
876 + else if (!strcmp(name, "voltage_d1reg"))
877 + reg_id = PCF50606_REGULATOR_D1REG;
878 + else if (!strcmp(name, "voltage_d2reg"))
879 + reg_id = PCF50606_REGULATOR_D2REG;
880 + else if (!strcmp(name, "voltage_d3reg"))
881 + reg_id = PCF50606_REGULATOR_D3REG;
882 + else if (!strcmp(name, "voltage_lpreg"))
883 + reg_id = PCF50606_REGULATOR_LPREG;
884 + else if (!strcmp(name, "voltage_ioreg"))
885 + reg_id = PCF50606_REGULATOR_IOREG;
886 + else
887 + reg_id = -1;
888 +
889 + return reg_id;
890 +}
891 +
892 +static ssize_t show_vreg(struct device *dev, struct device_attribute *attr,
893 + char *buf)
894 +{
895 + struct i2c_client *client = to_i2c_client(dev);
896 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
897 + unsigned int reg_id;
898 +
899 + reg_id = reg_id_by_name(attr->attr.name);
900 + if (reg_id < 0)
901 + return 0;
902 +
903 + if (pcf50606_onoff_get(pcf, reg_id) > 0)
904 + return sprintf(buf, "%u\n", pcf50606_voltage_get(pcf, reg_id));
905 + else
906 + return strlcpy(buf, "0\n", PAGE_SIZE);
907 +}
908 +
909 +static ssize_t set_vreg(struct device *dev, struct device_attribute *attr,
910 + const char *buf, size_t count)
911 +{
912 + struct i2c_client *client = to_i2c_client(dev);
913 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
914 + unsigned long mvolts = simple_strtoul(buf, NULL, 10);
915 + unsigned int reg_id;
916 +
917 + reg_id = reg_id_by_name(attr->attr.name);
918 + if (reg_id < 0)
919 + return -EIO;
920 +
921 + dev_dbg(dev, "attempting to set %s(%d) to %lu mvolts\n",
922 + attr->attr.name, reg_id, mvolts);
923 +
924 + if (mvolts == 0) {
925 + pcf50606_onoff_set(pcf, reg_id, 0);
926 + } else {
927 + if (pcf50606_voltage_set(pcf, reg_id, mvolts) < 0) {
928 + dev_warn(dev, "refusing to set %s(%d) to %lu mvolts "
929 + "(max=%u)\n", attr->attr.name, reg_id, mvolts,
930 + pcf->pdata->rails[reg_id].voltage.max);
931 + return -EINVAL;
932 + }
933 + pcf50606_onoff_set(pcf, reg_id, 1);
934 + }
935 +
936 + return count;
937 +}
938 +
939 +static DEVICE_ATTR(voltage_dcd, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
940 +static DEVICE_ATTR(voltage_dcde, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
941 +static DEVICE_ATTR(voltage_dcud, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
942 +static DEVICE_ATTR(voltage_d1reg, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
943 +static DEVICE_ATTR(voltage_d2reg, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
944 +static DEVICE_ATTR(voltage_d3reg, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
945 +static DEVICE_ATTR(voltage_lpreg, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
946 +static DEVICE_ATTR(voltage_ioreg, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
947 +
948 +/***********************************************************************
949 + * Charger Control
950 + ***********************************************************************/
951 +
952 +/* Enable/disable fast charging (500mA in the GTA01) */
953 +void pcf50606_charge_fast(struct pcf50606_data *pcf, int on)
954 +{
955 + if (!(pcf->pdata->used_features & PCF50606_FEAT_MBC))
956 + return;
957 +
958 + if (on) {
959 + /* We can allow PCF to automatically charge
960 + * using Ifast */
961 + pcf->flags |= PCF50606_F_CHG_FAST;
962 + reg_set_bit_mask(pcf, PCF50606_REG_MBCC1,
963 + PCF50606_MBCC1_AUTOFST,
964 + PCF50606_MBCC1_AUTOFST);
965 + } else {
966 + pcf->flags &= ~PCF50606_F_CHG_FAST;
967 + /* disable automatic fast-charge */
968 + reg_clear_bits(pcf, PCF50606_REG_MBCC1,
969 + PCF50606_MBCC1_AUTOFST);
970 + /* switch to idle mode to abort existing charge
971 + * process */
972 + reg_set_bit_mask(pcf, PCF50606_REG_MBCC1,
973 + PCF50606_MBCC1_CHGMOD_MASK,
974 + PCF50606_MBCC1_CHGMOD_IDLE);
975 + }
976 +}
977 +EXPORT_SYMBOL_GPL(pcf50606_charge_fast);
978 +
979 +static inline u_int16_t adc_to_rntc(struct pcf50606_data *pcf, u_int16_t adc)
980 +{
981 + u_int32_t r_ntc = (adc * (u_int32_t)pcf->pdata->r_fix_batt) / (1023 - adc);
982 +
983 + return r_ntc;
984 +}
985 +
986 +static inline int16_t rntc_to_temp(u_int16_t rntc)
987 +{
988 + int i;
989 +
990 + for (i = 0; i < ARRAY_SIZE(ntc_table_10k_3370B); i++) {
991 + if (rntc > ntc_table_10k_3370B[i])
992 + return i - 10; /* First element is -10 */
993 + }
994 + return -99; /* Below our range */
995 +}
996 +
997 +static ssize_t show_battemp(struct device *dev, struct device_attribute *attr,
998 + char *buf)
999 +{
1000 + struct i2c_client *client = to_i2c_client(dev);
1001 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1002 + u_int16_t adc;
1003 +
1004 + adc = adc_read(pcf, PCF50606_ADCMUX_BATTEMP, NULL);
1005 +
1006 + return sprintf(buf, "%d\n", rntc_to_temp(adc_to_rntc(pcf, adc)));
1007 +}
1008 +static DEVICE_ATTR(battemp, S_IRUGO | S_IWUSR, show_battemp, NULL);
1009 +
1010 +static inline int16_t adc_to_chg_milliamps(struct pcf50606_data *pcf,
1011 + u_int16_t adc_adcin1,
1012 + u_int16_t adc_batvolt)
1013 +{
1014 + int32_t res = (adc_adcin1 - adc_batvolt) * 2400;
1015 + return (res * 1000) / (pcf->pdata->r_sense_milli * 1024);
1016 +}
1017 +
1018 +static ssize_t show_chgcur(struct device *dev, struct device_attribute *attr,
1019 + char *buf)
1020 +{
1021 + struct i2c_client *client = to_i2c_client(dev);
1022 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1023 + u_int16_t adc_batvolt, adc_adcin1;
1024 + int16_t ma;
1025 +
1026 + adc_batvolt = adc_read(pcf, PCF50606_ADCMUX_BATVOLT_ADCIN1,
1027 + &adc_adcin1);
1028 + ma = adc_to_chg_milliamps(pcf, adc_adcin1, adc_batvolt);
1029 +
1030 + return sprintf(buf, "%d\n", ma);
1031 +}
1032 +static DEVICE_ATTR(chgcur, S_IRUGO | S_IWUSR, show_chgcur, NULL);
1033 +
1034 +static const char *chgmode_names[] = {
1035 + [PCF50606_MBCC1_CHGMOD_QUAL] = "qualification",
1036 + [PCF50606_MBCC1_CHGMOD_PRE] = "pre",
1037 + [PCF50606_MBCC1_CHGMOD_TRICKLE] = "trickle",
1038 + [PCF50606_MBCC1_CHGMOD_FAST_CCCV] = "fast_cccv",
1039 + [PCF50606_MBCC1_CHGMOD_FAST_NOCC] = "fast_nocc",
1040 + [PCF50606_MBCC1_CHGMOD_FAST_NOCV] = "fast_nocv",
1041 + [PCF50606_MBCC1_CHGMOD_FAST_SW] = "fast_switch",
1042 + [PCF50606_MBCC1_CHGMOD_IDLE] = "idle",
1043 +};
1044 +
1045 +static ssize_t show_chgmode(struct device *dev, struct device_attribute *attr,
1046 + char *buf)
1047 +{
1048 + struct i2c_client *client = to_i2c_client(dev);
1049 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1050 + u_int8_t mbcc1 = reg_read(pcf, PCF50606_REG_MBCC1);
1051 + u_int8_t chgmod = (mbcc1 & PCF50606_MBCC1_CHGMOD_MASK);
1052 +
1053 + return sprintf(buf, "%s\n", chgmode_names[chgmod]);
1054 +}
1055 +
1056 +static ssize_t set_chgmode(struct device *dev, struct device_attribute *attr,
1057 + const char *buf, size_t count)
1058 +{
1059 + struct i2c_client *client = to_i2c_client(dev);
1060 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1061 + u_int8_t mbcc1 = reg_read(pcf, PCF50606_REG_MBCC1);
1062 +
1063 + mbcc1 &= ~PCF50606_MBCC1_CHGMOD_MASK;
1064 +
1065 + if (!strcmp(buf, "qualification"))
1066 + mbcc1 |= PCF50606_MBCC1_CHGMOD_QUAL;
1067 + else if (!strcmp(buf, "pre"))
1068 + mbcc1 |= PCF50606_MBCC1_CHGMOD_PRE;
1069 + else if (!strcmp(buf, "trickle"))
1070 + mbcc1 |= PCF50606_MBCC1_CHGMOD_TRICKLE;
1071 + else if (!strcmp(buf, "fast_cccv"))
1072 + mbcc1 |= PCF50606_MBCC1_CHGMOD_FAST_CCCV;
1073 + /* We don't allow the other fast modes for security reasons */
1074 + else if (!strcmp(buf, "idle"))
1075 + mbcc1 |= PCF50606_MBCC1_CHGMOD_IDLE;
1076 + else
1077 + return -EINVAL;
1078 +
1079 + reg_write(pcf, PCF50606_REG_MBCC1, mbcc1);
1080 +
1081 + return count;
1082 +}
1083 +
1084 +static DEVICE_ATTR(chgmode, S_IRUGO | S_IWUSR, show_chgmode, set_chgmode);
1085 +
1086 +static const char *chgstate_names[] = {
1087 + [PCF50606_F_CHG_FAST] = "fast_enabled",
1088 + [PCF50606_F_CHG_PRESENT] = "present",
1089 + [PCF50606_F_CHG_FOK] = "fast_ok",
1090 + [PCF50606_F_CHG_ERR] = "error",
1091 + [PCF50606_F_CHG_PROT] = "protection",
1092 + [PCF50606_F_CHG_READY] = "ready",
1093 +};
1094 +
1095 +static ssize_t show_chgstate(struct device *dev, struct device_attribute *attr,
1096 + char *buf)
1097 +{
1098 + struct i2c_client *client = to_i2c_client(dev);
1099 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1100 + char *b = buf;
1101 + int i;
1102 +
1103 + for (i = 0; i < 32; i++)
1104 + if (pcf->flags & (1 << i) && i < ARRAY_SIZE(chgstate_names))
1105 + b += sprintf(b, "%s ", chgstate_names[i]);
1106 +
1107 + if (b > buf)
1108 + b += sprintf(b, "\n");
1109 +
1110 + return b - buf;
1111 +}
1112 +static DEVICE_ATTR(chgstate, S_IRUGO | S_IWUSR, show_chgstate, NULL);
1113 +
1114 +/***********************************************************************
1115 + * APM emulation
1116 + ***********************************************************************/
1117 +
1118 +static void pcf50606_get_power_status(struct apm_power_info *info)
1119 +{
1120 + struct pcf50606_data *pcf = pcf50606_global;
1121 + u_int8_t mbcc1 = reg_read(pcf, PCF50606_REG_MBCC1);
1122 + u_int8_t chgmod = mbcc1 & PCF50606_MBCC1_CHGMOD_MASK;
1123 + u_int16_t battvolt = pcf50606_battvolt(pcf);
1124 +
1125 + if (reg_read(pcf, PCF50606_REG_OOCS) & PCF50606_OOCS_EXTON)
1126 + info->ac_line_status = APM_AC_ONLINE;
1127 + else
1128 + info->ac_line_status = APM_AC_OFFLINE;
1129 +
1130 + switch (chgmod) {
1131 + case PCF50606_MBCC1_CHGMOD_QUAL:
1132 + case PCF50606_MBCC1_CHGMOD_PRE:
1133 + case PCF50606_MBCC1_CHGMOD_IDLE:
1134 + info->battery_life = battvolt_scale(battvolt);
1135 + break;
1136 + default:
1137 + info->battery_status = APM_BATTERY_STATUS_CHARGING;
1138 + info->battery_flag = APM_BATTERY_FLAG_CHARGING;
1139 + break;
1140 + }
1141 +}
1142 +
1143 +/***********************************************************************
1144 + * RTC
1145 + ***********************************************************************/
1146 +
1147 +struct pcf50606_time {
1148 + u_int8_t sec;
1149 + u_int8_t min;
1150 + u_int8_t hour;
1151 + u_int8_t wkday;
1152 + u_int8_t day;
1153 + u_int8_t month;
1154 + u_int8_t year;
1155 +};
1156 +
1157 +static void pcf2rtc_time(struct rtc_time *rtc, struct pcf50606_time *pcf)
1158 +{
1159 + rtc->tm_sec = BCD2BIN(pcf->sec);
1160 + rtc->tm_min = BCD2BIN(pcf->min);
1161 + rtc->tm_hour = BCD2BIN(pcf->hour);
1162 + rtc->tm_wday = BCD2BIN(pcf->wkday);
1163 + rtc->tm_mday = BCD2BIN(pcf->day);
1164 + rtc->tm_mon = BCD2BIN(pcf->month);
1165 + rtc->tm_year = BCD2BIN(pcf->year) + 100;
1166 +}
1167 +
1168 +static void rtc2pcf_time(struct pcf50606_time *pcf, struct rtc_time *rtc)
1169 +{
1170 + pcf->sec = BIN2BCD(rtc->tm_sec);
1171 + pcf->min = BIN2BCD(rtc->tm_min);
1172 + pcf->hour = BIN2BCD(rtc->tm_hour);
1173 + pcf->wkday = BIN2BCD(rtc->tm_wday);
1174 + pcf->day = BIN2BCD(rtc->tm_mday);
1175 + pcf->month = BIN2BCD(rtc->tm_mon);
1176 + pcf->year = BIN2BCD(rtc->tm_year - 100);
1177 +}
1178 +
1179 +static int pcf50606_rtc_ioctl(struct device *dev, unsigned int cmd,
1180 + unsigned long arg)
1181 +{
1182 + struct i2c_client *client = to_i2c_client(dev);
1183 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1184 + switch (cmd) {
1185 + case RTC_PIE_OFF:
1186 + /* disable periodic interrupt (hz tick) */
1187 + pcf->flags &= ~PCF50606_F_RTC_SECOND;
1188 + reg_set_bit_mask(pcf, PCF50606_REG_INT1M,
1189 + PCF50606_INT1_SECOND, PCF50606_INT1_SECOND);
1190 + return 0;
1191 + case RTC_PIE_ON:
1192 + /* ensable periodic interrupt (hz tick) */
1193 + pcf->flags |= PCF50606_F_RTC_SECOND;
1194 + reg_clear_bits(pcf, PCF50606_REG_INT1M, PCF50606_INT1_SECOND);
1195 + return 0;
1196 + }
1197 + return -ENOIOCTLCMD;
1198 +}
1199 +
1200 +static int pcf50606_rtc_read_time(struct device *dev, struct rtc_time *tm)
1201 +{
1202 + struct i2c_client *client = to_i2c_client(dev);
1203 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1204 + struct pcf50606_time pcf_tm;
1205 +
1206 + mutex_lock(&pcf->lock);
1207 + pcf_tm.sec = __reg_read(pcf, PCF50606_REG_RTCSC);
1208 + pcf_tm.min = __reg_read(pcf, PCF50606_REG_RTCMN);
1209 + pcf_tm.hour = __reg_read(pcf, PCF50606_REG_RTCHR);
1210 + pcf_tm.wkday = __reg_read(pcf, PCF50606_REG_RTCWD);
1211 + pcf_tm.day = __reg_read(pcf, PCF50606_REG_RTCDT);
1212 + pcf_tm.month = __reg_read(pcf, PCF50606_REG_RTCMT);
1213 + pcf_tm.year = __reg_read(pcf, PCF50606_REG_RTCYR);
1214 + mutex_unlock(&pcf->lock);
1215 +
1216 + dev_dbg(dev, "PCF_TIME: %02x.%02x.%02x %02x:%02x:%02x\n",
1217 + pcf_tm.day, pcf_tm.month, pcf_tm.year,
1218 + pcf_tm.hour, pcf_tm.min, pcf_tm.sec);
1219 +
1220 + pcf2rtc_time(tm, &pcf_tm);
1221 +
1222 + dev_dbg(dev, "RTC_TIME: %u.%u.%u %u:%u:%u\n",
1223 + tm->tm_mday, tm->tm_mon, tm->tm_year,
1224 + tm->tm_hour, tm->tm_min, tm->tm_sec);
1225 +
1226 + return 0;
1227 +}
1228 +
1229 +static int pcf50606_rtc_set_time(struct device *dev, struct rtc_time *tm)
1230 +{
1231 + struct i2c_client *client = to_i2c_client(dev);
1232 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1233 + struct pcf50606_time pcf_tm;
1234 + u_int8_t int1m;
1235 +
1236 + dev_dbg(dev, "RTC_TIME: %u.%u.%u %u:%u:%u\n",
1237 + tm->tm_mday, tm->tm_mon, tm->tm_year,
1238 + tm->tm_hour, tm->tm_min, tm->tm_sec);
1239 + rtc2pcf_time(&pcf_tm, tm);
1240 + dev_dbg(dev, "PCF_TIME: %02x.%02x.%02x %02x:%02x:%02x\n",
1241 + pcf_tm.day, pcf_tm.month, pcf_tm.year,
1242 + pcf_tm.hour, pcf_tm.min, pcf_tm.sec);
1243 +
1244 + mutex_lock(&pcf->lock);
1245 +
1246 + /* disable SECOND interrupt */
1247 + int1m = __reg_read(pcf, PCF50606_REG_INT1M);
1248 + __reg_write(pcf, PCF50606_REG_INT1M, int1m | PCF50606_INT1_SECOND);
1249 +
1250 + __reg_write(pcf, PCF50606_REG_RTCSC, pcf_tm.sec);
1251 + __reg_write(pcf, PCF50606_REG_RTCMN, pcf_tm.min);
1252 + __reg_write(pcf, PCF50606_REG_RTCHR, pcf_tm.hour);
1253 + __reg_write(pcf, PCF50606_REG_RTCWD, pcf_tm.wkday);
1254 + __reg_write(pcf, PCF50606_REG_RTCDT, pcf_tm.day);
1255 + __reg_write(pcf, PCF50606_REG_RTCMT, pcf_tm.month);
1256 + __reg_write(pcf, PCF50606_REG_RTCYR, pcf_tm.year);
1257 +
1258 + /* restore INT1M, potentially re-enable SECOND interrupt */
1259 + __reg_write(pcf, PCF50606_REG_INT1M, int1m);
1260 +
1261 + mutex_unlock(&pcf->lock);
1262 +
1263 + return 0;
1264 +}
1265 +
1266 +static int pcf50606_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
1267 +{
1268 + struct i2c_client *client = to_i2c_client(dev);
1269 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1270 + struct pcf50606_time pcf_tm;
1271 +
1272 + mutex_lock(&pcf->lock);
1273 + alrm->enabled =
1274 + __reg_read(pcf, PCF50606_REG_INT1M) & PCF50606_INT1_ALARM ? 0 : 1;
1275 + pcf_tm.sec = __reg_read(pcf, PCF50606_REG_RTCSCA);
1276 + pcf_tm.min = __reg_read(pcf, PCF50606_REG_RTCMNA);
1277 + pcf_tm.hour = __reg_read(pcf, PCF50606_REG_RTCHRA);
1278 + pcf_tm.wkday = __reg_read(pcf, PCF50606_REG_RTCWDA);
1279 + pcf_tm.day = __reg_read(pcf, PCF50606_REG_RTCDTA);
1280 + pcf_tm.month = __reg_read(pcf, PCF50606_REG_RTCMTA);
1281 + pcf_tm.year = __reg_read(pcf, PCF50606_REG_RTCYRA);
1282 + mutex_unlock(&pcf->lock);
1283 +
1284 + pcf2rtc_time(&alrm->time, &pcf_tm);
1285 +
1286 + return 0;
1287 +}
1288 +
1289 +static int pcf50606_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
1290 +{
1291 + struct i2c_client *client = to_i2c_client(dev);
1292 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1293 + struct pcf50606_time pcf_tm;
1294 + u_int8_t irqmask;
1295 +
1296 + rtc2pcf_time(&pcf_tm, &alrm->time);
1297 +
1298 + mutex_lock(&pcf->lock);
1299 +
1300 + /* disable alarm interrupt */
1301 + irqmask = __reg_read(pcf, PCF50606_REG_INT1M);
1302 + irqmask |= PCF50606_INT1_ALARM;
1303 + __reg_write(pcf, PCF50606_REG_INT1M, irqmask);
1304 +
1305 + __reg_write(pcf, PCF50606_REG_RTCSCA, pcf_tm.sec);
1306 + __reg_write(pcf, PCF50606_REG_RTCMNA, pcf_tm.min);
1307 + __reg_write(pcf, PCF50606_REG_RTCHRA, pcf_tm.hour);
1308 + __reg_write(pcf, PCF50606_REG_RTCWDA, pcf_tm.wkday);
1309 + __reg_write(pcf, PCF50606_REG_RTCDTA, pcf_tm.day);
1310 + __reg_write(pcf, PCF50606_REG_RTCMTA, pcf_tm.month);
1311 + __reg_write(pcf, PCF50606_REG_RTCYRA, pcf_tm.year);
1312 +
1313 + if (alrm->enabled) {
1314 + /* (re-)enaable alarm interrupt */
1315 + irqmask = __reg_read(pcf, PCF50606_REG_INT1M);
1316 + irqmask &= ~PCF50606_INT1_ALARM;
1317 + __reg_write(pcf, PCF50606_REG_INT1M, irqmask);
1318 + }
1319 +
1320 + mutex_unlock(&pcf->lock);
1321 +
1322 + /* FIXME */
1323 + return 0;
1324 +}
1325 +
1326 +static struct rtc_class_ops pcf50606_rtc_ops = {
1327 + .ioctl = pcf50606_rtc_ioctl,
1328 + .read_time = pcf50606_rtc_read_time,
1329 + .set_time = pcf50606_rtc_set_time,
1330 + .read_alarm = pcf50606_rtc_read_alarm,
1331 + .set_alarm = pcf50606_rtc_set_alarm,
1332 +};
1333 +
1334 +/***********************************************************************
1335 + * Watchdog
1336 + ***********************************************************************/
1337 +
1338 +static void pcf50606_wdt_start(struct pcf50606_data *pcf)
1339 +{
1340 + reg_set_bit_mask(pcf, PCF50606_REG_OOCC1, PCF50606_OOCC1_WDTRST,
1341 + PCF50606_OOCC1_WDTRST);
1342 +}
1343 +
1344 +static void pcf50606_wdt_stop(struct pcf50606_data *pcf)
1345 +{
1346 + reg_clear_bits(pcf, PCF50606_REG_OOCS, PCF50606_OOCS_WDTEXP);
1347 +}
1348 +
1349 +static void pcf50606_wdt_keepalive(struct pcf50606_data *pcf)
1350 +{
1351 + pcf50606_wdt_start(pcf);
1352 +}
1353 +
1354 +static int pcf50606_wdt_open(struct inode *inode, struct file *file)
1355 +{
1356 + struct pcf50606_data *pcf = pcf50606_global;
1357 +
1358 + file->private_data = pcf;
1359 +
1360 + /* start the timer */
1361 + pcf50606_wdt_start(pcf);
1362 +
1363 + return nonseekable_open(inode, file);
1364 +}
1365 +
1366 +static int pcf50606_wdt_release(struct inode *inode, struct file *file)
1367 +{
1368 + struct pcf50606_data *pcf = file->private_data;
1369 +
1370 + if (pcf->allow_close == CLOSE_STATE_ALLOW)
1371 + pcf50606_wdt_stop(pcf);
1372 + else {
1373 + printk(KERN_CRIT "Unexpected close, not stopping watchdog!\n");
1374 + pcf50606_wdt_keepalive(pcf);
1375 + }
1376 +
1377 + pcf->allow_close = CLOSE_STATE_NOT;
1378 +
1379 + return 0;
1380 +}
1381 +
1382 +static ssize_t pcf50606_wdt_write(struct file *file, const char __user *data,
1383 + size_t len, loff_t *ppos)
1384 +{
1385 + struct pcf50606_data *pcf = file->private_data;
1386 + if (len) {
1387 + size_t i;
1388 +
1389 + for (i = 0; i != len; i++) {
1390 + char c;
1391 + if (get_user(c, data + i))
1392 + return -EFAULT;
1393 + if (c == 'V')
1394 + pcf->allow_close = CLOSE_STATE_ALLOW;
1395 + }
1396 + pcf50606_wdt_keepalive(pcf);
1397 + }
1398 +
1399 + return len;
1400 +}
1401 +
1402 +static struct watchdog_info pcf50606_wdt_ident = {
1403 + .options = WDIOF_MAGICCLOSE,
1404 + .firmware_version = 0,
1405 + .identity = "PCF50606 Watchdog",
1406 +};
1407 +
1408 +static int pcf50606_wdt_ioctl(struct inode *inode, struct file *file,
1409 + unsigned int cmd, unsigned long arg)
1410 +{
1411 + struct pcf50606_data *pcf = file->private_data;
1412 + void __user *argp = (void __user *)arg;
1413 + int __user *p = argp;
1414 +
1415 + switch (cmd) {
1416 + case WDIOC_GETSUPPORT:
1417 + return copy_to_user(argp, &pcf50606_wdt_ident,
1418 + sizeof(pcf50606_wdt_ident)) ? -EFAULT : 0;
1419 + break;
1420 + case WDIOC_GETSTATUS:
1421 + case WDIOC_GETBOOTSTATUS:
1422 + return put_user(0, p);
1423 + case WDIOC_KEEPALIVE:
1424 + pcf50606_wdt_keepalive(pcf);
1425 + return 0;
1426 + case WDIOC_GETTIMEOUT:
1427 + return put_user(8, p);
1428 + default:
1429 + return -ENOIOCTLCMD;
1430 + }
1431 +}
1432 +
1433 +static struct file_operations pcf50606_wdt_fops = {
1434 + .owner = THIS_MODULE,
1435 + .llseek = no_llseek,
1436 + .write = &pcf50606_wdt_write,
1437 + .ioctl = &pcf50606_wdt_ioctl,
1438 + .open = &pcf50606_wdt_open,
1439 + .release = &pcf50606_wdt_release,
1440 +};
1441 +
1442 +static struct miscdevice pcf50606_wdt_miscdev = {
1443 + .minor = WATCHDOG_MINOR,
1444 + .name = "watchdog",
1445 + .fops = &pcf50606_wdt_fops,
1446 +};
1447 +
1448 +/***********************************************************************
1449 + * PWM
1450 + ***********************************************************************/
1451 +
1452 +static const char *pwm_dc_table[] = {
1453 + "0/16", "1/16", "2/16", "3/16",
1454 + "4/16", "5/16", "6/16", "7/16",
1455 + "8/16", "9/16", "10/16", "11/16",
1456 + "12/16", "13/16", "14/16", "15/16",
1457 +};
1458 +
1459 +static ssize_t show_pwm_dc(struct device *dev, struct device_attribute *attr,
1460 + char *buf)
1461 +{
1462 + struct i2c_client *client = to_i2c_client(dev);
1463 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1464 + u_int8_t val;
1465 +
1466 + val = reg_read(pcf, PCF50606_REG_PWMC1) >> PCF50606_PWMC1_DC_SHIFT;
1467 + val &= 0xf;
1468 +
1469 + return sprintf(buf, "%s\n", pwm_dc_table[val]);
1470 +}
1471 +
1472 +static ssize_t set_pwm_dc(struct device *dev, struct device_attribute *attr,
1473 + const char *buf, size_t count)
1474 +{
1475 + struct i2c_client *client = to_i2c_client(dev);
1476 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1477 + u_int8_t i;
1478 +
1479 + for (i = 0; i < ARRAY_SIZE(pwm_dc_table); i++) {
1480 + if (!strncmp(buf, pwm_dc_table[i], strlen(pwm_dc_table[i]))) {
1481 + dev_dbg(dev, "setting pwm dc %s\n\r", pwm_dc_table[i]);
1482 + reg_set_bit_mask(pcf, PCF50606_REG_PWMC1, 0x1e,
1483 + (i << PCF50606_PWMC1_DC_SHIFT));
1484 + }
1485 + }
1486 + return count;
1487 +}
1488 +
1489 +static DEVICE_ATTR(pwm_dc, S_IRUGO | S_IWUSR, show_pwm_dc, set_pwm_dc);
1490 +
1491 +static const char *pwm_clk_table[] = {
1492 + "512", "256", "128", "64",
1493 + "56300", "28100", "14100", "7000",
1494 +};
1495 +
1496 +static ssize_t show_pwm_clk(struct device *dev, struct device_attribute *attr,
1497 + char *buf)
1498 +{
1499 + struct i2c_client *client = to_i2c_client(dev);
1500 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1501 + u_int8_t val;
1502 +
1503 + val = reg_read(pcf, PCF50606_REG_PWMC1) >> PCF50606_PWMC1_CLK_SHIFT;
1504 + val &= 0x7;
1505 +
1506 + return sprintf(buf, "%s\n", pwm_clk_table[val]);
1507 +}
1508 +
1509 +static ssize_t set_pwm_clk(struct device *dev, struct device_attribute *attr,
1510 + const char *buf, size_t count)
1511 +{
1512 + struct i2c_client *client = to_i2c_client(dev);
1513 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1514 + u_int8_t i;
1515 +
1516 + for (i = 0; i < ARRAY_SIZE(pwm_clk_table); i++) {
1517 + if (!strncmp(buf, pwm_clk_table[i], strlen(pwm_clk_table[i]))) {
1518 + dev_dbg(dev, "setting pwm clk %s\n\r",
1519 + pwm_clk_table[i]);
1520 + reg_set_bit_mask(pcf, PCF50606_REG_PWMC1, 0xe0,
1521 + (i << PCF50606_PWMC1_CLK_SHIFT));
1522 + }
1523 + }
1524 + return count;
1525 +}
1526 +
1527 +static DEVICE_ATTR(pwm_clk, S_IRUGO | S_IWUSR, show_pwm_clk, set_pwm_clk);
1528 +
1529 +static int pcf50606bl_get_intensity(struct backlight_device *bd)
1530 +{
1531 + struct pcf50606_data *pcf = bl_get_data(bd);
1532 + int intensity = reg_read(pcf, PCF50606_REG_PWMC1);
1533 + intensity = (intensity >> PCF50606_PWMC1_DC_SHIFT);
1534 +
1535 + return intensity & 0xf;
1536 +}
1537 +
1538 +static int pcf50606bl_set_intensity(struct backlight_device *bd)
1539 +{
1540 + struct pcf50606_data *pcf = bl_get_data(bd);
1541 + int intensity = bd->props.brightness;
1542 +
1543 + if (bd->props.power != FB_BLANK_UNBLANK)
1544 + intensity = 0;
1545 + if (bd->props.fb_blank != FB_BLANK_UNBLANK)
1546 + intensity = 0;
1547 +
1548 + return reg_set_bit_mask(pcf, PCF50606_REG_PWMC1, 0x1e,
1549 + (intensity << PCF50606_PWMC1_DC_SHIFT));
1550 +}
1551 +
1552 +static struct backlight_ops pcf50606bl_ops = {
1553 + .get_brightness = pcf50606bl_get_intensity,
1554 + .update_status = pcf50606bl_set_intensity,
1555 +};
1556 +
1557 +/***********************************************************************
1558 + * Driver initialization
1559 + ***********************************************************************/
1560 +
1561 +#ifdef CONFIG_MACH_NEO1973_GTA01
1562 +/* We currently place those platform devices here to make sure the device
1563 + * suspend/resume order is correct */
1564 +static struct platform_device gta01_pm_gps_dev = {
1565 + .name = "neo1973-pm-gps",
1566 +};
1567 +
1568 +static struct platform_device gta01_pm_bt_dev = {
1569 + .name = "neo1973-pm-bt",
1570 +};
1571 +#endif
1572 +
1573 +static struct attribute *pcf_sysfs_entries[16] = {
1574 + &dev_attr_voltage_dcd.attr,
1575 + &dev_attr_voltage_dcde.attr,
1576 + &dev_attr_voltage_dcud.attr,
1577 + &dev_attr_voltage_d1reg.attr,
1578 + &dev_attr_voltage_d2reg.attr,
1579 + &dev_attr_voltage_d3reg.attr,
1580 + &dev_attr_voltage_lpreg.attr,
1581 + &dev_attr_voltage_ioreg.attr,
1582 + NULL
1583 +};
1584 +
1585 +static struct attribute_group pcf_attr_group = {
1586 + .name = NULL, /* put in device directory */
1587 + .attrs = pcf_sysfs_entries,
1588 +};
1589 +
1590 +static void populate_sysfs_group(struct pcf50606_data *pcf)
1591 +{
1592 + int i = 0;
1593 + struct attribute **attr;
1594 +
1595 + for (attr = pcf_sysfs_entries; *attr; attr++)
1596 + i++;
1597 +
1598 + if (pcf->pdata->used_features & PCF50606_FEAT_MBC) {
1599 + pcf_sysfs_entries[i++] = &dev_attr_chgstate.attr;
1600 + pcf_sysfs_entries[i++] = &dev_attr_chgmode.attr;
1601 + }
1602 +
1603 + if (pcf->pdata->used_features & PCF50606_FEAT_CHGCUR)
1604 + pcf_sysfs_entries[i++] = &dev_attr_chgcur.attr;
1605 +
1606 + if (pcf->pdata->used_features & PCF50606_FEAT_BATVOLT)
1607 + pcf_sysfs_entries[i++] = &dev_attr_battvolt.attr;
1608 +
1609 + if (pcf->pdata->used_features & PCF50606_FEAT_BATTEMP)
1610 + pcf_sysfs_entries[i++] = &dev_attr_battemp.attr;
1611 +
1612 + if (pcf->pdata->used_features & PCF50606_FEAT_PWM) {
1613 + pcf_sysfs_entries[i++] = &dev_attr_pwm_dc.attr;
1614 + pcf_sysfs_entries[i++] = &dev_attr_pwm_clk.attr;
1615 + }
1616 +}
1617 +
1618 +static int pcf50606_detect(struct i2c_adapter *adapter, int address, int kind)
1619 +{
1620 + struct i2c_client *new_client;
1621 + struct pcf50606_data *data;
1622 + int err = 0;
1623 + int irq;
1624 +
1625 + if (!pcf50606_pdev) {
1626 + printk(KERN_ERR "pcf50606: driver needs a platform_device!\n");
1627 + return -EIO;
1628 + }
1629 +
1630 + irq = platform_get_irq(pcf50606_pdev, 0);
1631 + if (irq < 0) {
1632 + dev_err(&pcf50606_pdev->dev, "no irq in platform resources!\n");
1633 + return -EIO;
1634 + }
1635 +
1636 + /* At the moment, we only support one PCF50606 in a system */
1637 + if (pcf50606_global) {
1638 + dev_err(&pcf50606_pdev->dev,
1639 + "currently only one chip supported\n");
1640 + return -EBUSY;
1641 + }
1642 +
1643 + data = kzalloc(sizeof(*data), GFP_KERNEL);
1644 + if (!data)
1645 + return -ENOMEM;
1646 +
1647 + mutex_init(&data->lock);
1648 + mutex_init(&data->working_lock);
1649 + INIT_WORK(&data->work, pcf50606_work);
1650 + data->irq = irq;
1651 + data->working = 0;
1652 + data->onkey_seconds = -1;
1653 + data->pdata = pcf50606_pdev->dev.platform_data;
1654 +
1655 + new_client = &data->client;
1656 + i2c_set_clientdata(new_client, data);
1657 + new_client->addr = address;
1658 + new_client->adapter = adapter;
1659 + new_client->driver = &pcf50606_driver;
1660 + new_client->flags = 0;
1661 + strlcpy(new_client->name, "pcf50606", I2C_NAME_SIZE);
1662 +
1663 + /* now we try to detect the chip */
1664 +
1665 + /* register with i2c core */
1666 + err = i2c_attach_client(new_client);
1667 + if (err) {
1668 + dev_err(&new_client->dev,
1669 + "error during i2c_attach_client()\n");
1670 + goto exit_free;
1671 + }
1672 +
1673 + populate_sysfs_group(data);
1674 +
1675 + err = sysfs_create_group(&new_client->dev.kobj, &pcf_attr_group);
1676 + if (err) {
1677 + dev_err(&new_client->dev, "error creating sysfs group\n");
1678 + goto exit_detach;
1679 + }
1680 +
1681 + /* create virtual charger 'device' */
1682 +
1683 + /* input device registration */
1684 + data->input_dev = input_allocate_device();
1685 + if (!data->input_dev)
1686 + goto exit_sysfs;
1687 +
1688 + data->input_dev->name = "FIC Neo1973 PMU events";
1689 + data->input_dev->phys = "I2C";
1690 + data->input_dev->id.bustype = BUS_I2C;
1691 + data->input_dev->cdev.dev = &new_client->dev;
1692 +
1693 + data->input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_PWR);
1694 + set_bit(KEY_POWER, data->input_dev->keybit);
1695 + set_bit(KEY_POWER2, data->input_dev->keybit);
1696 + set_bit(KEY_BATTERY, data->input_dev->keybit);
1697 +
1698 + err = input_register_device(data->input_dev);
1699 + if (err)
1700 + goto exit_sysfs;
1701 +
1702 + /* register power off handler with core power management */
1703 + pm_power_off = &pcf50606_go_standby;
1704 +
1705 + /* configure interrupt mask */
1706 + reg_write(data, PCF50606_REG_INT1M, PCF50606_INT1_SECOND);
1707 + reg_write(data, PCF50606_REG_INT2M, 0x00);
1708 + reg_write(data, PCF50606_REG_INT3M, PCF50606_INT3_TSCPRES);
1709 +
1710 + err = request_irq(irq, pcf50606_irq, IRQF_TRIGGER_FALLING,
1711 + "pcf50606", data);
1712 + if (err < 0)
1713 + goto exit_input;
1714 +
1715 + if (enable_irq_wake(irq) < 0)
1716 + dev_err(&new_client->dev, "IRQ %u cannot be enabled as wake-up"
1717 + "source in this hardware revision!", irq);
1718 +
1719 + pcf50606_global = data;
1720 +
1721 + if (data->pdata->used_features & PCF50606_FEAT_RTC) {
1722 + data->rtc = rtc_device_register("pcf50606", &new_client->dev,
1723 + &pcf50606_rtc_ops, THIS_MODULE);
1724 + if (IS_ERR(data->rtc)) {
1725 + err = PTR_ERR(data->rtc);
1726 + goto exit_irq;
1727 + }
1728 + }
1729 +
1730 + if (data->pdata->used_features & PCF50606_FEAT_WDT) {
1731 + err = misc_register(&pcf50606_wdt_miscdev);
1732 + if (err) {
1733 + dev_err(&new_client->dev, "cannot register miscdev on "
1734 + "minor=%d (%d)\n", WATCHDOG_MINOR, err);
1735 + goto exit_rtc;
1736 + }
1737 + }
1738 +
1739 + if (data->pdata->used_features & PCF50606_FEAT_PWM) {
1740 + /* enable PWM controller */
1741 + reg_set_bit_mask(data, PCF50606_REG_PWMC1,
1742 + PCF50606_PWMC1_ACTSET,
1743 + PCF50606_PWMC1_ACTSET);
1744 + }
1745 +
1746 + if (data->pdata->used_features & PCF50606_FEAT_PWM_BL) {
1747 + data->backlight = backlight_device_register("pcf50606-bl",
1748 + &new_client->dev,
1749 + data,
1750 + &pcf50606bl_ops);
1751 + if (!data->backlight)
1752 + goto exit_misc;
1753 + data->backlight->props.max_brightness = 16;
1754 + data->backlight->props.power = FB_BLANK_UNBLANK;
1755 + data->backlight->props.brightness =
1756 + data->pdata->init_brightness;
1757 + backlight_update_status(data->backlight);
1758 + }
1759 +
1760 + apm_get_power_status = pcf50606_get_power_status;
1761 +
1762 +#ifdef CONFIG_MACH_NEO1973_GTA01
1763 + if (machine_is_neo1973_gta01()) {
1764 + gta01_pm_gps_dev.dev.parent = &new_client->dev;
1765 + switch (system_rev) {
1766 + case GTA01Bv2_SYSTEM_REV:
1767 + case GTA01Bv3_SYSTEM_REV:
1768 + case GTA01Bv4_SYSTEM_REV:
1769 + gta01_pm_bt_dev.dev.parent = &new_client->dev;
1770 + platform_device_register(&gta01_pm_bt_dev);
1771 + break;
1772 + }
1773 + platform_device_register(&gta01_pm_gps_dev);
1774 + /* a link for gllin compatibility */
1775 + err = sysfs_create_link(&platform_bus_type.devices.kobj,
1776 + &gta01_pm_gps_dev.dev.kobj, "gta01-pm-gps.0");
1777 + if (err)
1778 + printk(KERN_ERR
1779 + "sysfs_create_link (gta01-pm-gps.0): %d\n", err);
1780 + }
1781 +#endif
1782 +
1783 + if (data->pdata->used_features & PCF50606_FEAT_ACD)
1784 + reg_set_bit_mask(data, PCF50606_REG_ACDC1,
1785 + PCF50606_ACDC1_ACDAPE, PCF50606_ACDC1_ACDAPE);
1786 + else
1787 + reg_clear_bits(data, PCF50606_REG_ACDC1,
1788 + PCF50606_ACDC1_ACDAPE);
1789 +
1790 + return 0;
1791 +
1792 +exit_misc:
1793 + if (data->pdata->used_features & PCF50606_FEAT_WDT)
1794 + misc_deregister(&pcf50606_wdt_miscdev);
1795 +exit_rtc:
1796 + if (data->pdata->used_features & PCF50606_FEAT_RTC)
1797 + rtc_device_unregister(pcf50606_global->rtc);
1798 +exit_irq:
1799 + free_irq(pcf50606_global->irq, pcf50606_global);
1800 + pcf50606_global = NULL;
1801 +exit_input:
1802 + pm_power_off = NULL;
1803 + input_unregister_device(data->input_dev);
1804 +exit_sysfs:
1805 + sysfs_remove_group(&new_client->dev.kobj, &pcf_attr_group);
1806 +exit_detach:
1807 + i2c_detach_client(new_client);
1808 +exit_free:
1809 + kfree(data);
1810 + return err;
1811 +}
1812 +
1813 +static int pcf50606_attach_adapter(struct i2c_adapter *adapter)
1814 +{
1815 + return i2c_probe(adapter, &addr_data, &pcf50606_detect);
1816 +}
1817 +
1818 +static int pcf50606_detach_client(struct i2c_client *client)
1819 +{
1820 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1821 +
1822 + apm_get_power_status = NULL;
1823 + input_unregister_device(pcf->input_dev);
1824 +
1825 + if (pcf->pdata->used_features & PCF50606_FEAT_PWM_BL)
1826 + backlight_device_unregister(pcf->backlight);
1827 +
1828 + if (pcf->pdata->used_features & PCF50606_FEAT_WDT)
1829 + misc_deregister(&pcf50606_wdt_miscdev);
1830 +
1831 + if (pcf->pdata->used_features & PCF50606_FEAT_RTC)
1832 + rtc_device_unregister(pcf->rtc);
1833 +
1834 + free_irq(pcf->irq, pcf);
1835 +
1836 + sysfs_remove_group(&client->dev.kobj, &pcf_attr_group);
1837 +
1838 + pm_power_off = NULL;
1839 +
1840 + kfree(pcf);
1841 +
1842 + return 0;
1843 +}
1844 +
1845 +#ifdef CONFIG_PM
1846 +#define INT1M_RESUMERS (PCF50606_INT1_ALARM | \
1847 + PCF50606_INT1_ONKEYF | \
1848 + PCF50606_INT1_EXTONR)
1849 +#define INT2M_RESUMERS (PCF50606_INT2_CHGWD10S | \
1850 + PCF50606_INT2_CHGPROT | \
1851 + PCF50606_INT2_CHGERR)
1852 +#define INT3M_RESUMERS (PCF50606_INT3_LOWBAT | \
1853 + PCF50606_INT3_HIGHTMP | \
1854 + PCF50606_INT3_ACDINS)
1855 +static int pcf50606_suspend(struct device *dev, pm_message_t state)
1856 +{
1857 + struct i2c_client *client = to_i2c_client(dev);
1858 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1859 + int i;
1860 +
1861 + /* The general idea is to power down all unused power supplies,
1862 + * and then mask all PCF50606 interrup sources but EXTONR, ONKEYF
1863 + * and ALARM */
1864 +
1865 + mutex_lock(&pcf->lock);
1866 +
1867 + /* Save all registers that don't "survive" standby state */
1868 + pcf->standby_regs.dcdc1 = __reg_read(pcf, PCF50606_REG_DCDC1);
1869 + pcf->standby_regs.dcdc2 = __reg_read(pcf, PCF50606_REG_DCDC2);
1870 + pcf->standby_regs.dcdec1 = __reg_read(pcf, PCF50606_REG_DCDEC1);
1871 + pcf->standby_regs.dcudc1 = __reg_read(pcf, PCF50606_REG_DCUDC1);
1872 + pcf->standby_regs.ioregc = __reg_read(pcf, PCF50606_REG_IOREGC);
1873 + pcf->standby_regs.d1regc1 = __reg_read(pcf, PCF50606_REG_D1REGC1);
1874 + pcf->standby_regs.d2regc1 = __reg_read(pcf, PCF50606_REG_D2REGC1);
1875 + pcf->standby_regs.d3regc1 = __reg_read(pcf, PCF50606_REG_D3REGC1);
1876 + pcf->standby_regs.lpregc1 = __reg_read(pcf, PCF50606_REG_LPREGC1);
1877 + pcf->standby_regs.adcc1 = __reg_read(pcf, PCF50606_REG_ADCC1);
1878 + pcf->standby_regs.adcc2 = __reg_read(pcf, PCF50606_REG_ADCC2);
1879 + pcf->standby_regs.pwmc1 = __reg_read(pcf, PCF50606_REG_PWMC1);
1880 +
1881 + /* switch off power supplies that are not needed during suspend */
1882 + for (i = 0; i < __NUM_PCF50606_REGULATORS; i++) {
1883 + if (!(pcf->pdata->rails[i].flags & PMU_VRAIL_F_SUSPEND_ON)) {
1884 + u_int8_t tmp;
1885 +
1886 + /* IOREG powers the I@C interface so we cannot switch
1887 + * it off */
1888 + if (i == PCF50606_REGULATOR_IOREG)
1889 + continue;
1890 +
1891 + dev_dbg(dev, "disabling pcf50606 regulator %u\n", i);
1892 + /* we cannot use pcf50606_onoff_set() because we're
1893 + * already under the mutex */
1894 + tmp = __reg_read(pcf, regulator_registers[i]);
1895 + tmp &= 0x1f;
1896 + __reg_write(pcf, regulator_registers[i], tmp);
1897 + }
1898 + }
1899 +
1900 + pcf->standby_regs.int1m = __reg_read(pcf, PCF50606_REG_INT1M);
1901 + pcf->standby_regs.int2m = __reg_read(pcf, PCF50606_REG_INT2M);
1902 + pcf->standby_regs.int3m = __reg_read(pcf, PCF50606_REG_INT3M);
1903 + __reg_write(pcf, PCF50606_REG_INT1M, ~INT1M_RESUMERS & 0xff);
1904 + __reg_write(pcf, PCF50606_REG_INT2M, ~INT2M_RESUMERS & 0xff);
1905 + __reg_write(pcf, PCF50606_REG_INT3M, ~INT3M_RESUMERS & 0xff);
1906 +
1907 + mutex_unlock(&pcf->lock);
1908 +
1909 + return 0;
1910 +}
1911 +
1912 +static int pcf50606_resume(struct device *dev)
1913 +{
1914 + struct i2c_client *client = to_i2c_client(dev);
1915 + struct pcf50606_data *pcf = i2c_get_clientdata(client);
1916 +
1917 + mutex_lock(&pcf->lock);
1918 +
1919 + /* Resume all saved registers that don't "survive" standby state */
1920 + __reg_write(pcf, PCF50606_REG_INT1M, pcf->standby_regs.int1m);
1921 + __reg_write(pcf, PCF50606_REG_INT2M, pcf->standby_regs.int2m);
1922 + __reg_write(pcf, PCF50606_REG_INT3M, pcf->standby_regs.int3m);
1923 +
1924 + __reg_write(pcf, PCF50606_REG_DCDC1, pcf->standby_regs.dcdc1);
1925 + __reg_write(pcf, PCF50606_REG_DCDC2, pcf->standby_regs.dcdc2);
1926 + __reg_write(pcf, PCF50606_REG_DCDEC1, pcf->standby_regs.dcdec1);
1927 + __reg_write(pcf, PCF50606_REG_DCUDC1, pcf->standby_regs.dcudc1);
1928 + __reg_write(pcf, PCF50606_REG_IOREGC, pcf->standby_regs.ioregc);
1929 + __reg_write(pcf, PCF50606_REG_D1REGC1, pcf->standby_regs.d1regc1);
1930 + __reg_write(pcf, PCF50606_REG_D2REGC1, pcf->standby_regs.d2regc1);
1931 + __reg_write(pcf, PCF50606_REG_D3REGC1, pcf->standby_regs.d3regc1);
1932 + __reg_write(pcf, PCF50606_REG_LPREGC1, pcf->standby_regs.lpregc1);
1933 + __reg_write(pcf, PCF50606_REG_ADCC1, pcf->standby_regs.adcc1);
1934 + __reg_write(pcf, PCF50606_REG_ADCC2, pcf->standby_regs.adcc2);
1935 + __reg_write(pcf, PCF50606_REG_PWMC1, pcf->standby_regs.pwmc1);
1936 +
1937 + mutex_unlock(&pcf->lock);
1938 +
1939 + return 0;
1940 +}
1941 +#else
1942 +#define pcf50606_suspend NULL
1943 +#define pcf50606_resume NULL
1944 +#endif
1945 +
1946 +static struct i2c_driver pcf50606_driver = {
1947 + .driver = {
1948 + .name = "pcf50606",
1949 + .suspend = pcf50606_suspend,
1950 + .resume = pcf50606_resume,
1951 + },
1952 + .id = I2C_DRIVERID_PCF50606,
1953 + .attach_adapter = pcf50606_attach_adapter,
1954 + .detach_client = pcf50606_detach_client,
1955 +};
1956 +
1957 +/* platform driver, since i2c devices don't have platform_data */
1958 +static int __init pcf50606_plat_probe(struct platform_device *pdev)
1959 +{
1960 + struct pcf50606_platform_data *pdata = pdev->dev.platform_data;
1961 +
1962 + if (!pdata)
1963 + return -ENODEV;
1964 +
1965 + pcf50606_pdev = pdev;
1966 +
1967 + return 0;
1968 +}
1969 +
1970 +static int pcf50606_plat_remove(struct platform_device *pdev)
1971 +{
1972 + return 0;
1973 +}
1974 +
1975 +static struct platform_driver pcf50606_plat_driver = {
1976 + .probe = pcf50606_plat_probe,
1977 + .remove = pcf50606_plat_remove,
1978 + .driver = {
1979 + .owner = THIS_MODULE,
1980 + .name = "pcf50606",
1981 + },
1982 +};
1983 +
1984 +static int __init pcf50606_init(void)
1985 +{
1986 + int rc;
1987 +
1988 + rc = platform_driver_register(&pcf50606_plat_driver);
1989 + if (!rc)
1990 + rc = i2c_add_driver(&pcf50606_driver);
1991 +
1992 + return rc;
1993 +}
1994 +
1995 +static void pcf50606_exit(void)
1996 +{
1997 + i2c_del_driver(&pcf50606_driver);
1998 + platform_driver_unregister(&pcf50606_plat_driver);
1999 +}
2000 +
2001 +MODULE_DESCRIPTION("I2C chip driver for NXP PCF50606 power management unit");
2002 +MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");
2003 +MODULE_LICENSE("GPL");
2004 +
2005 +module_init(pcf50606_init);
2006 +module_exit(pcf50606_exit);
2007 diff --git a/drivers/i2c/chips/pcf50606.h b/drivers/i2c/chips/pcf50606.h
2008 new file mode 100644
2009 index 0000000..15b350f
2010 --- /dev/null
2011 +++ b/drivers/i2c/chips/pcf50606.h
2012 @@ -0,0 +1,302 @@
2013 +#ifndef _PCF50606_H
2014 +#define _PCF50606_H
2015 +
2016 +/* Philips PCF50606 Power Managemnt Unit (PMU) driver
2017 + * (C) 2006-2007 by OpenMoko, Inc.
2018 + * Author: Harald Welte <laforge@openmoko.org>
2019 + *
2020 + */
2021 +
2022 +enum pfc50606_regs {
2023 + PCF50606_REG_ID = 0x00,
2024 + PCF50606_REG_OOCS = 0x01,
2025 + PCF50606_REG_INT1 = 0x02, /* Interrupt Status */
2026 + PCF50606_REG_INT2 = 0x03, /* Interrupt Status */
2027 + PCF50606_REG_INT3 = 0x04, /* Interrupt Status */
2028 + PCF50606_REG_INT1M = 0x05, /* Interrupt Mask */
2029 + PCF50606_REG_INT2M = 0x06, /* Interrupt Mask */
2030 + PCF50606_REG_INT3M = 0x07, /* Interrupt Mask */
2031 + PCF50606_REG_OOCC1 = 0x08,
2032 + PCF50606_REG_OOCC2 = 0x09,
2033 + PCF50606_REG_RTCSC = 0x0a, /* Second */
2034 + PCF50606_REG_RTCMN = 0x0b, /* Minute */
2035 + PCF50606_REG_RTCHR = 0x0c, /* Hour */
2036 + PCF50606_REG_RTCWD = 0x0d, /* Weekday */
2037 + PCF50606_REG_RTCDT = 0x0e, /* Day */
2038 + PCF50606_REG_RTCMT = 0x0f, /* Month */
2039 + PCF50606_REG_RTCYR = 0x10, /* Year */
2040 + PCF50606_REG_RTCSCA = 0x11, /* Alarm Second */
2041 + PCF50606_REG_RTCMNA = 0x12, /* Alarm Minute */
2042 + PCF50606_REG_RTCHRA = 0x13, /* Alarm Hour */
2043 + PCF50606_REG_RTCWDA = 0x14, /* Alarm Weekday */
2044 + PCF50606_REG_RTCDTA = 0x15, /* Alarm Day */
2045 + PCF50606_REG_RTCMTA = 0x16, /* Alarm Month */
2046 + PCF50606_REG_RTCYRA = 0x17, /* Alarm Year */
2047 + PCF50606_REG_PSSC = 0x18, /* Power sequencing */
2048 + PCF50606_REG_PWROKM = 0x19, /* PWROK mask */
2049 + PCF50606_REG_PWROKS = 0x1a, /* PWROK status */
2050 + PCF50606_REG_DCDC1 = 0x1b,
2051 + PCF50606_REG_DCDC2 = 0x1c,
2052 + PCF50606_REG_DCDC3 = 0x1d,
2053 + PCF50606_REG_DCDC4 = 0x1e,
2054 + PCF50606_REG_DCDEC1 = 0x1f,
2055 + PCF50606_REG_DCDEC2 = 0x20,
2056 + PCF50606_REG_DCUDC1 = 0x21,
2057 + PCF50606_REG_DCUDC2 = 0x22,
2058 + PCF50606_REG_IOREGC = 0x23,
2059 + PCF50606_REG_D1REGC1 = 0x24,
2060 + PCF50606_REG_D2REGC1 = 0x25,
2061 + PCF50606_REG_D3REGC1 = 0x26,
2062 + PCF50606_REG_LPREGC1 = 0x27,
2063 + PCF50606_REG_LPREGC2 = 0x28,
2064 + PCF50606_REG_MBCC1 = 0x29,
2065 + PCF50606_REG_MBCC2 = 0x2a,
2066 + PCF50606_REG_MBCC3 = 0x2b,
2067 + PCF50606_REG_MBCS1 = 0x2c,
2068 + PCF50606_REG_BBCC = 0x2d,
2069 + PCF50606_REG_ADCC1 = 0x2e,
2070 + PCF50606_REG_ADCC2 = 0x2f,
2071 + PCF50606_REG_ADCS1 = 0x30,
2072 + PCF50606_REG_ADCS2 = 0x31,
2073 + PCF50606_REG_ADCS3 = 0x32,
2074 + PCF50606_REG_ACDC1 = 0x33,
2075 + PCF50606_REG_BVMC = 0x34,
2076 + PCF50606_REG_PWMC1 = 0x35,
2077 + PCF50606_REG_LEDC1 = 0x36,
2078 + PCF50606_REG_LEDC2 = 0x37,
2079 + PCF50606_REG_GPOC1 = 0x38,
2080 + PCF50606_REG_GPOC2 = 0x39,
2081 + PCF50606_REG_GPOC3 = 0x3a,
2082 + PCF50606_REG_GPOC4 = 0x3b,
2083 + PCF50606_REG_GPOC5 = 0x3c,
2084 + __NUM_PCF50606_REGS
2085 +};
2086 +
2087 +enum pcf50606_reg_oocs {
2088 + PFC50606_OOCS_ONKEY = 0x01,
2089 + PCF50606_OOCS_EXTON = 0x02,
2090 + PCF50606_OOCS_PWROKRST = 0x04,
2091 + PCF50606_OOCS_BATOK = 0x08,
2092 + PCF50606_OOCS_BACKOK = 0x10,
2093 + PCF50606_OOCS_CHGOK = 0x20,
2094 + PCF50606_OOCS_TEMPOK = 0x40,
2095 + PCF50606_OOCS_WDTEXP = 0x80,
2096 +};
2097 +
2098 +enum pcf50606_reg_oocc1 {
2099 + PCF50606_OOCC1_GOSTDBY = 0x01,
2100 + PCF50606_OOCC1_TOTRST = 0x02,
2101 + PCF50606_OOCC1_CLK32ON = 0x04,
2102 + PCF50606_OOCC1_WDTRST = 0x08,
2103 + PCF50606_OOCC1_RTCWAK = 0x10,
2104 + PCF50606_OOCC1_CHGWAK = 0x20,
2105 + PCF50606_OOCC1_EXTONWAK_HIGH = 0x40,
2106 + PCF50606_OOCC1_EXTONWAK_LOW = 0x80,
2107 +};
2108 +
2109 +enum pcf50606_reg_oocc2 {
2110 + PCF50606_OOCC2_ONKEYDB_NONE = 0x00,
2111 + PCF50606_OOCC2_ONKEYDB_14ms = 0x01,
2112 + PCF50606_OOCC2_ONKEYDB_62ms = 0x02,
2113 + PCF50606_OOCC2_ONKEYDB_500ms = 0x03,
2114 + PCF50606_OOCC2_EXTONDB_NONE = 0x00,
2115 + PCF50606_OOCC2_EXTONDB_14ms = 0x04,
2116 + PCF50606_OOCC2_EXTONDB_62ms = 0x08,
2117 + PCF50606_OOCC2_EXTONDB_500ms = 0x0c,
2118 +};
2119 +
2120 +enum pcf50606_reg_int1 {
2121 + PCF50606_INT1_ONKEYR = 0x01, /* ONKEY rising edge */
2122 + PCF50606_INT1_ONKEYF = 0x02, /* ONKEY falling edge */
2123 + PCF50606_INT1_ONKEY1S = 0x04, /* OMKEY at least 1sec low */
2124 + PCF50606_INT1_EXTONR = 0x08, /* EXTON rising edge */
2125 + PCF50606_INT1_EXTONF = 0x10, /* EXTON falling edge */
2126 + PCF50606_INT1_SECOND = 0x40, /* RTC periodic second interrupt */
2127 + PCF50606_INT1_ALARM = 0x80, /* RTC alarm time is reached */
2128 +};
2129 +
2130 +enum pcf50606_reg_int2 {
2131 + PCF50606_INT2_CHGINS = 0x01, /* Charger inserted */
2132 + PCF50606_INT2_CHGRM = 0x02, /* Charger removed */
2133 + PCF50606_INT2_CHGFOK = 0x04, /* Fast charging OK */
2134 + PCF50606_INT2_CHGERR = 0x08, /* Error in charging mode */
2135 + PCF50606_INT2_CHGFRDY = 0x10, /* Fast charge completed */
2136 + PCF50606_INT2_CHGPROT = 0x20, /* Charging protection interrupt */
2137 + PCF50606_INT2_CHGWD10S = 0x40, /* Charger watchdig expires in 10s */
2138 + PCF50606_INT2_CHGWDEXP = 0x80, /* Charger watchdog expires */
2139 +};
2140 +
2141 +enum pcf50606_reg_int3 {
2142 + PCF50606_INT3_ADCRDY = 0x01, /* ADC conversion finished */
2143 + PCF50606_INT3_ACDINS = 0x02, /* Accessory inserted */
2144 + PCF50606_INT3_ACDREM = 0x04, /* Accessory removed */
2145 + PCF50606_INT3_TSCPRES = 0x08, /* Touch screen pressed */
2146 + PCF50606_INT3_LOWBAT = 0x40, /* Low battery voltage */
2147 + PCF50606_INT3_HIGHTMP = 0x80, /* High temperature */
2148 +};
2149 +
2150 +/* used by PSSC, PWROKM, PWROKS, */
2151 +enum pcf50606_regu {
2152 + PCF50606_REGU_DCD = 0x01, /* DCD in phase 2 */
2153 + PCF50606_REGU_DCDE = 0x02, /* DCDE in phase 2 */
2154 + PCF50606_REGU_DCUD = 0x04, /* DCDU in phase 2 */
2155 + PCF50606_REGU_IO = 0x08, /* IO in phase 2 */
2156 + PCF50606_REGU_D1 = 0x10, /* D1 in phase 2 */
2157 + PCF50606_REGU_D2 = 0x20, /* D2 in phase 2 */
2158 + PCF50606_REGU_D3 = 0x40, /* D3 in phase 2 */
2159 + PCF50606_REGU_LP = 0x80, /* LP in phase 2 */
2160 +};
2161 +
2162 +enum pcf50606_reg_dcdc4 {
2163 + PCF50606_DCDC4_MODE_AUTO = 0x00,
2164 + PCF50606_DCDC4_MODE_PWM = 0x01,
2165 + PCF50606_DCDC4_MODE_PCF = 0x02,
2166 + PCF50606_DCDC4_OFF_FLOAT = 0x00,
2167 + PCF50606_DCDC4_OFF_BYPASS = 0x04,
2168 + PCF50606_DCDC4_OFF_PULLDOWN = 0x08,
2169 + PCF50606_DCDC4_CURLIM_500mA = 0x00,
2170 + PCF50606_DCDC4_CURLIM_750mA = 0x10,
2171 + PCF50606_DCDC4_CURLIM_1000mA = 0x20,
2172 + PCF50606_DCDC4_CURLIM_1250mA = 0x30,
2173 + PCF50606_DCDC4_TOGGLE = 0x40,
2174 + PCF50606_DCDC4_REGSEL_DCDC2 = 0x80,
2175 +};
2176 +
2177 +enum pcf50606_reg_dcdec2 {
2178 + PCF50606_DCDEC2_MODE_AUTO = 0x00,
2179 + PCF50606_DCDEC2_MODE_PWM = 0x01,
2180 + PCF50606_DCDEC2_MODE_PCF = 0x02,
2181 + PCF50606_DCDEC2_OFF_FLOAT = 0x00,
2182 + PCF50606_DCDEC2_OFF_BYPASS = 0x04,
2183 +};
2184 +
2185 +enum pcf50606_reg_dcudc2 {
2186 + PCF50606_DCUDC2_MODE_AUTO = 0x00,
2187 + PCF50606_DCUDC2_MODE_PWM = 0x01,
2188 + PCF50606_DCUDC2_MODE_PCF = 0x02,
2189 + PCF50606_DCUDC2_OFF_FLOAT = 0x00,
2190 + PCF50606_DCUDC2_OFF_BYPASS = 0x04,
2191 +};
2192 +
2193 +enum pcf50606_reg_adcc1 {
2194 + PCF50606_ADCC1_TSCMODACT = 0x01,
2195 + PCF50606_ADCC1_TSCMODSTB = 0x02,
2196 + PCF50606_ADCC1_TRATSET = 0x04,
2197 + PCF50606_ADCC1_NTCSWAPE = 0x08,
2198 + PCF50606_ADCC1_NTCSWAOFF = 0x10,
2199 + PCF50606_ADCC1_EXTSYNCBREAK = 0x20,
2200 + /* reserved */
2201 + PCF50606_ADCC1_TSCINT = 0x80,
2202 +};
2203 +
2204 +enum pcf50606_reg_adcc2 {
2205 + PCF50606_ADCC2_ADCSTART = 0x01,
2206 + /* see enum pcf50606_adcc2_adcmux */
2207 + PCF50606_ADCC2_SYNC_NONE = 0x00,
2208 + PCF50606_ADCC2_SYNC_TXON = 0x20,
2209 + PCF50606_ADCC2_SYNC_PWREN1 = 0x40,
2210 + PCF50606_ADCC2_SYNC_PWREN2 = 0x60,
2211 + PCF50606_ADCC2_RES_10BIT = 0x00,
2212 + PCF50606_ADCC2_RES_8BIT = 0x80,
2213 +};
2214 +
2215 +#define PCF50606_ADCC2_ADCMUX_MASK (0xf << 1)
2216 +
2217 +#define ADCMUX_SHIFT 1
2218 +enum pcf50606_adcc2_adcmux {
2219 + PCF50606_ADCMUX_BATVOLT_RES = 0x0 << ADCMUX_SHIFT,
2220 + PCF50606_ADCMUX_BATVOLT_SUBTR = 0x1 << ADCMUX_SHIFT,
2221 + PCF50606_ADCMUX_ADCIN1_RES = 0x2 << ADCMUX_SHIFT,
2222 + PCF50606_ADCMUX_ADCIN1_SUBTR = 0x3 << ADCMUX_SHIFT,
2223 + PCF50606_ADCMUX_BATTEMP = 0x4 << ADCMUX_SHIFT,
2224 + PCF50606_ADCMUX_ADCIN2 = 0x5 << ADCMUX_SHIFT,
2225 + PCF50606_ADCMUX_ADCIN3 = 0x6 << ADCMUX_SHIFT,
2226 + PCF50606_ADCMUX_ADCIN3_RATIO = 0x7 << ADCMUX_SHIFT,
2227 + PCF50606_ADCMUX_XPOS = 0x8 << ADCMUX_SHIFT,
2228 + PCF50606_ADCMUX_YPOS = 0x9 << ADCMUX_SHIFT,
2229 + PCF50606_ADCMUX_P1 = 0xa << ADCMUX_SHIFT,
2230 + PCF50606_ADCMUX_P2 = 0xb << ADCMUX_SHIFT,
2231 + PCF50606_ADCMUX_BATVOLT_ADCIN1 = 0xc << ADCMUX_SHIFT,
2232 + PCF50606_ADCMUX_XY_SEQUENCE = 0xe << ADCMUX_SHIFT,
2233 + PCF50606_P1_P2_RESISTANCE = 0xf << ADCMUX_SHIFT,
2234 +};
2235 +
2236 +enum pcf50606_adcs2 {
2237 + PCF50606_ADCS2_ADCRDY = 0x80,
2238 +};
2239 +
2240 +enum pcf50606_reg_mbcc1 {
2241 + PCF50606_MBCC1_CHGAPE = 0x01,
2242 + PCF50606_MBCC1_AUTOFST = 0x02,
2243 +#define PCF50606_MBCC1_CHGMOD_MASK 0x1c
2244 +#define PCF50606_MBCC1_CHGMOD_SHIFT 2
2245 + PCF50606_MBCC1_CHGMOD_QUAL = 0x00,
2246 + PCF50606_MBCC1_CHGMOD_PRE = 0x04,
2247 + PCF50606_MBCC1_CHGMOD_TRICKLE = 0x08,
2248 + PCF50606_MBCC1_CHGMOD_FAST_CCCV = 0x0c,
2249 + PCF50606_MBCC1_CHGMOD_FAST_NOCC = 0x10,
2250 + PCF50606_MBCC1_CHGMOD_FAST_NOCV = 0x14,
2251 + PCF50606_MBCC1_CHGMOD_FAST_SW = 0x18,
2252 + PCF50606_MBCC1_CHGMOD_IDLE = 0x1c,
2253 + PCF50606_MBCC1_DETMOD_LOWCHG = 0x20,
2254 + PCF50606_MBCC1_DETMOD_WDRST = 0x40,
2255 +};
2256 +
2257 +enum pcf50606_reg_acdc1 {
2258 + PCF50606_ACDC1_ACDDET = 0x01,
2259 + PCF50606_ACDC1_THRSHLD_1V0 = 0x00,
2260 + PCF50606_ACDC1_THRSHLD_1V2 = 0x02,
2261 + PCF50606_ACDC1_THRSHLD_1V4 = 0x04,
2262 + PCF50606_ACDC1_THRSHLD_1V6 = 0x06,
2263 + PCF50606_ACDC1_THRSHLD_1V8 = 0x08,
2264 + PCF50606_ACDC1_THRSHLD_2V0 = 0x0a,
2265 + PCF50606_ACDC1_THRSHLD_2V2 = 0x0c,
2266 + PCF50606_ACDC1_THRSHLD_2V4 = 0x0e,
2267 + PCF50606_ACDC1_DISDB = 0x10,
2268 + PCF50606_ACDC1_ACDAPE = 0x80,
2269 +};
2270 +
2271 +enum pcf50606_reg_bvmc {
2272 + PCF50606_BVMC_LOWBAT = 0x01,
2273 + PCF50606_BVMC_THRSHLD_NULL = 0x00,
2274 + PCF50606_BVMC_THRSHLD_2V8 = 0x02,
2275 + PCF50606_BVMC_THRSHLD_2V9 = 0x04,
2276 + PCF50606_BVMC_THRSHLD_3V = 0x08,
2277 + PCF50606_BVMC_THRSHLD_3V1 = 0x08,
2278 + PCF50606_BVMC_THRSHLD_3V2 = 0x0a,
2279 + PCF50606_BVMC_THRSHLD_3V3 = 0x0c,
2280 + PCF50606_BVMC_THRSHLD_3V4 = 0x0e,
2281 + PCF50606_BVMC_DISDB = 0x10,
2282 +};
2283 +
2284 +enum pcf50606_reg_pwmc1 {
2285 + PCF50606_PWMC1_ACTSET = 0x01,
2286 + PCF50606_PWMC1_PWMDC_0_16 = 0x00,
2287 + PCF50606_PWMC1_PWMDC_1_16 = 0x02,
2288 + PCF50606_PWMC1_PWMDC_2_16 = 0x04,
2289 + PCF50606_PWMC1_PWMDC_3_16 = 0x06,
2290 + PCF50606_PWMC1_PWMDC_4_16 = 0x08,
2291 + PCF50606_PWMC1_PWMDC_5_16 = 0x0a,
2292 + PCF50606_PWMC1_PWMDC_6_16 = 0x0c,
2293 + PCF50606_PWMC1_PWMDC_7_16 = 0x0e,
2294 + PCF50606_PWMC1_PWMDC_8_16 = 0x10,
2295 + PCF50606_PWMC1_PWMDC_9_16 = 0x12,
2296 + PCF50606_PWMC1_PWMDC_10_16 = 0x14,
2297 + PCF50606_PWMC1_PWMDC_11_16 = 0x16,
2298 + PCF50606_PWMC1_PWMDC_12_16 = 0x18,
2299 + PCF50606_PWMC1_PWMDC_13_16 = 0x1a,
2300 + PCF50606_PWMC1_PWMDC_14_16 = 0x1c,
2301 + PCF50606_PWMC1_PWMDC_15_16 = 0x1e,
2302 + PCF50606_PWMC1_PRESC_512Hz = 0x20,
2303 + PCF50606_PWMC1_PRESC_256Hz = 0x40,
2304 + PCF50606_PWMC1_PRESC_64Hz = 0x60,
2305 + PCF50606_PWMC1_PRESC_56kHz = 0x80,
2306 + PCF50606_PWMC1_PRESC_28kHz = 0xa0,
2307 + PCF50606_PWMC1_PRESC_14kHz = 0xc0,
2308 + PCF50606_PWMC1_PRESC_7kHz = 0xe0,
2309 +};
2310 +#define PCF50606_PWMC1_CLK_SHIFT 5
2311 +#define PCF50606_PWMC1_DC_SHIFT 1
2312 +
2313 +#endif /* _PCF50606_H */
2314 +
2315 diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
2316 index 580acc9..2cda699 100644
2317 --- a/include/linux/i2c-id.h
2318 +++ b/include/linux/i2c-id.h
2319 @@ -94,6 +94,7 @@
2320 #define I2C_DRIVERID_I2CDEV 900
2321
2322 #define I2C_DRIVERID_OV7670 1048 /* Omnivision 7670 camera */
2323 +#define I2C_DRIVERID_PCF50606 1049
2324
2325 /*
2326 * ---- Adapter types ----------------------------------------------------
2327 diff --git a/include/linux/pcf50606.h b/include/linux/pcf50606.h
2328 new file mode 100644
2329 index 0000000..bc98e47
2330 --- /dev/null
2331 +++ b/include/linux/pcf50606.h
2332 @@ -0,0 +1,108 @@
2333 +#ifndef _LINUX_PCF50606_H
2334 +#define _LINUX_PCF50606_H
2335 +
2336 +/* public in-kernel pcf50606 api */
2337 +enum pcf50606_regulator_id {
2338 + PCF50606_REGULATOR_DCD,
2339 + PCF50606_REGULATOR_DCDE,
2340 + PCF50606_REGULATOR_DCUD,
2341 + PCF50606_REGULATOR_D1REG,
2342 + PCF50606_REGULATOR_D2REG,
2343 + PCF50606_REGULATOR_D3REG,
2344 + PCF50606_REGULATOR_LPREG,
2345 + PCF50606_REGULATOR_IOREG,
2346 + __NUM_PCF50606_REGULATORS
2347 +};
2348 +
2349 +struct pcf50606_data;
2350 +
2351 +/* This is an ugly construct on how to access the (currently single/global)
2352 + * pcf50606 handle from other code in the kernel. I didn't really come up with
2353 + * a more decent method of dynamically resolving this */
2354 +extern struct pcf50606_data *pcf50606_global;
2355 +
2356 +extern void
2357 +pcf50606_go_standby(void);
2358 +
2359 +extern void
2360 +pcf50606_gpo0_set(struct pcf50606_data *pcf, int on);
2361 +
2362 +extern int
2363 +pcf50606_gpo0_get(struct pcf50606_data *pcf);
2364 +
2365 +extern int
2366 +pcf50606_voltage_set(struct pcf50606_data *pcf,
2367 + enum pcf50606_regulator_id reg,
2368 + unsigned int millivolts);
2369 +extern unsigned int
2370 +pcf50606_voltage_get(struct pcf50606_data *pcf,
2371 + enum pcf50606_regulator_id reg);
2372 +extern int
2373 +pcf50606_onoff_get(struct pcf50606_data *pcf,
2374 + enum pcf50606_regulator_id reg);
2375 +
2376 +extern int
2377 +pcf50606_onoff_set(struct pcf50606_data *pcf,
2378 + enum pcf50606_regulator_id reg, int on);
2379 +
2380 +extern void
2381 +pcf50606_charge_fast(struct pcf50606_data *pcf, int on);
2382 +
2383 +#define PMU_VRAIL_F_SUSPEND_ON 0x00000001 /* Remains on during suspend */
2384 +#define PMU_VRAIL_F_UNUSED 0x00000002 /* This rail is not used */
2385 +struct pmu_voltage_rail {
2386 + char *name;
2387 + unsigned int flags;
2388 + struct {
2389 + unsigned int init;
2390 + unsigned int max;
2391 + } voltage;
2392 +};
2393 +
2394 +enum pmu_event {
2395 + PMU_EVT_NONE,
2396 + PMU_EVT_INSERT,
2397 + PMU_EVT_REMOVE,
2398 + __NUM_PMU_EVTS
2399 +};
2400 +
2401 +typedef int pmu_cb(struct device *dev, unsigned int feature,
2402 + enum pmu_event event);
2403 +
2404 +#define PCF50606_FEAT_EXTON 0x00000001 /* not yet supported */
2405 +#define PCF50606_FEAT_MBC 0x00000002
2406 +#define PCF50606_FEAT_BBC 0x00000004 /* not yet supported */
2407 +#define PCF50606_FEAT_TSC 0x00000008 /* not yet supported */
2408 +#define PCF50606_FEAT_WDT 0x00000010
2409 +#define PCF50606_FEAT_ACD 0x00000020
2410 +#define PCF50606_FEAT_RTC 0x00000040
2411 +#define PCF50606_FEAT_PWM 0x00000080
2412 +#define PCF50606_FEAT_CHGCUR 0x00000100
2413 +#define PCF50606_FEAT_BATVOLT 0x00000200
2414 +#define PCF50606_FEAT_BATTEMP 0x00000400
2415 +#define PCF50606_FEAT_PWM_BL 0x00000800
2416 +
2417 +struct pcf50606_platform_data {
2418 + /* general */
2419 + unsigned int used_features;
2420 + unsigned int onkey_seconds_required;
2421 +
2422 + /* voltage regulator related */
2423 + struct pmu_voltage_rail rails[__NUM_PCF50606_REGULATORS];
2424 + unsigned int used_regulators;
2425 +
2426 + /* charger related */
2427 + unsigned int r_fix_batt;
2428 + unsigned int r_fix_batt_par;
2429 + unsigned int r_sense_milli;
2430 +
2431 + /* backlight related */
2432 + unsigned int init_brightness;
2433 +
2434 + struct {
2435 + u_int8_t mbcc3; /* charger voltage / current */
2436 + } charger;
2437 + pmu_cb *cb;
2438 +};
2439 +
2440 +#endif
2441 --
2442 1.5.6.3
2443
Personal OpenWRT clone
This page took 0.14964 seconds and 5 git commands to generate.