projects / openwrt / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
disable IMQ on 2.6.28 as well -- people should use IFB..
[openwrt/openwrt.git] / target / linux / s3c24xx / patches / 0024-pcf50633.patch.patch
1 From b04e2c56a057f288342a8ce8f88b7a1dfc88afa1 Mon Sep 17 00:00:00 2001
2 From: mokopatches <mokopatches@openmoko.org>
3 Date: Wed, 16 Jul 2008 14:44:50 +0100
4 Subject: [PATCH] pcf50633.patch
5
6 ---
7 drivers/i2c/chips/Kconfig | 9 +
8 drivers/i2c/chips/Makefile | 1 +
9 drivers/i2c/chips/pcf50633.c | 1964 ++++++++++++++++++++++++++++++++++++++++++
10 drivers/i2c/chips/pcf50633.h | 402 +++++++++
11 include/linux/i2c-id.h | 1 +
12 include/linux/pcf50633.h | 114 +++
13 6 files changed, 2491 insertions(+), 0 deletions(-)
14 create mode 100644 drivers/i2c/chips/pcf50633.c
15 create mode 100644 drivers/i2c/chips/pcf50633.h
16 create mode 100644 include/linux/pcf50633.h
17
18 diff --git a/drivers/i2c/chips/Kconfig b/drivers/i2c/chips/Kconfig
19 index e8e64aa..e38c006 100644
20 --- a/drivers/i2c/chips/Kconfig
21 +++ b/drivers/i2c/chips/Kconfig
22 @@ -35,6 +35,15 @@ config SENSORS_PCF50606
23 This driver can also be built as a module. If so, the module
24 will be called pcf50606.
25
26 +config SENSORS_PCF50633
27 + tristate "Philips PCF50633"
28 + depends on I2C
29 + help
30 + If you say yes here you get support for Philips PCF50633
31 + PMU (Power Management Unit) chips.
32 +
33 + This driver can also be built as a module. If so, the module
34 + will be called pcf50633.
35
36 config SENSORS_PCF8574
37 tristate "Philips PCF8574 and PCF8574A"
38 diff --git a/drivers/i2c/chips/Makefile b/drivers/i2c/chips/Makefile
39 index 60d3d5a..9fa353d 100644
40 --- a/drivers/i2c/chips/Makefile
41 +++ b/drivers/i2c/chips/Makefile
42 @@ -14,6 +14,7 @@ obj-$(CONFIG_SENSORS_EEPROM) += eeprom.o
43 obj-$(CONFIG_SENSORS_MAX6875) += max6875.o
44 obj-$(CONFIG_SENSORS_PCA9539) += pca9539.o
45 obj-$(CONFIG_SENSORS_PCF50606) += pcf50606.o
46 +obj-$(CONFIG_SENSORS_PCF50633) += pcf50633.o
47 obj-$(CONFIG_SENSORS_PCF8574) += pcf8574.o
48 obj-$(CONFIG_PCF8575) += pcf8575.o
49 obj-$(CONFIG_SENSORS_PCF8591) += pcf8591.o
50 diff --git a/drivers/i2c/chips/pcf50633.c b/drivers/i2c/chips/pcf50633.c
51 new file mode 100644
52 index 0000000..5488084
53 --- /dev/null
54 +++ b/drivers/i2c/chips/pcf50633.c
55 @@ -0,0 +1,1964 @@
56 +/* Philips PCF50633 Power Management Unit (PMU) driver
57 + *
58 + * (C) 2006-2007 by OpenMoko, Inc.
59 + * Author: Harald Welte <laforge@openmoko.org>
60 + * All rights reserved.
61 + *
62 + * This program is free software; you can redistribute it and/or
63 + * modify it under the terms of the GNU General Public License as
64 + * published by the Free Software Foundation; either version 2 of
65 + * the License, or (at your option) any later version.
66 + *
67 + * This program is distributed in the hope that it will be useful,
68 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
69 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
70 + * GNU General Public License for more details.
71 + *
72 + * You should have received a copy of the GNU General Public License
73 + * along with this program; if not, write to the Free Software
74 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
75 + * MA 02111-1307 USA
76 + *
77 + * This driver is a monster ;) It provides the following features
78 + * - voltage control for a dozen different voltage domains
79 + * - charging control for main and backup battery
80 + * - rtc / alarm
81 + * - adc driver (hw_sensors like)
82 + * - backlight
83 + *
84 + */
85 +
86 +#include <linux/module.h>
87 +#include <linux/init.h>
88 +#include <linux/i2c.h>
89 +#include <linux/types.h>
90 +#include <linux/interrupt.h>
91 +#include <linux/irq.h>
92 +#include <linux/workqueue.h>
93 +#include <linux/delay.h>
94 +#include <linux/rtc.h>
95 +#include <linux/bcd.h>
96 +#include <linux/watchdog.h>
97 +#include <linux/miscdevice.h>
98 +#include <linux/input.h>
99 +#include <linux/fb.h>
100 +#include <linux/backlight.h>
101 +#include <linux/sched.h>
102 +#include <linux/platform_device.h>
103 +#include <linux/pcf50633.h>
104 +#include <linux/apm-emulation.h>
105 +
106 +#include <asm/mach-types.h>
107 +#include <asm/arch/gta02.h>
108 +
109 +#include "pcf50633.h"
110 +
111 +#if 1
112 +#define DEBUGP(x, args ...) printk("%s: " x, __FUNCTION__, ## args)
113 +#define DEBUGPC(x, args ...) printk(x, ## args)
114 +#else
115 +#define DEBUGP(x, args ...)
116 +#define DEBUGPC(x, args ...)
117 +#endif
118 +
119 +/***********************************************************************
120 + * Static data / structures
121 + ***********************************************************************/
122 +
123 +static unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
124 +
125 +I2C_CLIENT_INSMOD_1(pcf50633);
126 +
127 +#define PCF50633_FIDX_CHG_ENABLED 0 /* Charger enabled */
128 +#define PCF50633_FIDX_CHG_PRESENT 1 /* Charger present */
129 +#define PCF50633_FIDX_CHG_ERR 3 /* Charger Error */
130 +#define PCF50633_FIDX_CHG_PROT 4 /* Charger Protection */
131 +#define PCF50633_FIDX_CHG_READY 5 /* Charging completed */
132 +#define PCF50633_FIDX_PWR_PRESSED 8
133 +#define PCF50633_FIDX_RTC_SECOND 9
134 +#define PCF50633_FIDX_USB_PRESENT 10
135 +
136 +#define PCF50633_F_CHG_ENABLED (1 << PCF50633_FIDX_CHG_ENABLED)
137 +#define PCF50633_F_CHG_PRESENT (1 << PCF50633_FIDX_CHG_PRESENT)
138 +#define PCF50633_F_CHG_ERR (1 << PCF50633_FIDX_CHG_ERR)
139 +#define PCF50633_F_CHG_PROT (1 << PCF50633_FIDX_CHG_PROT)
140 +#define PCF50633_F_CHG_READY (1 << PCF50633_FIDX_CHG_READY)
141 +
142 +#define PCF50633_F_CHG_MASK 0x000000fc
143 +
144 +#define PCF50633_F_PWR_PRESSED (1 << PCF50633_FIDX_PWR_PRESSED)
145 +#define PCF50633_F_RTC_SECOND (1 << PCF50633_FIDX_RTC_SECOND)
146 +#define PCF50633_F_USB_PRESENT (1 << PCF50633_FIDX_USB_PRESENT)
147 +
148 +enum close_state {
149 + CLOSE_STATE_NOT,
150 + CLOSE_STATE_ALLOW = 0x2342,
151 +};
152 +
153 +enum charger_type {
154 + CHARGER_TYPE_NONE = 0,
155 + CHARGER_TYPE_HOSTUSB,
156 + CHARGER_TYPE_1A
157 +};
158 +
159 +#define ADC_NOM_CHG_DETECT_1A 6
160 +#define ADC_NOM_CHG_DETECT_NONE 43
161 +
162 +#define MAX_ADC_FIFO_DEPTH 8
163 +
164 +struct pcf50633_data {
165 + struct i2c_client client;
166 + struct pcf50633_platform_data *pdata;
167 + struct backlight_device *backlight;
168 + struct mutex lock;
169 + unsigned int flags;
170 + unsigned int working;
171 + struct mutex working_lock;
172 + struct work_struct work;
173 + struct rtc_device *rtc;
174 + struct input_dev *input_dev;
175 + int allow_close;
176 + int onkey_seconds;
177 + int irq;
178 +
179 + int coldplug_done; /* cleared by probe, set by first work service */
180 + int flag_bat_voltage_read; /* ipc to /sys batt voltage read func */
181 +
182 + int charger_adc_result_raw;
183 + enum charger_type charger_type;
184 +
185 + /* we have a FIFO of ADC measurement requests that are used only by
186 + * the workqueue service code after the ADC completion interrupt
187 + */
188 + int adc_queue_mux[MAX_ADC_FIFO_DEPTH]; /* which ADC input to use */
189 + int adc_queue_avg[MAX_ADC_FIFO_DEPTH]; /* amount of averaging */
190 + int adc_queue_head; /* head owned by foreground code */
191 + int adc_queue_tail; /* tail owned by service code */
192 +
193 +#ifdef CONFIG_PM
194 + struct {
195 + u_int8_t int1m, int2m, int3m, int4m, int5m;
196 + u_int8_t ooctim2;
197 + u_int8_t autoout, autoena, automxc;
198 + u_int8_t down1out, down1mxc;
199 + u_int8_t down2out, down2ena;
200 + u_int8_t memldoout, memldoena;
201 + u_int8_t ledout, ledena, leddim;
202 + struct {
203 + u_int8_t out;
204 + u_int8_t ena;
205 + } ldo[__NUM_PCF50633_REGS];
206 + } standby_regs;
207 +#endif
208 +};
209 +
210 +static struct i2c_driver pcf50633_driver;
211 +
212 +struct pcf50633_data *pcf50633_global;
213 +EXPORT_SYMBOL_GPL(pcf50633_global);
214 +
215 +static struct platform_device *pcf50633_pdev;
216 +
217 +/***********************************************************************
218 + * Low-Level routines
219 + ***********************************************************************/
220 +
221 +static int __reg_write(struct pcf50633_data *pcf, u_int8_t reg, u_int8_t val)
222 +{
223 + return i2c_smbus_write_byte_data(&pcf->client, reg, val);
224 +}
225 +
226 +static int reg_write(struct pcf50633_data *pcf, u_int8_t reg, u_int8_t val)
227 +{
228 + int ret;
229 +
230 + mutex_lock(&pcf->lock);
231 + ret = __reg_write(pcf, reg, val);
232 + mutex_unlock(&pcf->lock);
233 +
234 + return ret;
235 +}
236 +
237 +static int32_t __reg_read(struct pcf50633_data *pcf, u_int8_t reg)
238 +{
239 + int32_t ret;
240 +
241 + ret = i2c_smbus_read_byte_data(&pcf->client, reg);
242 +
243 + return ret;
244 +}
245 +
246 +static u_int8_t reg_read(struct pcf50633_data *pcf, u_int8_t reg)
247 +{
248 + int32_t ret;
249 +
250 + mutex_lock(&pcf->lock);
251 + ret = __reg_read(pcf, reg);
252 + mutex_unlock(&pcf->lock);
253 +
254 + return ret & 0xff;
255 +}
256 +
257 +static int reg_set_bit_mask(struct pcf50633_data *pcf,
258 + u_int8_t reg, u_int8_t mask, u_int8_t val)
259 +{
260 + int ret;
261 + u_int8_t tmp;
262 +
263 + val &= mask;
264 +
265 + mutex_lock(&pcf->lock);
266 +
267 + tmp = __reg_read(pcf, reg);
268 + tmp &= ~mask;
269 + tmp |= val;
270 + ret = __reg_write(pcf, reg, tmp);
271 +
272 + mutex_unlock(&pcf->lock);
273 +
274 + return ret;
275 +}
276 +
277 +static int reg_clear_bits(struct pcf50633_data *pcf, u_int8_t reg, u_int8_t val)
278 +{
279 + int ret;
280 + u_int8_t tmp;
281 +
282 + mutex_lock(&pcf->lock);
283 +
284 + tmp = __reg_read(pcf, reg);
285 + tmp &= ~val;
286 + ret = __reg_write(pcf, reg, tmp);
287 +
288 + mutex_unlock(&pcf->lock);
289 +
290 + return ret;
291 +}
292 +
293 +/* asynchronously setup reading one ADC channel */
294 +static void async_adc_read_setup(struct pcf50633_data *pcf,
295 + int channel, int avg)
296 +{
297 + channel &= PCF50633_ADCC1_ADCMUX_MASK;
298 +
299 + /* kill ratiometric, but enable ACCSW biasing */
300 + __reg_write(pcf, PCF50633_REG_ADCC2, 0x00);
301 + __reg_write(pcf, PCF50633_REG_ADCC3, 0x01);
302 +
303 + /* start ADC conversion of selected channel */
304 + __reg_write(pcf, PCF50633_REG_ADCC1, channel | avg |
305 + PCF50633_ADCC1_ADCSTART | PCF50633_ADCC1_RES_10BIT);
306 +
307 +}
308 +
309 +static u_int16_t async_adc_complete(struct pcf50633_data *pcf)
310 +{
311 + u_int16_t ret = (__reg_read(pcf, PCF50633_REG_ADCS1) << 2) |
312 + (__reg_read(pcf, PCF50633_REG_ADCS3) &
313 + PCF50633_ADCS3_ADCDAT1L_MASK);
314 +
315 + return ret;
316 +}
317 +
318 +
319 +
320 +
321 +/***********************************************************************
322 + * Voltage / ADC
323 + ***********************************************************************/
324 +
325 +static u_int8_t auto_voltage(unsigned int millivolts)
326 +{
327 + if (millivolts < 1800)
328 + return 0;
329 + if (millivolts > 3800)
330 + return 0xff;
331 +
332 + millivolts -= 625;
333 + return millivolts/25;
334 +}
335 +
336 +static unsigned int auto_2voltage(u_int8_t bits)
337 +{
338 + if (bits < 0x2f)
339 + return 0;
340 + return 625 + (bits * 25);
341 +}
342 +
343 +static u_int8_t down_voltage(unsigned int millivolts)
344 +{
345 + if (millivolts < 625)
346 + return 0;
347 + else if (millivolts > 3000)
348 + return 0xff;
349 +
350 + millivolts -= 625;
351 + return millivolts/25;
352 +}
353 +
354 +static unsigned int down_2voltage(u_int8_t bits)
355 +{
356 + return 625 + (bits*25);
357 +}
358 +
359 +static u_int8_t ldo_voltage(unsigned int millivolts)
360 +{
361 + if (millivolts < 900)
362 + return 0;
363 + else if (millivolts > 3600)
364 + return 0x1f;
365 +
366 + millivolts -= 900;
367 + return millivolts/100;
368 +}
369 +
370 +static unsigned int ldo_2voltage(u_int8_t bits)
371 +{
372 + bits &= 0x1f;
373 + return 900 + (bits * 100);
374 +}
375 +
376 +static const u_int8_t regulator_registers[__NUM_PCF50633_REGULATORS] = {
377 + [PCF50633_REGULATOR_AUTO] = PCF50633_REG_AUTOOUT,
378 + [PCF50633_REGULATOR_DOWN1] = PCF50633_REG_DOWN1OUT,
379 + [PCF50633_REGULATOR_DOWN2] = PCF50633_REG_DOWN2OUT,
380 + [PCF50633_REGULATOR_MEMLDO] = PCF50633_REG_MEMLDOOUT,
381 + [PCF50633_REGULATOR_LDO1] = PCF50633_REG_LDO1OUT,
382 + [PCF50633_REGULATOR_LDO2] = PCF50633_REG_LDO2OUT,
383 + [PCF50633_REGULATOR_LDO3] = PCF50633_REG_LDO3OUT,
384 + [PCF50633_REGULATOR_LDO4] = PCF50633_REG_LDO4OUT,
385 + [PCF50633_REGULATOR_LDO5] = PCF50633_REG_LDO5OUT,
386 + [PCF50633_REGULATOR_LDO6] = PCF50633_REG_LDO6OUT,
387 + [PCF50633_REGULATOR_HCLDO] = PCF50633_REG_HCLDOOUT,
388 +};
389 +
390 +int pcf50633_onoff_set(struct pcf50633_data *pcf,
391 + enum pcf50633_regulator_id reg, int on)
392 +{
393 + u_int8_t addr;
394 +
395 + if (reg >= __NUM_PCF50633_REGULATORS)
396 + return -EINVAL;
397 +
398 + /* the *ENA register is always one after the *OUT register */
399 + addr = regulator_registers[reg] + 1;
400 +
401 + if (on == 0)
402 + reg_set_bit_mask(pcf, addr, PCF50633_REGULATOR_ON, 0);
403 + else
404 + reg_set_bit_mask(pcf, addr, PCF50633_REGULATOR_ON,
405 + PCF50633_REGULATOR_ON);
406 +
407 + return 0;
408 +}
409 +EXPORT_SYMBOL_GPL(pcf50633_onoff_set);
410 +
411 +int pcf50633_onoff_get(struct pcf50633_data *pcf,
412 + enum pcf50633_regulator_id reg)
413 +{
414 + u_int8_t val, addr;
415 +
416 + if (reg >= __NUM_PCF50633_REGULATORS)
417 + return -EINVAL;
418 +
419 + /* the *ENA register is always one after the *OUT register */
420 + addr = regulator_registers[reg] + 1;
421 + val = reg_read(pcf, addr) & PCF50633_REGULATOR_ON;
422 +
423 + return val;
424 +}
425 +EXPORT_SYMBOL_GPL(pcf50633_onoff_get);
426 +
427 +int pcf50633_voltage_set(struct pcf50633_data *pcf,
428 + enum pcf50633_regulator_id reg,
429 + unsigned int millivolts)
430 +{
431 + u_int8_t volt_bits;
432 + u_int8_t regnr;
433 +
434 + DEBUGP("pcf=%p, reg=%d, mvolts=%d\n", pcf, reg, millivolts);
435 +
436 + if (reg >= __NUM_PCF50633_REGULATORS)
437 + return -EINVAL;
438 +
439 + regnr = regulator_registers[reg];
440 +
441 + if (millivolts > pcf->pdata->rails[reg].voltage.max)
442 + return -EINVAL;
443 +
444 + switch (reg) {
445 + case PCF50633_REGULATOR_AUTO:
446 + volt_bits = auto_voltage(millivolts);
447 + break;
448 + case PCF50633_REGULATOR_DOWN1:
449 + volt_bits = down_voltage(millivolts);
450 + break;
451 + case PCF50633_REGULATOR_DOWN2:
452 + volt_bits = down_voltage(millivolts);
453 + break;
454 + case PCF50633_REGULATOR_LDO1:
455 + case PCF50633_REGULATOR_LDO2:
456 + case PCF50633_REGULATOR_LDO3:
457 + case PCF50633_REGULATOR_LDO4:
458 + case PCF50633_REGULATOR_LDO5:
459 + case PCF50633_REGULATOR_LDO6:
460 + case PCF50633_REGULATOR_HCLDO:
461 + volt_bits = ldo_voltage(millivolts);
462 + DEBUGP("ldo_voltage(0x%x)=%u\n", millivolts, volt_bits);
463 + break;
464 + default:
465 + return -EINVAL;
466 + }
467 +
468 + return reg_write(pcf, regnr, volt_bits);
469 +}
470 +EXPORT_SYMBOL_GPL(pcf50633_voltage_set);
471 +
472 +unsigned int pcf50633_voltage_get(struct pcf50633_data *pcf,
473 + enum pcf50633_regulator_id reg)
474 +{
475 + u_int8_t volt_bits;
476 + u_int8_t regnr;
477 + unsigned int rc = 0;
478 +
479 + if (reg >= __NUM_PCF50633_REGULATORS)
480 + return -EINVAL;
481 +
482 + regnr = regulator_registers[reg];
483 + volt_bits = reg_read(pcf, regnr);
484 +
485 + switch (reg) {
486 + case PCF50633_REGULATOR_AUTO:
487 + rc = auto_2voltage(volt_bits);
488 + break;
489 + case PCF50633_REGULATOR_DOWN1:
490 + rc = down_2voltage(volt_bits);
491 + break;
492 + case PCF50633_REGULATOR_DOWN2:
493 + rc = down_2voltage(volt_bits);
494 + break;
495 + case PCF50633_REGULATOR_LDO1:
496 + case PCF50633_REGULATOR_LDO2:
497 + case PCF50633_REGULATOR_LDO3:
498 + case PCF50633_REGULATOR_LDO4:
499 + case PCF50633_REGULATOR_LDO5:
500 + case PCF50633_REGULATOR_LDO6:
501 + case PCF50633_REGULATOR_HCLDO:
502 + rc = ldo_2voltage(volt_bits);
503 + break;
504 + default:
505 + return -EINVAL;
506 + }
507 +
508 + return rc;
509 +}
510 +EXPORT_SYMBOL_GPL(pcf50633_voltage_get);
511 +
512 +/* go into 'STANDBY' mode, i.e. power off the main CPU and peripherals */
513 +void pcf50633_go_standby(void)
514 +{
515 + reg_set_bit_mask(pcf50633_global, PCF50633_REG_OOCSHDWN,
516 + PCF50633_OOCSHDWN_GOSTDBY, PCF50633_OOCSHDWN_GOSTDBY);
517 +}
518 +EXPORT_SYMBOL_GPL(pcf50633_go_standby);
519 +
520 +void pcf50633_gpio_set(struct pcf50633_data *pcf, enum pcf50633_gpio gpio,
521 + int on)
522 +{
523 + u_int8_t reg = gpio - PCF50633_GPIO1 + PCF50633_REG_GPIO1CFG;
524 +
525 + if (on)
526 + reg_set_bit_mask(pcf, reg, 0x0f, 0x07);
527 + else
528 + reg_set_bit_mask(pcf, reg, 0x0f, 0x00);
529 +}
530 +EXPORT_SYMBOL_GPL(pcf50633_gpio_set);
531 +
532 +int pcf50633_gpio_get(struct pcf50633_data *pcf, enum pcf50633_gpio gpio)
533 +{
534 + u_int8_t reg = gpio - PCF50633_GPIO1 + PCF50633_REG_GPIO1CFG;
535 + u_int8_t val = reg_read(pcf, reg) & 0x0f;
536 +
537 + if (val == PCF50633_GPOCFG_GPOSEL_1 ||
538 + val == (PCF50633_GPOCFG_GPOSEL_0|PCF50633_GPOCFG_GPOSEL_INVERSE))
539 + return 1;
540 +
541 + return 0;
542 +}
543 +EXPORT_SYMBOL_GPL(pcf50633_gpio_get);
544 +
545 +static int interpret_charger_type_from_adc(struct pcf50633_data *pcf,
546 + int sample)
547 +{
548 + /* 1A capable charger? */
549 +
550 + if (sample < ((ADC_NOM_CHG_DETECT_NONE + ADC_NOM_CHG_DETECT_1A) / 2))
551 + return CHARGER_TYPE_1A;
552 +
553 + /* well then, nothing in the USB hole, or USB host / unk adapter */
554 +
555 + if (pcf->flags & PCF50633_F_USB_PRESENT) /* ooh power is in there */
556 + return CHARGER_TYPE_HOSTUSB; /* HOSTUSB is the catchall */
557 +
558 + return CHARGER_TYPE_NONE; /* no really -- nothing in there */
559 +}
560 +
561 +
562 +
563 +static void configure_pmu_for_charger(struct pcf50633_data *pcf,
564 + enum charger_type type)
565 +{
566 + switch (type) {
567 + case CHARGER_TYPE_NONE:
568 + __reg_write(pcf, PCF50633_REG_MBCC7,
569 + PCF50633_MBCC7_USB_SUSPEND);
570 + break;
571 + /*
572 + * the PCF50633 has a feature that it will supply only excess current
573 + * from the charger that is not used to power the device. So this
574 + * 500mA setting is "up to 500mA" according to that.
575 + */
576 + case CHARGER_TYPE_HOSTUSB:
577 + __reg_write(pcf, PCF50633_REG_MBCC7, PCF50633_MBCC7_USB_500mA);
578 + break;
579 + case CHARGER_TYPE_1A:
580 + __reg_write(pcf, PCF50633_REG_MBCC7, PCF50633_MBCC7_USB_1000mA);
581 + break;
582 + }
583 +}
584 +
585 +static void trigger_next_adc_job_if_any(struct pcf50633_data *pcf)
586 +{
587 + if (pcf->adc_queue_head == pcf->adc_queue_tail)
588 + return;
589 + async_adc_read_setup(pcf,
590 + pcf->adc_queue_mux[pcf->adc_queue_tail],
591 + pcf->adc_queue_avg[pcf->adc_queue_tail]);
592 +}
593 +
594 +static void add_request_to_adc_queue(struct pcf50633_data *pcf,
595 + int mux, int avg)
596 +{
597 + int old_head = pcf->adc_queue_head;
598 + pcf->adc_queue_mux[pcf->adc_queue_head] = mux;
599 + pcf->adc_queue_avg[pcf->adc_queue_head] = avg;
600 +
601 + pcf->adc_queue_head = (pcf->adc_queue_head + 1) &
602 + (MAX_ADC_FIFO_DEPTH - 1);
603 +
604 + /* it was idle before we just added this? we need to kick it then */
605 + if (old_head == pcf->adc_queue_tail)
606 + trigger_next_adc_job_if_any(pcf);
607 +}
608 +
609 +static void pcf50633_work(struct work_struct *work)
610 +{
611 + struct pcf50633_data *pcf =
612 + container_of(work, struct pcf50633_data, work);
613 + u_int8_t pcfirq[5];
614 + int ret;
615 + int tail;
616 +
617 + mutex_lock(&pcf->working_lock);
618 + pcf->working = 1;
619 + /*
620 + * datasheet says we have to read the five IRQ
621 + * status regs in one transaction
622 + */
623 + ret = i2c_smbus_read_i2c_block_data(&pcf->client, PCF50633_REG_INT1, 5,
624 + pcfirq);
625 + if (ret != 5)
626 + DEBUGP("Oh crap PMU IRQ register read failed %d\n", ret);
627 +
628 + if (!pcf->coldplug_done) {
629 + DEBUGP("PMU Coldplug init\n");
630 +
631 + /* we used SECOND to kick ourselves started -- turn it off */
632 + pcfirq[0] &= ~PCF50633_INT1_SECOND;
633 + reg_set_bit_mask(pcf, PCF50633_REG_INT1M,
634 + PCF50633_INT1_SECOND,
635 + PCF50633_INT1_SECOND);
636 +
637 + /* coldplug the USB if present */
638 + if ((__reg_read(pcf, PCF50633_REG_MBCS1) &
639 + (PCF50633_MBCS1_USBPRES | PCF50633_MBCS1_USBOK)) ==
640 + (PCF50633_MBCS1_USBPRES | PCF50633_MBCS1_USBOK)) {
641 + DEBUGPC("COLD USBINS\n");
642 + input_report_key(pcf->input_dev, KEY_POWER2, 1);
643 + apm_queue_event(APM_POWER_STATUS_CHANGE);
644 + pcf->flags |= PCF50633_F_USB_PRESENT;
645 + if (pcf->pdata->cb)
646 + pcf->pdata->cb(&pcf->client.dev,
647 + PCF50633_FEAT_MBC, PMU_EVT_USB_INSERT);
648 + }
649 +
650 + /* figure out our initial charging stance */
651 + add_request_to_adc_queue(pcf, PCF50633_ADCC1_MUX_ADCIN1,
652 + PCF50633_ADCC1_AVERAGE_16);
653 +
654 + pcf->coldplug_done = 1;
655 + }
656 +
657 + DEBUGP("INT1=0x%02x INT2=0x%02x INT3=0x%02x INT4=0x%02x INT5=0x%02x\n",
658 + pcfirq[0], pcfirq[1], pcfirq[2], pcfirq[3], pcfirq[4]);
659 +
660 + if (pcfirq[0] & PCF50633_INT1_ADPINS) {
661 + /* Charger inserted */
662 + DEBUGPC("ADPINS ");
663 + input_report_key(pcf->input_dev, KEY_BATTERY, 1);
664 + apm_queue_event(APM_POWER_STATUS_CHANGE);
665 + pcf->flags |= PCF50633_F_CHG_PRESENT;
666 + if (pcf->pdata->cb)
667 + pcf->pdata->cb(&pcf->client.dev,
668 + PCF50633_FEAT_MBC, PMU_EVT_INSERT);
669 + /* FIXME: signal this to userspace */
670 + //kobject_uevent( ,KOBJ_ADD);
671 + }
672 + if (pcfirq[0] & PCF50633_INT1_ADPREM) {
673 + /* Charger removed */
674 + DEBUGPC("ADPREM ");
675 + input_report_key(pcf->input_dev, KEY_BATTERY, 0);
676 + apm_queue_event(APM_POWER_STATUS_CHANGE);
677 + pcf->flags &= ~PCF50633_F_CHG_PRESENT;
678 + if (pcf->pdata->cb)
679 + pcf->pdata->cb(&pcf->client.dev,
680 + PCF50633_FEAT_MBC, PMU_EVT_REMOVE);
681 + /* FIXME: signal this to userspace */
682 + //kobject_uevent( ,KOBJ_ADD);
683 + }
684 + if (pcfirq[0] & PCF50633_INT1_USBINS) {
685 + DEBUGPC("USBINS ");
686 + input_report_key(pcf->input_dev, KEY_POWER2, 1);
687 + apm_queue_event(APM_POWER_STATUS_CHANGE);
688 + pcf->flags |= PCF50633_F_USB_PRESENT;
689 + if (pcf->pdata->cb)
690 + pcf->pdata->cb(&pcf->client.dev,
691 + PCF50633_FEAT_MBC, PMU_EVT_USB_INSERT);
692 + /* completion irq will figure out our charging stance */
693 + add_request_to_adc_queue(pcf, PCF50633_ADCC1_MUX_ADCIN1,
694 + PCF50633_ADCC1_AVERAGE_16);
695 + }
696 + if (pcfirq[0] & PCF50633_INT1_USBREM) {
697 + DEBUGPC("USBREM ");
698 + /* only deal if we had understood it was in */
699 + if (pcf->flags & PCF50633_F_USB_PRESENT) {
700 + input_report_key(pcf->input_dev, KEY_POWER2, 0);
701 + apm_queue_event(APM_POWER_STATUS_CHANGE);
702 + pcf->flags &= ~PCF50633_F_USB_PRESENT;
703 + if (pcf->pdata->cb)
704 + pcf->pdata->cb(&pcf->client.dev,
705 + PCF50633_FEAT_MBC, PMU_EVT_USB_REMOVE);
706 + /* completion irq will figure out our charging stance */
707 + add_request_to_adc_queue(pcf, PCF50633_ADCC1_MUX_ADCIN1,
708 + PCF50633_ADCC1_AVERAGE_16);
709 + }
710 + }
711 + if (pcfirq[0] & PCF50633_INT1_ALARM) {
712 + DEBUGPC("ALARM ");
713 + if (pcf->pdata->used_features & PCF50633_FEAT_RTC)
714 + rtc_update_irq(pcf->rtc, 1, RTC_AF | RTC_IRQF);
715 + }
716 + if (pcfirq[0] & PCF50633_INT1_SECOND) {
717 + DEBUGPC("SECOND ");
718 + if (pcf->flags & PCF50633_F_RTC_SECOND)
719 + rtc_update_irq(pcf->rtc, 1, RTC_PF | RTC_IRQF);
720 +
721 + if (pcf->onkey_seconds >= 0 &&
722 + pcf->flags & PCF50633_F_PWR_PRESSED) {
723 + DEBUGP("ONKEY_SECONDS(%u, OOCSTAT=0x%02x) ",
724 + pcf->onkey_seconds,
725 + reg_read(pcf, PCF50633_REG_OOCSTAT));
726 + pcf->onkey_seconds++;
727 + if (pcf->onkey_seconds >=
728 + pcf->pdata->onkey_seconds_sig_init) {
729 + /* Ask init to do 'ctrlaltdel' */
730 + DEBUGPC("SIGINT(init) ");
731 + kill_proc(1, SIGINT, 1);
732 + /* FIXME: what if userspace doesn't shut down? */
733 + }
734 + if (pcf->onkey_seconds >=
735 + pcf->pdata->onkey_seconds_shutdown) {
736 + DEBUGPC("Power Off ");
737 + pcf50633_go_standby();
738 + }
739 + }
740 + }
741 +
742 + if (pcfirq[1] & PCF50633_INT2_ONKEYF) {
743 + /* ONKEY falling edge (start of button press) */
744 + DEBUGPC("ONKEYF ");
745 + pcf->flags |= PCF50633_F_PWR_PRESSED;
746 + input_report_key(pcf->input_dev, KEY_POWER, 1);
747 + }
748 + if (pcfirq[1] & PCF50633_INT2_ONKEYR) {
749 + /* ONKEY rising edge (end of button press) */
750 + DEBUGPC("ONKEYR ");
751 + pcf->flags &= ~PCF50633_F_PWR_PRESSED;
752 + pcf->onkey_seconds = -1;
753 + input_report_key(pcf->input_dev, KEY_POWER, 0);
754 + /* disable SECOND interrupt in case RTC didn't
755 + * request it */
756 + if (!(pcf->flags & PCF50633_F_RTC_SECOND))
757 + reg_set_bit_mask(pcf, PCF50633_REG_INT1M,
758 + PCF50633_INT1_SECOND,
759 + PCF50633_INT1_SECOND);
760 + }
761 + /* FIXME: we don't use EXTON1/2/3. thats why we skip it */
762 +
763 + if (pcfirq[2] & PCF50633_INT3_BATFULL) {
764 + DEBUGPC("BATFULL ");
765 + /* FIXME: signal this to userspace */
766 + }
767 + if (pcfirq[2] & PCF50633_INT3_CHGHALT) {
768 + DEBUGPC("CHGHALT ");
769 + /*
770 + * this is really "battery not pulling current" -- it can
771 + * appear with no battery attached
772 + */
773 + /* FIXME: signal this to userspace */
774 + }
775 + if (pcfirq[2] & PCF50633_INT3_THLIMON) {
776 + DEBUGPC("THLIMON ");
777 + pcf->flags |= PCF50633_F_CHG_PROT;
778 + /* FIXME: signal this to userspace */
779 + }
780 + if (pcfirq[2] & PCF50633_INT3_THLIMOFF) {
781 + DEBUGPC("THLIMOFF ");
782 + pcf->flags &= ~PCF50633_F_CHG_PROT;
783 + /* FIXME: signal this to userspace */
784 + }
785 + if (pcfirq[2] & PCF50633_INT3_USBLIMON) {
786 + DEBUGPC("USBLIMON ");
787 + /* FIXME: signal this to userspace */
788 + }
789 + if (pcfirq[2] & PCF50633_INT3_USBLIMOFF) {
790 + DEBUGPC("USBLIMOFF ");
791 + /* FIXME: signal this to userspace */
792 + }
793 + if (pcfirq[2] & PCF50633_INT3_ADCRDY) {
794 + /* ADC result ready */
795 + DEBUGPC("ADCRDY ");
796 + tail = pcf->adc_queue_tail;
797 + pcf->adc_queue_tail = (pcf->adc_queue_tail + 1) &
798 + (MAX_ADC_FIFO_DEPTH - 1);
799 +
800 + switch (pcf->adc_queue_mux[tail]) {
801 + case PCF50633_ADCC1_MUX_BATSNS_RES: /* battery voltage */
802 + pcf->flag_bat_voltage_read =
803 + async_adc_complete(pcf);
804 + break;
805 + case PCF50633_ADCC1_MUX_ADCIN1: /* charger type */
806 + pcf->charger_adc_result_raw = async_adc_complete(pcf);
807 + pcf->charger_type = interpret_charger_type_from_adc(
808 + pcf, pcf->charger_adc_result_raw);
809 + configure_pmu_for_charger(pcf, pcf->charger_type);
810 + break;
811 + default:
812 + async_adc_complete(pcf);
813 + break;
814 + }
815 + trigger_next_adc_job_if_any(pcf);
816 + }
817 + if (pcfirq[2] & PCF50633_INT3_ONKEY1S) {
818 + /* ONKEY pressed for more than 1 second */
819 + pcf->onkey_seconds = 0;
820 + DEBUGPC("ONKEY1S ");
821 + /* Tell PMU we are taking care of this */
822 + reg_set_bit_mask(pcf, PCF50633_REG_OOCSHDWN,
823 + PCF50633_OOCSHDWN_TOTRST,
824 + PCF50633_OOCSHDWN_TOTRST);
825 + /* enable SECOND interrupt (hz tick) */
826 + reg_clear_bits(pcf, PCF50633_REG_INT1M, PCF50633_INT1_SECOND);
827 + }
828 +
829 + if (pcfirq[3] & (PCF50633_INT4_LOWBAT|PCF50633_INT4_LOWSYS)) {
830 + /* Really low battery voltage, we have 8 seconds left */
831 + DEBUGPC("LOWBAT ");
832 + apm_queue_event(APM_LOW_BATTERY);
833 + DEBUGPC("SIGPWR(init) ");
834 + kill_proc(1, SIGPWR, 1);
835 + /* Tell PMU we are taking care of this */
836 + reg_set_bit_mask(pcf, PCF50633_REG_OOCSHDWN,
837 + PCF50633_OOCSHDWN_TOTRST,
838 + PCF50633_OOCSHDWN_TOTRST);
839 + }
840 + if (pcfirq[3] & PCF50633_INT4_HIGHTMP) {
841 + /* High temperature */
842 + DEBUGPC("HIGHTMP ");
843 + apm_queue_event(APM_CRITICAL_SUSPEND);
844 + }
845 + if (pcfirq[3] & PCF50633_INT4_AUTOPWRFAIL) {
846 + DEBUGPC("PCF50633_INT4_AUTOPWRFAIL ");
847 + /* FIXME: deal with this */
848 + }
849 + if (pcfirq[3] & PCF50633_INT4_DWN1PWRFAIL) {
850 + DEBUGPC("PCF50633_INT4_DWN1PWRFAIL ");
851 + /* FIXME: deal with this */
852 + }
853 + if (pcfirq[3] & PCF50633_INT4_DWN2PWRFAIL) {
854 + DEBUGPC("PCF50633_INT4_DWN2PWRFAIL ");
855 + /* FIXME: deal with this */
856 + }
857 + if (pcfirq[3] & PCF50633_INT4_LEDPWRFAIL) {
858 + DEBUGPC("PCF50633_INT4_LEDPWRFAIL ");
859 + /* FIXME: deal with this */
860 + }
861 + if (pcfirq[3] & PCF50633_INT4_LEDOVP) {
862 + DEBUGPC("PCF50633_INT4_LEDOVP ");
863 + /* FIXME: deal with this */
864 + }
865 +
866 + DEBUGPC("\n");
867 +
868 + pcf->working = 0;
869 + input_sync(pcf->input_dev);
870 + put_device(&pcf->client.dev);
871 + mutex_unlock(&pcf->working_lock);
872 +}
873 +
874 +static irqreturn_t pcf50633_irq(int irq, void *_pcf)
875 +{
876 + struct pcf50633_data *pcf = _pcf;
877 +
878 + DEBUGP("entering(irq=%u, pcf=%p): scheduling work\n", irq, _pcf);
879 +
880 + get_device(&pcf->client.dev);
881 + if (!schedule_work(&pcf->work) && !pcf->working)
882 + dev_dbg(&pcf->client.dev, "work item may be lost\n");
883 +
884 + return IRQ_HANDLED;
885 +}
886 +
887 +static u_int16_t adc_to_batt_millivolts(u_int16_t adc)
888 +{
889 + u_int16_t mvolts;
890 +
891 + mvolts = (adc * 6000) / 1024;
892 +
893 + return mvolts;
894 +}
895 +
896 +#define BATTVOLT_SCALE_START 2800
897 +#define BATTVOLT_SCALE_END 4200
898 +#define BATTVOLT_SCALE_DIVIDER ((BATTVOLT_SCALE_END - BATTVOLT_SCALE_START)/100)
899 +
900 +static u_int8_t battvolt_scale(u_int16_t battvolt)
901 +{
902 + /* FIXME: this linear scale is completely bogus */
903 + u_int16_t battvolt_relative = battvolt - BATTVOLT_SCALE_START;
904 + unsigned int percent = battvolt_relative / BATTVOLT_SCALE_DIVIDER;
905 +
906 + return percent;
907 +}
908 +
909 +u_int16_t pcf50633_battvolt(struct pcf50633_data *pcf)
910 +{
911 + int count = 10;
912 +
913 + pcf->flag_bat_voltage_read = -1;
914 + add_request_to_adc_queue(pcf, PCF50633_ADCC1_MUX_BATSNS_RES,
915 + PCF50633_ADCC1_AVERAGE_16);
916 +
917 + while ((count--) && (pcf->flag_bat_voltage_read < 0))
918 + msleep(1);
919 +
920 + if (count < 0) { /* timeout somehow */
921 + DEBUGPC("pcf50633_battvolt timeout :-(\n");
922 + return -1;
923 + }
924 +
925 + return adc_to_batt_millivolts(pcf->flag_bat_voltage_read);
926 +}
927 +EXPORT_SYMBOL_GPL(pcf50633_battvolt);
928 +
929 +static ssize_t show_battvolt(struct device *dev, struct device_attribute *attr,
930 + char *buf)
931 +{
932 + struct i2c_client *client = to_i2c_client(dev);
933 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
934 +
935 + return sprintf(buf, "%u\n", pcf50633_battvolt(pcf));
936 +}
937 +static DEVICE_ATTR(battvolt, S_IRUGO | S_IWUSR, show_battvolt, NULL);
938 +
939 +static int reg_id_by_name(const char *name)
940 +{
941 + int reg_id;
942 +
943 + if (!strcmp(name, "voltage_auto"))
944 + reg_id = PCF50633_REGULATOR_AUTO;
945 + else if (!strcmp(name, "voltage_down1"))
946 + reg_id = PCF50633_REGULATOR_DOWN1;
947 + else if (!strcmp(name, "voltage_down2"))
948 + reg_id = PCF50633_REGULATOR_DOWN2;
949 + else if (!strcmp(name, "voltage_memldo"))
950 + reg_id = PCF50633_REGULATOR_MEMLDO;
951 + else if (!strcmp(name, "voltage_ldo1"))
952 + reg_id = PCF50633_REGULATOR_LDO1;
953 + else if (!strcmp(name, "voltage_ldo2"))
954 + reg_id = PCF50633_REGULATOR_LDO2;
955 + else if (!strcmp(name, "voltage_ldo3"))
956 + reg_id = PCF50633_REGULATOR_LDO3;
957 + else if (!strcmp(name, "voltage_ldo4"))
958 + reg_id = PCF50633_REGULATOR_LDO4;
959 + else if (!strcmp(name, "voltage_ldo5"))
960 + reg_id = PCF50633_REGULATOR_LDO5;
961 + else if (!strcmp(name, "voltage_ldo6"))
962 + reg_id = PCF50633_REGULATOR_LDO6;
963 + else if (!strcmp(name, "voltage_hcldo"))
964 + reg_id = PCF50633_REGULATOR_HCLDO;
965 + else
966 + reg_id = -1;
967 +
968 + return reg_id;
969 +}
970 +
971 +static ssize_t show_vreg(struct device *dev, struct device_attribute *attr,
972 + char *buf)
973 +{
974 + struct i2c_client *client = to_i2c_client(dev);
975 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
976 + unsigned int reg_id;
977 +
978 + reg_id = reg_id_by_name(attr->attr.name);
979 + if (reg_id < 0)
980 + return 0;
981 +
982 + if (pcf50633_onoff_get(pcf, reg_id) > 0)
983 + return sprintf(buf, "%u\n", pcf50633_voltage_get(pcf, reg_id));
984 + else
985 + return strlcpy(buf, "0\n", PAGE_SIZE);
986 +}
987 +
988 +static ssize_t set_vreg(struct device *dev, struct device_attribute *attr,
989 + const char *buf, size_t count)
990 +{
991 + struct i2c_client *client = to_i2c_client(dev);
992 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
993 + unsigned long mvolts = simple_strtoul(buf, NULL, 10);
994 + unsigned int reg_id;
995 +
996 + reg_id = reg_id_by_name(attr->attr.name);
997 + if (reg_id < 0)
998 + return -EIO;
999 +
1000 + DEBUGP("attempting to set %s(%d) to %lu mvolts\n", attr->attr.name,
1001 + reg_id, mvolts);
1002 +
1003 + if (mvolts == 0) {
1004 + pcf50633_onoff_set(pcf, reg_id, 0);
1005 + } else {
1006 + if (pcf50633_voltage_set(pcf, reg_id, mvolts) < 0) {
1007 + dev_warn(dev, "refusing to set %s(%d) to %lu mvolts "
1008 + "(max=%u)\n", attr->attr.name, reg_id, mvolts,
1009 + pcf->pdata->rails[reg_id].voltage.max);
1010 + return -EINVAL;
1011 + }
1012 + pcf50633_onoff_set(pcf, reg_id, 1);
1013 + }
1014 +
1015 + return count;
1016 +}
1017 +
1018 +static DEVICE_ATTR(voltage_auto, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
1019 +static DEVICE_ATTR(voltage_down1, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
1020 +static DEVICE_ATTR(voltage_down2, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
1021 +static DEVICE_ATTR(voltage_memldo, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
1022 +static DEVICE_ATTR(voltage_ldo1, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
1023 +static DEVICE_ATTR(voltage_ldo2, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
1024 +static DEVICE_ATTR(voltage_ldo3, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
1025 +static DEVICE_ATTR(voltage_ldo4, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
1026 +static DEVICE_ATTR(voltage_ldo5, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
1027 +static DEVICE_ATTR(voltage_ldo6, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
1028 +static DEVICE_ATTR(voltage_hcldo, S_IRUGO | S_IWUSR, show_vreg, set_vreg);
1029 +
1030 +/***********************************************************************
1031 + * Charger Control
1032 + ***********************************************************************/
1033 +
1034 +/* Set maximum USB current limit */
1035 +void pcf50633_usb_curlim_set(struct pcf50633_data *pcf, int ma)
1036 +{
1037 + u_int8_t bits;
1038 +
1039 + dev_dbg(&pcf->client.dev, "setting usb current limit to %d ma", ma);
1040 +
1041 + if (ma >= 1000)
1042 + bits = PCF50633_MBCC7_USB_1000mA;
1043 + else if (ma >= 500)
1044 + bits = PCF50633_MBCC7_USB_500mA;
1045 + else if (ma >= 100)
1046 + bits = PCF50633_MBCC7_USB_100mA;
1047 + else
1048 + bits = PCF50633_MBCC7_USB_SUSPEND;
1049 +
1050 + reg_set_bit_mask(pcf, PCF50633_REG_MBCC7, PCF56033_MBCC7_USB_MASK,
1051 + bits);
1052 +}
1053 +EXPORT_SYMBOL_GPL(pcf50633_usb_curlim_set);
1054 +
1055 +static ssize_t show_usblim(struct device *dev, struct device_attribute *attr,
1056 + char *buf)
1057 +{
1058 + struct i2c_client *client = to_i2c_client(dev);
1059 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1060 + u_int8_t usblim = reg_read(pcf, PCF50633_REG_MBCC7) &
1061 + PCF56033_MBCC7_USB_MASK;
1062 + unsigned int ma;
1063 +
1064 + if (usblim == PCF50633_MBCC7_USB_1000mA)
1065 + ma = 1000;
1066 + else if (usblim == PCF50633_MBCC7_USB_500mA)
1067 + ma = 500;
1068 + else if (usblim == PCF50633_MBCC7_USB_100mA)
1069 + ma = 100;
1070 + else
1071 + ma = 0;
1072 +
1073 + return sprintf(buf, "%u\n", ma);
1074 +}
1075 +static DEVICE_ATTR(usb_curlim, S_IRUGO | S_IWUSR, show_usblim, NULL);
1076 +
1077 +/* Enable/disable charging */
1078 +void pcf50633_charge_enable(struct pcf50633_data *pcf, int on)
1079 +{
1080 + u_int8_t bits;
1081 +
1082 + if (!(pcf->pdata->used_features & PCF50633_FEAT_MBC))
1083 + return;
1084 +
1085 + if (on) {
1086 + pcf->flags |= PCF50633_F_CHG_ENABLED;
1087 + bits = PCF50633_MBCC1_CHGENA;
1088 + } else {
1089 + pcf->flags &= ~PCF50633_F_CHG_ENABLED;
1090 + bits = 0;
1091 + }
1092 + reg_set_bit_mask(pcf, PCF50633_REG_MBCC1, PCF50633_MBCC1_CHGENA,
1093 + bits);
1094 +}
1095 +EXPORT_SYMBOL_GPL(pcf50633_charge_enable);
1096 +
1097 +#if 0
1098 +#define ONE 1000000
1099 +static u_int16_t adc_to_rntc(struct pcf50633_data *pcf, u_int16_t adc)
1100 +{
1101 + u_int32_t r_batt = (adc * pcf->pdata->r_fix_batt) / (1023 - adc);
1102 + u_int16_t r_ntc;
1103 +
1104 + /* The battery NTC has a parallell 10kOhms resistor */
1105 + r_ntc = ONE / ((ONE/r_batt) - (ONE/pcf->pdata->r_fix_batt_par));
1106 +
1107 + return r_ntc;
1108 +}
1109 +#endif
1110 +static ssize_t show_battemp(struct device *dev, struct device_attribute *attr,
1111 + char *buf)
1112 +{
1113 + return sprintf(buf, "\n");
1114 +}
1115 +static DEVICE_ATTR(battemp, S_IRUGO | S_IWUSR, show_battemp, NULL);
1116 +#if 0
1117 +static u_int16_t adc_to_chg_milliamps(struct pcf50633_data *pcf,
1118 + u_int16_t adc_adcin1,
1119 + u_int16_t adc_batvolt)
1120 +{
1121 + u_int32_t res = ((adc_adcin1 - adc_batvolt) * 6000);
1122 + return res / (pcf->pdata->r_sense_milli * 1024 / 1000);
1123 +}
1124 +#endif
1125 +static ssize_t show_chgcur(struct device *dev, struct device_attribute *attr,
1126 + char *buf)
1127 +{
1128 + return sprintf(buf, "\n");
1129 +}
1130 +static DEVICE_ATTR(chgcur, S_IRUGO | S_IWUSR, show_chgcur, NULL);
1131 +
1132 +static const char *chgmode_names[] = {
1133 + [PCF50633_MBCS2_MBC_PLAY] = "play-only",
1134 + [PCF50633_MBCS2_MBC_USB_PRE] = "pre",
1135 + [PCF50633_MBCS2_MBC_ADP_PRE] = "pre",
1136 + [PCF50633_MBCS2_MBC_USB_PRE_WAIT] = "pre-wait",
1137 + [PCF50633_MBCS2_MBC_ADP_PRE_WAIT] = "pre-wait",
1138 + [PCF50633_MBCS2_MBC_USB_FAST] = "fast",
1139 + [PCF50633_MBCS2_MBC_ADP_FAST] = "fast",
1140 + [PCF50633_MBCS2_MBC_USB_FAST_WAIT] = "fast-wait",
1141 + [PCF50633_MBCS2_MBC_ADP_FAST_WAIT] = "fast-wait",
1142 + [PCF50633_MBCS2_MBC_ADP_FAST_WAIT] = "bat-full",
1143 +};
1144 +
1145 +static ssize_t show_chgmode(struct device *dev, struct device_attribute *attr,
1146 + char *buf)
1147 +{
1148 + struct i2c_client *client = to_i2c_client(dev);
1149 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1150 + u_int8_t mbcs2 = reg_read(pcf, PCF50633_REG_MBCS2);
1151 + u_int8_t chgmod = (mbcs2 & PCF50633_MBCS2_MBC_MASK);
1152 +
1153 + return sprintf(buf, "%s\n", chgmode_names[chgmod]);
1154 +}
1155 +
1156 +static ssize_t set_chgmode(struct device *dev, struct device_attribute *attr,
1157 + const char *buf, size_t count)
1158 +{
1159 + struct i2c_client *client = to_i2c_client(dev);
1160 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1161 +
1162 + /* As opposed to the PCF50606, we can only enable or disable
1163 + * charging and not directly jump into a certain mode! */
1164 +
1165 + if (!strcmp(buf, "0\n"))
1166 + pcf50633_charge_enable(pcf, 0);
1167 + else
1168 + pcf50633_charge_enable(pcf, 1);
1169 +
1170 + return count;
1171 +}
1172 +
1173 +static DEVICE_ATTR(chgmode, S_IRUGO | S_IWUSR, show_chgmode, set_chgmode);
1174 +
1175 +static const char *chgstate_names[] = {
1176 + [PCF50633_FIDX_CHG_ENABLED] = "enabled",
1177 + [PCF50633_FIDX_CHG_PRESENT] = "charger_present",
1178 + [PCF50633_FIDX_USB_PRESENT] = "usb_present",
1179 + [PCF50633_FIDX_CHG_ERR] = "error",
1180 + [PCF50633_FIDX_CHG_PROT] = "protection",
1181 + [PCF50633_FIDX_CHG_READY] = "ready",
1182 +};
1183 +
1184 +static ssize_t show_chgstate(struct device *dev, struct device_attribute *attr,
1185 + char *buf)
1186 +{
1187 + struct i2c_client *client = to_i2c_client(dev);
1188 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1189 +
1190 + char *b = buf;
1191 + int i;
1192 +
1193 + for (i = 0; i < 32; i++)
1194 + if (pcf->flags & (1 << i) && i < ARRAY_SIZE(chgstate_names))
1195 + b += sprintf(b, "%s ", chgstate_names[i]);
1196 +
1197 + if (b > buf)
1198 + b += sprintf(b, "\n");
1199 +
1200 + return b - buf;
1201 +}
1202 +static DEVICE_ATTR(chgstate, S_IRUGO | S_IWUSR, show_chgstate, NULL);
1203 +
1204 +/***********************************************************************
1205 + * APM emulation
1206 + ***********************************************************************/
1207 +
1208 +extern void (*apm_get_power_status)(struct apm_power_info *);
1209 +
1210 +static void pcf50633_get_power_status(struct apm_power_info *info)
1211 +{
1212 + struct pcf50633_data *pcf = pcf50633_global;
1213 + u_int8_t chgmod = reg_read(pcf, PCF50633_REG_MBCS2) &
1214 + PCF50633_MBCS2_MBC_MASK;
1215 +
1216 + u_int16_t battvolt = pcf50633_battvolt(pcf);
1217 +
1218 + if (reg_read(pcf, PCF50633_REG_MBCS1) &
1219 + (PCF50633_MBCS1_USBPRES|PCF50633_MBCS1_ADAPTPRES))
1220 + info->ac_line_status = APM_AC_ONLINE;
1221 + else
1222 + info->ac_line_status = APM_AC_OFFLINE;
1223 +
1224 + switch (chgmod) {
1225 + case PCF50633_MBCS2_MBC_PLAY:
1226 + case PCF50633_MBCS2_MBC_USB_PRE:
1227 + case PCF50633_MBCS2_MBC_USB_PRE_WAIT:
1228 + case PCF50633_MBCS2_MBC_USB_FAST_WAIT:
1229 + case PCF50633_MBCS2_MBC_ADP_PRE:
1230 + case PCF50633_MBCS2_MBC_ADP_PRE_WAIT:
1231 + case PCF50633_MBCS2_MBC_ADP_FAST_WAIT:
1232 + case PCF50633_MBCS2_MBC_BAT_FULL:
1233 + case PCF50633_MBCS2_MBC_HALT:
1234 + info->battery_life = battvolt_scale(battvolt);
1235 + break;
1236 + case PCF50633_MBCS2_MBC_USB_FAST:
1237 + case PCF50633_MBCS2_MBC_ADP_FAST:
1238 + info->battery_status = APM_BATTERY_STATUS_CHARGING;
1239 + info->battery_flag = APM_BATTERY_FLAG_CHARGING;
1240 + default:
1241 + break;
1242 + }
1243 +}
1244 +
1245 +/***********************************************************************
1246 + * RTC
1247 + ***********************************************************************/
1248 +
1249 +struct pcf50633_time {
1250 + u_int8_t sec;
1251 + u_int8_t min;
1252 + u_int8_t hour;
1253 + u_int8_t wkday;
1254 + u_int8_t day;
1255 + u_int8_t month;
1256 + u_int8_t year;
1257 +};
1258 +
1259 +static void pcf2rtc_time(struct rtc_time *rtc, struct pcf50633_time *pcf)
1260 +{
1261 + rtc->tm_sec = BCD2BIN(pcf->sec);
1262 + rtc->tm_min = BCD2BIN(pcf->min);
1263 + rtc->tm_hour = BCD2BIN(pcf->hour);
1264 + rtc->tm_wday = BCD2BIN(pcf->wkday);
1265 + rtc->tm_mday = BCD2BIN(pcf->day);
1266 + rtc->tm_mon = BCD2BIN(pcf->month);
1267 + rtc->tm_year = BCD2BIN(pcf->year) + 100;
1268 +}
1269 +
1270 +static void rtc2pcf_time(struct pcf50633_time *pcf, struct rtc_time *rtc)
1271 +{
1272 + pcf->sec = BIN2BCD(rtc->tm_sec);
1273 + pcf->min = BIN2BCD(rtc->tm_min);
1274 + pcf->hour = BIN2BCD(rtc->tm_hour);
1275 + pcf->wkday = BIN2BCD(rtc->tm_wday);
1276 + pcf->day = BIN2BCD(rtc->tm_mday);
1277 + pcf->month = BIN2BCD(rtc->tm_mon);
1278 + pcf->year = BIN2BCD(rtc->tm_year - 100);
1279 +}
1280 +
1281 +static int pcf50633_rtc_ioctl(struct device *dev, unsigned int cmd,
1282 + unsigned long arg)
1283 +{
1284 + struct i2c_client *client = to_i2c_client(dev);
1285 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1286 + switch (cmd) {
1287 + case RTC_PIE_OFF:
1288 + /* disable periodic interrupt (hz tick) */
1289 + pcf->flags &= ~PCF50633_F_RTC_SECOND;
1290 + reg_set_bit_mask(pcf, PCF50633_REG_INT1M,
1291 + PCF50633_INT1_SECOND, PCF50633_INT1_SECOND);
1292 + return 0;
1293 + case RTC_PIE_ON:
1294 + /* ensable periodic interrupt (hz tick) */
1295 + pcf->flags |= PCF50633_F_RTC_SECOND;
1296 + reg_clear_bits(pcf, PCF50633_REG_INT1M, PCF50633_INT1_SECOND);
1297 + return 0;
1298 + }
1299 + return -ENOIOCTLCMD;
1300 +}
1301 +
1302 +static int pcf50633_rtc_read_time(struct device *dev, struct rtc_time *tm)
1303 +{
1304 + struct i2c_client *client = to_i2c_client(dev);
1305 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1306 + struct pcf50633_time pcf_tm;
1307 +
1308 + mutex_lock(&pcf->lock);
1309 + pcf_tm.sec = __reg_read(pcf, PCF50633_REG_RTCSC);
1310 + pcf_tm.min = __reg_read(pcf, PCF50633_REG_RTCMN);
1311 + pcf_tm.hour = __reg_read(pcf, PCF50633_REG_RTCHR);
1312 + pcf_tm.wkday = __reg_read(pcf, PCF50633_REG_RTCWD);
1313 + pcf_tm.day = __reg_read(pcf, PCF50633_REG_RTCDT);
1314 + pcf_tm.month = __reg_read(pcf, PCF50633_REG_RTCMT);
1315 + pcf_tm.year = __reg_read(pcf, PCF50633_REG_RTCYR);
1316 + mutex_unlock(&pcf->lock);
1317 +
1318 + DEBUGP("PCF_TIME: %02x.%02x.%02x %02x:%02x:%02x\n",
1319 + pcf_tm.day, pcf_tm.month, pcf_tm.year,
1320 + pcf_tm.hour, pcf_tm.min, pcf_tm.sec);
1321 +
1322 + pcf2rtc_time(tm, &pcf_tm);
1323 +
1324 + DEBUGP("RTC_TIME: %u.%u.%u %u:%u:%u\n",
1325 + tm->tm_mday, tm->tm_mon, tm->tm_year,
1326 + tm->tm_hour, tm->tm_min, tm->tm_sec);
1327 +
1328 + return 0;
1329 +}
1330 +
1331 +static int pcf50633_rtc_set_time(struct device *dev, struct rtc_time *tm)
1332 +{
1333 + struct i2c_client *client = to_i2c_client(dev);
1334 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1335 + struct pcf50633_time pcf_tm;
1336 +
1337 + DEBUGP("RTC_TIME: %u.%u.%u %u:%u:%u\n",
1338 + tm->tm_mday, tm->tm_mon, tm->tm_year,
1339 + tm->tm_hour, tm->tm_min, tm->tm_sec);
1340 + rtc2pcf_time(&pcf_tm, tm);
1341 + DEBUGP("PCF_TIME: %02x.%02x.%02x %02x:%02x:%02x\n",
1342 + pcf_tm.day, pcf_tm.month, pcf_tm.year,
1343 + pcf_tm.hour, pcf_tm.min, pcf_tm.sec);
1344 +
1345 + mutex_lock(&pcf->lock);
1346 + /* FIXME: disable second interrupt */
1347 + __reg_write(pcf, PCF50633_REG_RTCSC, pcf_tm.sec);
1348 + __reg_write(pcf, PCF50633_REG_RTCMN, pcf_tm.min);
1349 + __reg_write(pcf, PCF50633_REG_RTCHR, pcf_tm.hour);
1350 + __reg_write(pcf, PCF50633_REG_RTCWD, pcf_tm.wkday);
1351 + __reg_write(pcf, PCF50633_REG_RTCDT, pcf_tm.day);
1352 + __reg_write(pcf, PCF50633_REG_RTCMT, pcf_tm.month);
1353 + __reg_write(pcf, PCF50633_REG_RTCYR, pcf_tm.year);
1354 + /* FIXME: re-enable second interrupt */
1355 + mutex_unlock(&pcf->lock);
1356 +
1357 + return 0;
1358 +}
1359 +
1360 +static int pcf50633_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
1361 +{
1362 + struct i2c_client *client = to_i2c_client(dev);
1363 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1364 + struct pcf50633_time pcf_tm;
1365 +
1366 + mutex_lock(&pcf->lock);
1367 + alrm->enabled =
1368 + __reg_read(pcf, PCF50633_REG_INT1M) & PCF50633_INT1_ALARM ? 0 : 1;
1369 + pcf_tm.sec = __reg_read(pcf, PCF50633_REG_RTCSCA);
1370 + pcf_tm.min = __reg_read(pcf, PCF50633_REG_RTCMNA);
1371 + pcf_tm.hour = __reg_read(pcf, PCF50633_REG_RTCHRA);
1372 + pcf_tm.wkday = __reg_read(pcf, PCF50633_REG_RTCWDA);
1373 + pcf_tm.day = __reg_read(pcf, PCF50633_REG_RTCDTA);
1374 + pcf_tm.month = __reg_read(pcf, PCF50633_REG_RTCMTA);
1375 + pcf_tm.year = __reg_read(pcf, PCF50633_REG_RTCYRA);
1376 + mutex_unlock(&pcf->lock);
1377 +
1378 + pcf2rtc_time(&alrm->time, &pcf_tm);
1379 +
1380 + return 0;
1381 +}
1382 +
1383 +static int pcf50633_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
1384 +{
1385 + struct i2c_client *client = to_i2c_client(dev);
1386 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1387 + struct pcf50633_time pcf_tm;
1388 + u_int8_t irqmask;
1389 +
1390 + rtc2pcf_time(&pcf_tm, &alrm->time);
1391 +
1392 + mutex_lock(&pcf->lock);
1393 +
1394 + /* disable alarm interrupt */
1395 + irqmask = __reg_read(pcf, PCF50633_REG_INT1M);
1396 + irqmask |= PCF50633_INT1_ALARM;
1397 + __reg_write(pcf, PCF50633_REG_INT1M, irqmask);
1398 +
1399 + __reg_write(pcf, PCF50633_REG_RTCSCA, pcf_tm.sec);
1400 + __reg_write(pcf, PCF50633_REG_RTCMNA, pcf_tm.min);
1401 + __reg_write(pcf, PCF50633_REG_RTCHRA, pcf_tm.hour);
1402 + __reg_write(pcf, PCF50633_REG_RTCWDA, pcf_tm.wkday);
1403 + __reg_write(pcf, PCF50633_REG_RTCDTA, pcf_tm.day);
1404 + __reg_write(pcf, PCF50633_REG_RTCMTA, pcf_tm.month);
1405 + __reg_write(pcf, PCF50633_REG_RTCYRA, pcf_tm.year);
1406 +
1407 + if (alrm->enabled) {
1408 + /* (re-)enaable alarm interrupt */
1409 + irqmask = __reg_read(pcf, PCF50633_REG_INT1M);
1410 + irqmask &= ~PCF50633_INT1_ALARM;
1411 + __reg_write(pcf, PCF50633_REG_INT1M, irqmask);
1412 + }
1413 +
1414 + mutex_unlock(&pcf->lock);
1415 +
1416 + /* FIXME */
1417 + return 0;
1418 +}
1419 +
1420 +static struct rtc_class_ops pcf50633_rtc_ops = {
1421 + .ioctl = pcf50633_rtc_ioctl,
1422 + .read_time = pcf50633_rtc_read_time,
1423 + .set_time = pcf50633_rtc_set_time,
1424 + .read_alarm = pcf50633_rtc_read_alarm,
1425 + .set_alarm = pcf50633_rtc_set_alarm,
1426 +};
1427 +
1428 +/***********************************************************************
1429 + * Backlight device
1430 + ***********************************************************************/
1431 +
1432 +static int pcf50633bl_get_intensity(struct backlight_device *bd)
1433 +{
1434 + struct pcf50633_data *pcf = bl_get_data(bd);
1435 + int intensity = reg_read(pcf, PCF50633_REG_LEDOUT);
1436 +
1437 + return intensity & 0x3f;
1438 +}
1439 +
1440 +static int pcf50633bl_set_intensity(struct backlight_device *bd)
1441 +{
1442 + struct pcf50633_data *pcf = bl_get_data(bd);
1443 + int intensity = bd->props.brightness;
1444 + int old_intensity = reg_read(pcf, PCF50633_REG_LEDOUT);
1445 + u_int8_t ledena;
1446 + int ret;
1447 +
1448 + if (bd->props.power != FB_BLANK_UNBLANK)
1449 + intensity = 0;
1450 + if (bd->props.fb_blank != FB_BLANK_UNBLANK)
1451 + intensity = 0;
1452 +
1453 + /* The PCF50633 seems to have some kind of oddity (bug?) when
1454 + * the intensity was 0, you need to completely switch it off
1455 + * and re-enable it, before it produces any output voltage again */
1456 +
1457 + if (intensity != 0 && old_intensity == 0) {
1458 + ledena = reg_read(pcf, PCF50633_REG_LEDENA);
1459 + reg_write(pcf, PCF50633_REG_LEDENA, 0x00);
1460 + }
1461 +
1462 + ret = reg_set_bit_mask(pcf, PCF50633_REG_LEDOUT, 0x3f,
1463 + intensity);
1464 +
1465 + if (intensity != 0 && old_intensity == 0)
1466 + reg_write(pcf, PCF50633_REG_LEDENA, ledena);
1467 +
1468 + return ret;
1469 +}
1470 +
1471 +static struct backlight_ops pcf50633bl_ops = {
1472 + .get_brightness = pcf50633bl_get_intensity,
1473 + .update_status = pcf50633bl_set_intensity,
1474 +};
1475 +
1476 +/*
1477 + * Charger type
1478 + */
1479 +
1480 +static ssize_t show_charger_type(struct device *dev,
1481 + struct device_attribute *attr, char *buf)
1482 +{
1483 + struct i2c_client *client = to_i2c_client(dev);
1484 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1485 + static const char *names_charger_type[] = {
1486 + [CHARGER_TYPE_NONE] = "none",
1487 + [CHARGER_TYPE_HOSTUSB] = "host/500mA usb",
1488 + [CHARGER_TYPE_1A] = "charger 1A",
1489 + };
1490 + static const char *names_charger_modes[] = {
1491 + [PCF50633_MBCC7_USB_1000mA] = "1A",
1492 + [PCF50633_MBCC7_USB_500mA] = "500mA",
1493 + [PCF50633_MBCC7_USB_100mA] = "100mA",
1494 + [PCF50633_MBCC7_USB_SUSPEND] = "suspend",
1495 + };
1496 + int mode = reg_read(pcf, PCF50633_REG_MBCC7) & PCF56033_MBCC7_USB_MASK;
1497 +
1498 + return sprintf(buf, "%s mode %s\n",
1499 + names_charger_type[pcf->charger_type],
1500 + names_charger_modes[mode]);
1501 +}
1502 +
1503 +static DEVICE_ATTR(charger_type, 0444, show_charger_type, NULL);
1504 +
1505 +/*
1506 + * Charger adc
1507 + */
1508 +
1509 +static ssize_t show_charger_adc(struct device *dev,
1510 + struct device_attribute *attr, char *buf)
1511 +{
1512 + struct i2c_client *client = to_i2c_client(dev);
1513 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1514 +
1515 + return sprintf(buf, "%d\n", pcf->charger_adc_result_raw);
1516 +}
1517 +
1518 +static DEVICE_ATTR(charger_adc, 0444, show_charger_adc, NULL);
1519 +
1520 +/*
1521 + * Dump regs
1522 + */
1523 +
1524 +static ssize_t show_dump_regs(struct device *dev, struct device_attribute *attr,
1525 + char *buf)
1526 +{
1527 + struct i2c_client *client = to_i2c_client(dev);
1528 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1529 + u8 dump[16];
1530 + int n, n1, idx = 0;
1531 + char *buf1 = buf;
1532 + static u8 address_no_read[] = { /* must be ascending */
1533 + PCF50633_REG_INT1,
1534 + PCF50633_REG_INT2,
1535 + PCF50633_REG_INT3,
1536 + PCF50633_REG_INT4,
1537 + PCF50633_REG_INT5,
1538 + 0 /* terminator */
1539 + };
1540 +
1541 + for (n = 0; n < 256; n += sizeof(dump)) {
1542 +
1543 + for (n1 = 0; n1 < sizeof(dump); n1++)
1544 + if (n == address_no_read[idx]) {
1545 + idx++;
1546 + dump[n1] = 0x00;
1547 + } else
1548 + dump[n1] = reg_read(pcf, n + n1);
1549 +
1550 + hex_dump_to_buffer(dump, sizeof(dump), 16, 1, buf1, 128, 0);
1551 + buf1 += strlen(buf1);
1552 + *buf1++ = '\n';
1553 + *buf1 = '\0';
1554 + }
1555 +
1556 + return buf1 - buf;
1557 +}
1558 +
1559 +static DEVICE_ATTR(dump_regs, 0400, show_dump_regs, NULL);
1560 +
1561 +
1562 +/***********************************************************************
1563 + * Driver initialization
1564 + ***********************************************************************/
1565 +
1566 +#ifdef CONFIG_MACH_NEO1973_GTA02
1567 +/* We currently place those platform devices here to make sure the device
1568 + * suspend/resume order is correct */
1569 +static struct platform_device gta01_pm_gps_dev = {
1570 + .name = "neo1973-pm-gps",
1571 +};
1572 +
1573 +static struct platform_device gta01_pm_bt_dev = {
1574 + .name = "neo1973-pm-bt",
1575 +};
1576 +#endif
1577 +
1578 +/*
1579 + * CARE! This table is modified at runtime!
1580 + */
1581 +static struct attribute *pcf_sysfs_entries[] = {
1582 + &dev_attr_voltage_auto.attr,
1583 + &dev_attr_voltage_down1.attr,
1584 + &dev_attr_voltage_down2.attr,
1585 + &dev_attr_voltage_memldo.attr,
1586 + &dev_attr_voltage_ldo1.attr,
1587 + &dev_attr_voltage_ldo2.attr,
1588 + &dev_attr_voltage_ldo3.attr,
1589 + &dev_attr_voltage_ldo4.attr,
1590 + &dev_attr_voltage_ldo5.attr,
1591 + &dev_attr_voltage_ldo6.attr,
1592 + &dev_attr_voltage_hcldo.attr,
1593 + &dev_attr_charger_type.attr,
1594 + &dev_attr_charger_adc.attr,
1595 + &dev_attr_dump_regs.attr,
1596 + NULL, /* going to add things at this point! */
1597 + NULL,
1598 + NULL,
1599 + NULL,
1600 + NULL,
1601 + NULL,
1602 + NULL,
1603 +};
1604 +
1605 +static struct attribute_group pcf_attr_group = {
1606 + .name = NULL, /* put in device directory */
1607 + .attrs = pcf_sysfs_entries,
1608 +};
1609 +
1610 +static void populate_sysfs_group(struct pcf50633_data *pcf)
1611 +{
1612 + int i = 0;
1613 + struct attribute **attr;
1614 +
1615 + for (attr = pcf_sysfs_entries; *attr; attr++)
1616 + i++;
1617 +
1618 + if (pcf->pdata->used_features & PCF50633_FEAT_MBC) {
1619 + pcf_sysfs_entries[i++] = &dev_attr_chgstate.attr;
1620 + pcf_sysfs_entries[i++] = &dev_attr_chgmode.attr;
1621 + pcf_sysfs_entries[i++] = &dev_attr_usb_curlim.attr;
1622 + }
1623 +
1624 + if (pcf->pdata->used_features & PCF50633_FEAT_CHGCUR)
1625 + pcf_sysfs_entries[i++] = &dev_attr_chgcur.attr;
1626 +
1627 + if (pcf->pdata->used_features & PCF50633_FEAT_BATVOLT)
1628 + pcf_sysfs_entries[i++] = &dev_attr_battvolt.attr;
1629 +
1630 + if (pcf->pdata->used_features & PCF50633_FEAT_BATTEMP)
1631 + pcf_sysfs_entries[i++] = &dev_attr_battemp.attr;
1632 +
1633 +}
1634 +
1635 +static int pcf50633_detect(struct i2c_adapter *adapter, int address, int kind)
1636 +{
1637 + struct i2c_client *new_client;
1638 + struct pcf50633_data *data;
1639 + int err = 0;
1640 + int irq;
1641 +
1642 + DEBUGP("entering\n");
1643 + if (!pcf50633_pdev) {
1644 + printk(KERN_ERR "pcf50633: driver needs a platform_device!\n");
1645 + return -EIO;
1646 + }
1647 +
1648 + irq = platform_get_irq(pcf50633_pdev, 0);
1649 + if (irq < 0) {
1650 + dev_err(&pcf50633_pdev->dev, "no irq in platform resources!\n");
1651 + return -EIO;
1652 + }
1653 +
1654 + /* At the moment, we only support one PCF50633 in a system */
1655 + if (pcf50633_global) {
1656 + dev_err(&pcf50633_pdev->dev,
1657 + "currently only one chip supported\n");
1658 + return -EBUSY;
1659 + }
1660 +
1661 + if (!(data = kzalloc(sizeof(*data), GFP_KERNEL)))
1662 + return -ENOMEM;
1663 +
1664 + mutex_init(&data->lock);
1665 + mutex_init(&data->working_lock);
1666 + INIT_WORK(&data->work, pcf50633_work);
1667 + data->irq = irq;
1668 + data->working = 0;
1669 + data->onkey_seconds = -1;
1670 + data->pdata = pcf50633_pdev->dev.platform_data;
1671 +
1672 + new_client = &data->client;
1673 + i2c_set_clientdata(new_client, data);
1674 + new_client->addr = address;
1675 + new_client->adapter = adapter;
1676 + new_client->driver = &pcf50633_driver;
1677 + new_client->flags = 0;
1678 + strlcpy(new_client->name, "pcf50633", I2C_NAME_SIZE);
1679 +
1680 + /* now we try to detect the chip */
1681 +
1682 + /* register with i2c core */
1683 + if ((err = i2c_attach_client(new_client))) {
1684 + dev_err(&new_client->dev,
1685 + "error during i2c_attach_client()\n");
1686 + goto exit_free;
1687 + }
1688 +
1689 + pcf50633_global = data;
1690 +
1691 + populate_sysfs_group(data);
1692 +
1693 + err = sysfs_create_group(&new_client->dev.kobj, &pcf_attr_group);
1694 + if (err) {
1695 + dev_err(&new_client->dev, "error creating sysfs group\n");
1696 + goto exit_detach;
1697 + }
1698 +
1699 + /* create virtual charger 'device' */
1700 +
1701 + /* register power off handler with core power management */
1702 + pm_power_off = &pcf50633_go_standby;
1703 +
1704 + data->input_dev = input_allocate_device();
1705 + if (!data->input_dev)
1706 + goto exit_sysfs;
1707 +
1708 + data->input_dev->name = "GTA02 PMU events";
1709 + data->input_dev->phys = "FIXME";
1710 + data->input_dev->id.bustype = BUS_I2C;
1711 + data->input_dev->cdev.dev = &new_client->dev;
1712 +
1713 + data->input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_PWR);
1714 + set_bit(KEY_POWER, data->input_dev->keybit);
1715 + set_bit(KEY_POWER2, data->input_dev->keybit);
1716 + set_bit(KEY_BATTERY, data->input_dev->keybit);
1717 +
1718 + err = input_register_device(data->input_dev);
1719 + if (err)
1720 + goto exit_sysfs;
1721 +
1722 + /* configure interrupt mask */
1723 + reg_write(data, PCF50633_REG_INT1M, 0x00); /* we want SECOND to kick */
1724 + reg_write(data, PCF50633_REG_INT2M, 0x00);
1725 + reg_write(data, PCF50633_REG_INT3M, 0x00);
1726 + reg_write(data, PCF50633_REG_INT4M, 0x00);
1727 + reg_write(data, PCF50633_REG_INT5M, 0x00);
1728 +
1729 + err = request_irq(irq, pcf50633_irq, IRQF_TRIGGER_FALLING,
1730 + "pcf50633", data);
1731 + if (err < 0)
1732 + goto exit_input;
1733 +
1734 + if (enable_irq_wake(irq) < 0)
1735 + dev_err(&new_client->dev, "IRQ %u cannot be enabled as wake-up"
1736 + "source in this hardware revision!", irq);
1737 +
1738 + if (data->pdata->used_features & PCF50633_FEAT_RTC) {
1739 + data->rtc = rtc_device_register("pcf50633", &new_client->dev,
1740 + &pcf50633_rtc_ops, THIS_MODULE);
1741 + if (IS_ERR(data->rtc)) {
1742 + err = PTR_ERR(data->rtc);
1743 + goto exit_irq;
1744 + }
1745 + }
1746 +
1747 + if (data->pdata->used_features & PCF50633_FEAT_PWM_BL) {
1748 + data->backlight = backlight_device_register("pcf50633-bl",
1749 + &new_client->dev,
1750 + data,
1751 + &pcf50633bl_ops);
1752 + if (!data->backlight)
1753 + goto exit_rtc;
1754 + /* FIXME: are we sure we want default == off? */
1755 + data->backlight->props.max_brightness = 0x3f;
1756 + data->backlight->props.power = FB_BLANK_UNBLANK;
1757 + data->backlight->props.fb_blank = FB_BLANK_UNBLANK;
1758 + data->backlight->props.brightness =
1759 + data->backlight->props.max_brightness;
1760 + backlight_update_status(data->backlight);
1761 + }
1762 +
1763 + apm_get_power_status = pcf50633_get_power_status;
1764 +
1765 +#ifdef CONFIG_MACH_NEO1973_GTA02
1766 + if (machine_is_neo1973_gta02()) {
1767 + gta01_pm_gps_dev.dev.parent = &new_client->dev;
1768 + gta01_pm_bt_dev.dev.parent = &new_client->dev;
1769 + platform_device_register(&gta01_pm_bt_dev);
1770 + platform_device_register(&gta01_pm_gps_dev);
1771 + }
1772 +#endif
1773 +
1774 + return 0;
1775 +exit_rtc:
1776 + if (data->pdata->used_features & PCF50633_FEAT_RTC)
1777 + rtc_device_unregister(pcf50633_global->rtc);
1778 +exit_irq:
1779 + free_irq(pcf50633_global->irq, pcf50633_global);
1780 +exit_input:
1781 + input_unregister_device(data->input_dev);
1782 +exit_sysfs:
1783 + pm_power_off = NULL;
1784 + sysfs_remove_group(&new_client->dev.kobj, &pcf_attr_group);
1785 +exit_detach:
1786 + i2c_detach_client(new_client);
1787 +exit_free:
1788 + kfree(data);
1789 + pcf50633_global = NULL;
1790 + return err;
1791 +}
1792 +
1793 +static int pcf50633_attach_adapter(struct i2c_adapter *adapter)
1794 +{
1795 + DEBUGP("entering, calling i2c_probe\n");
1796 + return i2c_probe(adapter, &addr_data, &pcf50633_detect);
1797 +}
1798 +
1799 +static int pcf50633_detach_client(struct i2c_client *client)
1800 +{
1801 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1802 +
1803 + DEBUGP("entering\n");
1804 +
1805 + apm_get_power_status = NULL;
1806 +
1807 + free_irq(pcf->irq, pcf);
1808 +
1809 + input_unregister_device(pcf->input_dev);
1810 +
1811 + if (pcf->pdata->used_features & PCF50633_FEAT_PWM_BL)
1812 + backlight_device_unregister(pcf->backlight);
1813 +
1814 + if (pcf->pdata->used_features & PCF50633_FEAT_RTC)
1815 + rtc_device_unregister(pcf->rtc);
1816 +
1817 +#ifdef CONFIG_MACH_NEO1973_GTA02
1818 + if (machine_is_neo1973_gta02()) {
1819 + platform_device_unregister(&gta01_pm_bt_dev);
1820 + platform_device_unregister(&gta01_pm_gps_dev);
1821 + }
1822 +#endif
1823 +
1824 + sysfs_remove_group(&client->dev.kobj, &pcf_attr_group);
1825 +
1826 + pm_power_off = NULL;
1827 +
1828 + kfree(pcf);
1829 +
1830 + return 0;
1831 +}
1832 +
1833 +#ifdef CONFIG_PM
1834 +#define INT1M_RESUMERS (PCF50633_INT1_ADPINS | \
1835 + PCF50633_INT1_ADPREM | \
1836 + PCF50633_INT1_USBINS | \
1837 + PCF50633_INT1_USBREM | \
1838 + PCF50633_INT1_ALARM)
1839 +#define INT2M_RESUMERS (PCF50633_INT2_ONKEYF)
1840 +#define INT3M_RESUMERS (PCF50633_INT3_BATFULL | \
1841 + PCF50633_INT3_CHGHALT | \
1842 + PCF50633_INT3_THLIMON | \
1843 + PCF50633_INT3_THLIMOFF | \
1844 + PCF50633_INT3_USBLIMON | \
1845 + PCF50633_INT3_USBLIMOFF | \
1846 + PCF50633_INT3_ONKEY1S)
1847 +#define INT4M_RESUMERS (PCF50633_INT4_LOWSYS | \
1848 + PCF50633_INT4_LOWBAT | \
1849 + PCF50633_INT4_HIGHTMP)
1850 +#define INT5M_RESUMERS (0)
1851 +
1852 +static int pcf50633_suspend(struct device *dev, pm_message_t state)
1853 +{
1854 + struct i2c_client *client = to_i2c_client(dev);
1855 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1856 + int i;
1857 +
1858 + /* The general idea is to power down all unused power supplies,
1859 + * and then mask all PCF50606 interrup sources but EXTONR, ONKEYF
1860 + * and ALARM */
1861 +
1862 + mutex_lock(&pcf->lock);
1863 +
1864 + /* Save all registers that don't "survive" standby state */
1865 + pcf->standby_regs.ooctim2 = __reg_read(pcf, PCF50633_REG_OOCTIM2);
1866 + pcf->standby_regs.autoout = __reg_read(pcf, PCF50633_REG_AUTOOUT);
1867 + pcf->standby_regs.autoena = __reg_read(pcf, PCF50633_REG_AUTOENA);
1868 + pcf->standby_regs.automxc = __reg_read(pcf, PCF50633_REG_AUTOMXC);
1869 + pcf->standby_regs.down1out = __reg_read(pcf, PCF50633_REG_DOWN1OUT);
1870 + pcf->standby_regs.down1mxc = __reg_read(pcf, PCF50633_REG_DOWN1MXC);
1871 + pcf->standby_regs.down2out = __reg_read(pcf, PCF50633_REG_DOWN2OUT);
1872 + pcf->standby_regs.down2ena = __reg_read(pcf, PCF50633_REG_DOWN2ENA);
1873 + pcf->standby_regs.memldoout = __reg_read(pcf, PCF50633_REG_MEMLDOOUT);
1874 + pcf->standby_regs.memldoena = __reg_read(pcf, PCF50633_REG_MEMLDOENA);
1875 + pcf->standby_regs.ledout = __reg_read(pcf, PCF50633_REG_LEDOUT);
1876 + pcf->standby_regs.ledena = __reg_read(pcf, PCF50633_REG_LEDENA);
1877 + pcf->standby_regs.leddim = __reg_read(pcf, PCF50633_REG_LEDDIM);
1878 + /* FIXME: one big read? */
1879 + for (i = 0; i < 7; i++) {
1880 + u_int8_t reg_out = PCF50633_REG_LDO1OUT + 2*i;
1881 + pcf->standby_regs.ldo[i].out = __reg_read(pcf, reg_out);
1882 + pcf->standby_regs.ldo[i].ena = __reg_read(pcf, reg_out+1);
1883 + }
1884 +
1885 + /* switch off power supplies that are not needed during suspend */
1886 + for (i = 0; i < __NUM_PCF50633_REGULATORS; i++) {
1887 + if (!(pcf->pdata->rails[i].flags & PMU_VRAIL_F_SUSPEND_ON)) {
1888 + u_int8_t tmp;
1889 +
1890 + DEBUGP("disabling pcf50633 regulator %u\n", i);
1891 + /* we cannot use pcf50633_onoff_set() because we're
1892 + * already under the mutex */
1893 + tmp = __reg_read(pcf, regulator_registers[i]+1);
1894 + tmp &= 0xfe;
1895 + __reg_write(pcf, regulator_registers[i]+1, tmp);
1896 + }
1897 + }
1898 +
1899 + pcf->standby_regs.int1m = __reg_read(pcf, PCF50633_REG_INT1M);
1900 + pcf->standby_regs.int2m = __reg_read(pcf, PCF50633_REG_INT2M);
1901 + pcf->standby_regs.int3m = __reg_read(pcf, PCF50633_REG_INT3M);
1902 + pcf->standby_regs.int4m = __reg_read(pcf, PCF50633_REG_INT4M);
1903 + pcf->standby_regs.int5m = __reg_read(pcf, PCF50633_REG_INT5M);
1904 + __reg_write(pcf, PCF50633_REG_INT1M, ~INT1M_RESUMERS & 0xff);
1905 + __reg_write(pcf, PCF50633_REG_INT2M, ~INT2M_RESUMERS & 0xff);
1906 + __reg_write(pcf, PCF50633_REG_INT3M, ~INT3M_RESUMERS & 0xff);
1907 + __reg_write(pcf, PCF50633_REG_INT4M, ~INT4M_RESUMERS & 0xff);
1908 + __reg_write(pcf, PCF50633_REG_INT5M, ~INT5M_RESUMERS & 0xff);
1909 +
1910 + mutex_unlock(&pcf->lock);
1911 +
1912 + return 0;
1913 +}
1914 +
1915 +static int pcf50633_resume(struct device *dev)
1916 +{
1917 + struct i2c_client *client = to_i2c_client(dev);
1918 + struct pcf50633_data *pcf = i2c_get_clientdata(client);
1919 + int i;
1920 +
1921 + mutex_lock(&pcf->lock);
1922 +
1923 + /* Resume all saved registers that don't "survive" standby state */
1924 + __reg_write(pcf, PCF50633_REG_INT1M, pcf->standby_regs.int1m);
1925 + __reg_write(pcf, PCF50633_REG_INT2M, pcf->standby_regs.int2m);
1926 + __reg_write(pcf, PCF50633_REG_INT3M, pcf->standby_regs.int3m);
1927 + __reg_write(pcf, PCF50633_REG_INT4M, pcf->standby_regs.int4m);
1928 + __reg_write(pcf, PCF50633_REG_INT5M, pcf->standby_regs.int5m);
1929 +
1930 + __reg_write(pcf, PCF50633_REG_OOCTIM2, pcf->standby_regs.ooctim2);
1931 + __reg_write(pcf, PCF50633_REG_AUTOOUT, pcf->standby_regs.autoout);
1932 + __reg_write(pcf, PCF50633_REG_AUTOMXC, pcf->standby_regs.automxc);
1933 + __reg_write(pcf, PCF50633_REG_DOWN1OUT, pcf->standby_regs.down1out);
1934 + __reg_write(pcf, PCF50633_REG_DOWN1MXC, pcf->standby_regs.down1mxc);
1935 + __reg_write(pcf, PCF50633_REG_DOWN2OUT, pcf->standby_regs.down2out);
1936 + __reg_write(pcf, PCF50633_REG_DOWN2ENA, pcf->standby_regs.down2ena);
1937 + __reg_write(pcf, PCF50633_REG_MEMLDOOUT, pcf->standby_regs.memldoout);
1938 + __reg_write(pcf, PCF50633_REG_MEMLDOENA, pcf->standby_regs.memldoena);
1939 + __reg_write(pcf, PCF50633_REG_LEDOUT, pcf->standby_regs.ledout);
1940 + __reg_write(pcf, PCF50633_REG_LEDENA, pcf->standby_regs.ledena);
1941 + __reg_write(pcf, PCF50633_REG_LEDDIM, pcf->standby_regs.leddim);
1942 + /* FIXME: one big read? */
1943 + for (i = 0; i < 7; i++) {
1944 + u_int8_t reg_out = PCF50633_REG_LDO1OUT + 2*i;
1945 + __reg_write(pcf, reg_out, pcf->standby_regs.ldo[i].out);
1946 + __reg_write(pcf, reg_out+1, pcf->standby_regs.ldo[i].ena);
1947 + }
1948 +
1949 + mutex_unlock(&pcf->lock);
1950 +
1951 + pcf50633_irq(pcf->irq, pcf);
1952 +
1953 + return 0;
1954 +}
1955 +#else
1956 +#define pcf50633_suspend NULL
1957 +#define pcf50633_resume NULL
1958 +#endif
1959 +
1960 +static struct i2c_driver pcf50633_driver = {
1961 + .driver = {
1962 + .name = "pcf50633",
1963 + .suspend= pcf50633_suspend,
1964 + .resume = pcf50633_resume,
1965 + },
1966 + .id = I2C_DRIVERID_PCF50633,
1967 + .attach_adapter = pcf50633_attach_adapter,
1968 + .detach_client = pcf50633_detach_client,
1969 +};
1970 +
1971 +/* platform driver, since i2c devices don't have platform_data */
1972 +static int __init pcf50633_plat_probe(struct platform_device *pdev)
1973 +{
1974 + struct pcf50633_platform_data *pdata = pdev->dev.platform_data;
1975 +
1976 + if (!pdata)
1977 + return -ENODEV;
1978 +
1979 + pcf50633_pdev = pdev;
1980 +
1981 + return 0;
1982 +}
1983 +
1984 +static int pcf50633_plat_remove(struct platform_device *pdev)
1985 +{
1986 + return 0;
1987 +}
1988 +
1989 +static struct platform_driver pcf50633_plat_driver = {
1990 + .probe = pcf50633_plat_probe,
1991 + .remove = pcf50633_plat_remove,
1992 + .driver = {
1993 + .owner = THIS_MODULE,
1994 + .name = "pcf50633",
1995 + },
1996 +};
1997 +
1998 +static int __init pcf50633_init(void)
1999 +{
2000 + int rc;
2001 +
2002 + if (!(rc = platform_driver_register(&pcf50633_plat_driver)))
2003 + rc = i2c_add_driver(&pcf50633_driver);
2004 +
2005 + return rc;
2006 +}
2007 +
2008 +static void pcf50633_exit(void)
2009 +{
2010 + i2c_del_driver(&pcf50633_driver);
2011 + platform_driver_unregister(&pcf50633_plat_driver);
2012 +}
2013 +
2014 +MODULE_DESCRIPTION("I2C chip driver for NXP PCF50633 power management unit");
2015 +MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");
2016 +MODULE_LICENSE("GPL");
2017 +
2018 +module_init(pcf50633_init);
2019 +module_exit(pcf50633_exit);
2020 diff --git a/drivers/i2c/chips/pcf50633.h b/drivers/i2c/chips/pcf50633.h
2021 new file mode 100644
2022 index 0000000..9aad206
2023 --- /dev/null
2024 +++ b/drivers/i2c/chips/pcf50633.h
2025 @@ -0,0 +1,402 @@
2026 +#ifndef _PCF50633_H
2027 +#define _PCF50633_H
2028 +
2029 +/* Philips PCF50633 Power Managemnt Unit (PMU) driver
2030 + * (C) 2006-2007 by OpenMoko, Inc.
2031 + * Author: Harald Welte <laforge@openmoko.org>
2032 + *
2033 + */
2034 +
2035 +enum pfc50633_regs {
2036 + PCF50633_REG_VERSION = 0x00,
2037 + PCF50633_REG_VARIANT = 0x01,
2038 + PCF50633_REG_INT1 = 0x02, /* Interrupt Status */
2039 + PCF50633_REG_INT2 = 0x03, /* Interrupt Status */
2040 + PCF50633_REG_INT3 = 0x04, /* Interrupt Status */
2041 + PCF50633_REG_INT4 = 0x05, /* Interrupt Status */
2042 + PCF50633_REG_INT5 = 0x06, /* Interrupt Status */
2043 + PCF50633_REG_INT1M = 0x07, /* Interrupt Mask */
2044 + PCF50633_REG_INT2M = 0x08, /* Interrupt Mask */
2045 + PCF50633_REG_INT3M = 0x09, /* Interrupt Mask */
2046 + PCF50633_REG_INT4M = 0x0a, /* Interrupt Mask */
2047 + PCF50633_REG_INT5M = 0x0b, /* Interrupt Mask */
2048 + PCF50633_REG_OOCSHDWN = 0x0c,
2049 + PCF50633_REG_OOCWAKE = 0x0d,
2050 + PCF50633_REG_OOCTIM1 = 0x0e,
2051 + PCF50633_REG_OOCTIM2 = 0x0f,
2052 + PCF50633_REG_OOCMODE = 0x10,
2053 + PCF50633_REG_OOCCTL = 0x11,
2054 + PCF50633_REG_OOCSTAT = 0x12,
2055 + PCF50633_REG_GPIOCTL = 0x13,
2056 + PCF50633_REG_GPIO1CFG = 0x14,
2057 + PCF50633_REG_GPIO2CFG = 0x15,
2058 + PCF50633_REG_GPIO3CFG = 0x16,
2059 + PCF50633_REG_GPOCFG = 0x17,
2060 + PCF50633_REG_BVMCTL = 0x18,
2061 + PCF50633_REG_SVMCTL = 0x19,
2062 + PCF50633_REG_AUTOOUT = 0x1a,
2063 + PCF50633_REG_AUTOENA = 0x1b,
2064 + PCF50633_REG_AUTOCTL = 0x1c,
2065 + PCF50633_REG_AUTOMXC = 0x1d,
2066 + PCF50633_REG_DOWN1OUT = 0x1e,
2067 + PCF50633_REG_DOWN1ENA = 0x1f,
2068 + PCF50633_REG_DOWN1CTL = 0x20,
2069 + PCF50633_REG_DOWN1MXC = 0x21,
2070 + PCF50633_REG_DOWN2OUT = 0x22,
2071 + PCF50633_REG_DOWN2ENA = 0x23,
2072 + PCF50633_REG_DOWN2CTL = 0x24,
2073 + PCF50633_REG_DOWN2MXC = 0x25,
2074 + PCF50633_REG_MEMLDOOUT = 0x26,
2075 + PCF50633_REG_MEMLDOENA = 0x27,
2076 + PCF50633_REG_LEDOUT = 0x28,
2077 + PCF50633_REG_LEDENA = 0x29,
2078 + PCF50633_REG_LEDCTL = 0x2a,
2079 + PCF50633_REG_LEDDIM = 0x2b,
2080 + /* reserved */
2081 + PCF50633_REG_LDO1OUT = 0x2d,
2082 + PCF50633_REG_LDO1ENA = 0x2e,
2083 + PCF50633_REG_LDO2OUT = 0x2f,
2084 + PCF50633_REG_LDO2ENA = 0x30,
2085 + PCF50633_REG_LDO3OUT = 0x31,
2086 + PCF50633_REG_LDO3ENA = 0x32,
2087 + PCF50633_REG_LDO4OUT = 0x33,
2088 + PCF50633_REG_LDO4ENA = 0x34,
2089 + PCF50633_REG_LDO5OUT = 0x35,
2090 + PCF50633_REG_LDO5ENA = 0x36,
2091 + PCF50633_REG_LDO6OUT = 0x37,
2092 + PCF50633_REG_LDO6ENA = 0x38,
2093 + PCF50633_REG_HCLDOOUT = 0x39,
2094 + PCF50633_REG_HCLDOENA = 0x3a,
2095 + PCF50633_REG_STBYCTL1 = 0x3b,
2096 + PCF50633_REG_STBYCTL2 = 0x3c,
2097 + PCF50633_REG_DEBPF1 = 0x3d,
2098 + PCF50633_REG_DEBPF2 = 0x3e,
2099 + PCF50633_REG_DEBPF3 = 0x3f,
2100 + PCF50633_REG_HCLDOOVL = 0x40,
2101 + PCF50633_REG_DCDCSTAT = 0x41,
2102 + PCF50633_REG_LDOSTAT = 0x42,
2103 + PCF50633_REG_MBCC1 = 0x43,
2104 + PCF50633_REG_MBCC2 = 0x44,
2105 + PCF50633_REG_MBCC3 = 0x45,
2106 + PCF50633_REG_MBCC4 = 0x46,
2107 + PCF50633_REG_MBCC5 = 0x47,
2108 + PCF50633_REG_MBCC6 = 0x48,
2109 + PCF50633_REG_MBCC7 = 0x49,
2110 + PCF50633_REG_MBCC8 = 0x4a,
2111 + PCF50633_REG_MBCS1 = 0x4b,
2112 + PCF50633_REG_MBCS2 = 0x4c,
2113 + PCF50633_REG_MBCS3 = 0x4d,
2114 + PCF50633_REG_BBCCTL = 0x4e,
2115 + PCF50633_REG_ALMGAIN = 0x4f,
2116 + PCF50633_REG_ALMDATA = 0x50,
2117 + /* reserved */
2118 + PCF50633_REG_ADCC3 = 0x52,
2119 + PCF50633_REG_ADCC2 = 0x53,
2120 + PCF50633_REG_ADCC1 = 0x54,
2121 + PCF50633_REG_ADCS1 = 0x55,
2122 + PCF50633_REG_ADCS2 = 0x56,
2123 + PCF50633_REG_ADCS3 = 0x57,
2124 + /* reserved */
2125 + PCF50633_REG_RTCSC = 0x59, /* Second */
2126 + PCF50633_REG_RTCMN = 0x5a, /* Minute */
2127 + PCF50633_REG_RTCHR = 0x5b, /* Hour */
2128 + PCF50633_REG_RTCWD = 0x5c, /* Weekday */
2129 + PCF50633_REG_RTCDT = 0x5d, /* Day */
2130 + PCF50633_REG_RTCMT = 0x5e, /* Month */
2131 + PCF50633_REG_RTCYR = 0x5f, /* Year */
2132 + PCF50633_REG_RTCSCA = 0x60, /* Alarm Second */
2133 + PCF50633_REG_RTCMNA = 0x61, /* Alarm Minute */
2134 + PCF50633_REG_RTCHRA = 0x62, /* Alarm Hour */
2135 + PCF50633_REG_RTCWDA = 0x63, /* Alarm Weekday */
2136 + PCF50633_REG_RTCDTA = 0x64, /* Alarm Day */
2137 + PCF50633_REG_RTCMTA = 0x65, /* Alarm Month */
2138 + PCF50633_REG_RTCYRA = 0x66, /* Alarm Year */
2139 +
2140 + PCF50633_REG_MEMBYTE0 = 0x67,
2141 + PCF50633_REG_MEMBYTE1 = 0x68,
2142 + PCF50633_REG_MEMBYTE2 = 0x69,
2143 + PCF50633_REG_MEMBYTE3 = 0x6a,
2144 + PCF50633_REG_MEMBYTE4 = 0x6b,
2145 + PCF50633_REG_MEMBYTE5 = 0x6c,
2146 + PCF50633_REG_MEMBYTE6 = 0x6d,
2147 + PCF50633_REG_MEMBYTE7 = 0x6e,
2148 + /* reserved */
2149 + PCF50633_REG_DCDCPFM = 0x84,
2150 + __NUM_PCF50633_REGS
2151 +};
2152 +
2153 +enum pcf50633_reg_int1 {
2154 + PCF50633_INT1_ADPINS = 0x01, /* Adapter inserted */
2155 + PCF50633_INT1_ADPREM = 0x02, /* Adapter removed */
2156 + PCF50633_INT1_USBINS = 0x04, /* USB inserted */
2157 + PCF50633_INT1_USBREM = 0x08, /* USB removed */
2158 + /* reserved */
2159 + PCF50633_INT1_ALARM = 0x40, /* RTC alarm time is reached */
2160 + PCF50633_INT1_SECOND = 0x80, /* RTC periodic second interrupt */
2161 +};
2162 +
2163 +enum pcf50633_reg_int2 {
2164 + PCF50633_INT2_ONKEYR = 0x01, /* ONKEY rising edge */
2165 + PCF50633_INT2_ONKEYF = 0x02, /* ONKEY falling edge */
2166 + PCF50633_INT2_EXTON1R = 0x04, /* EXTON1 rising edge */
2167 + PCF50633_INT2_EXTON1F = 0x08, /* EXTON1 falling edge */
2168 + PCF50633_INT2_EXTON2R = 0x10, /* EXTON2 rising edge */
2169 + PCF50633_INT2_EXTON2F = 0x20, /* EXTON2 falling edge */
2170 + PCF50633_INT2_EXTON3R = 0x40, /* EXTON3 rising edge */
2171 + PCF50633_INT2_EXTON3F = 0x80, /* EXTON3 falling edge */
2172 +};
2173 +
2174 +enum pcf50633_reg_int3 {
2175 + PCF50633_INT3_BATFULL = 0x01, /* Battery full */
2176 + PCF50633_INT3_CHGHALT = 0x02, /* Charger halt */
2177 + PCF50633_INT3_THLIMON = 0x04,
2178 + PCF50633_INT3_THLIMOFF = 0x08,
2179 + PCF50633_INT3_USBLIMON = 0x10,
2180 + PCF50633_INT3_USBLIMOFF = 0x20,
2181 + PCF50633_INT3_ADCRDY = 0x40, /* ADC conversion finished */
2182 + PCF50633_INT3_ONKEY1S = 0x80, /* ONKEY pressed 1 second */
2183 +};
2184 +
2185 +enum pcf50633_reg_int4 {
2186 + PCF50633_INT4_LOWSYS = 0x01,
2187 + PCF50633_INT4_LOWBAT = 0x02,
2188 + PCF50633_INT4_HIGHTMP = 0x04,
2189 + PCF50633_INT4_AUTOPWRFAIL = 0x08,
2190 + PCF50633_INT4_DWN1PWRFAIL = 0x10,
2191 + PCF50633_INT4_DWN2PWRFAIL = 0x20,
2192 + PCF50633_INT4_LEDPWRFAIL = 0x40,
2193 + PCF50633_INT4_LEDOVP = 0x80,
2194 +};
2195 +
2196 +enum pcf50633_reg_int5 {
2197 + PCF50633_INT5_LDO1PWRFAIL = 0x01,
2198 + PCF50633_INT5_LDO2PWRFAIL = 0x02,
2199 + PCF50633_INT5_LDO3PWRFAIL = 0x04,
2200 + PCF50633_INT5_LDO4PWRFAIL = 0x08,
2201 + PCF50633_INT5_LDO5PWRFAIL = 0x10,
2202 + PCF50633_INT5_LDO6PWRFAIL = 0x20,
2203 + PCF50633_INT5_HCLDOPWRFAIL = 0x40,
2204 + PCF50633_INT5_HCLDOOVL = 0x80,
2205 +};
2206 +
2207 +enum pcf50633_reg_oocshdwn {
2208 + PCF50633_OOCSHDWN_GOSTDBY = 0x01,
2209 + PCF50633_OOCSHDWN_TOTRST = 0x04,
2210 + PCF50633_OOCSHDWN_COLDBOOT = 0x08,
2211 +};
2212 +
2213 +enum pcf50633_reg_oocwake {
2214 + PCF50633_OOCWAKE_ONKEY = 0x01,
2215 + PCF50633_OOCWAKE_EXTON1 = 0x02,
2216 + PCF50633_OOCWAKE_EXTON2 = 0x04,
2217 + PCF50633_OOCWAKE_EXTON3 = 0x08,
2218 + PCF50633_OOCWAKE_RTC = 0x10,
2219 + /* reserved */
2220 + PCF50633_OOCWAKE_USB = 0x40,
2221 + PCF50633_OOCWAKE_ADP = 0x80,
2222 +};
2223 +
2224 +enum pcf50633_reg_mbcc1 {
2225 + PCF50633_MBCC1_CHGENA = 0x01, /* Charger enable */
2226 + PCF50633_MBCC1_AUTOSTOP = 0x02,
2227 + PCF50633_MBCC1_AUTORES = 0x04, /* automatic resume */
2228 + PCF50633_MBCC1_RESUME = 0x08, /* explicit resume cmd */
2229 + PCF50633_MBCC1_RESTART = 0x10, /* restart charging */
2230 + PCF50633_MBCC1_PREWDTIME_60M = 0x20, /* max. precharging time */
2231 + PCF50633_MBCC1_WDTIME_1H = 0x00,
2232 + PCF50633_MBCC1_WDTIME_2H = 0x40,
2233 + PCF50633_MBCC1_WDTIME_4H = 0x80,
2234 + PCF50633_MBCC1_WDTIME_6H = 0xc0,
2235 +};
2236 +#define PCF50633_MBCC1_WDTIME_MASK 0xc0
2237 +
2238 +enum pcf50633_reg_mbcc2 {
2239 + PCF50633_MBCC2_VBATCOND_2V7 = 0x00,
2240 + PCF50633_MBCC2_VBATCOND_2V85 = 0x01,
2241 + PCF50633_MBCC2_VBATCOND_3V0 = 0x02,
2242 + PCF50633_MBCC2_VBATCOND_3V15 = 0x03,
2243 + PCF50633_MBCC2_VMAX_4V = 0x00,
2244 + PCF50633_MBCC2_VMAX_4V20 = 0x28,
2245 + PCF50633_MBCC2_VRESDEBTIME_64S = 0x80, /* debounce time (32/64sec) */
2246 +};
2247 +#define PCF50633_MBCC2_VBATCOND_MASK 0x03
2248 +#define PCF50633_MBCC2_VMAX_MASK 0x3c
2249 +
2250 +enum pcf50633_reg_adcc1 {
2251 + PCF50633_ADCC1_ADCSTART = 0x01,
2252 + PCF50633_ADCC1_RES_10BIT = 0x02,
2253 + PCF50633_ADCC1_AVERAGE_NO = 0x00,
2254 + PCF50633_ADCC1_AVERAGE_4 = 0x04,
2255 + PCF50633_ADCC1_AVERAGE_8 = 0x08,
2256 + PCF50633_ADCC1_AVERAGE_16 = 0x0c,
2257 +
2258 + PCF50633_ADCC1_MUX_BATSNS_RES = 0x00,
2259 + PCF50633_ADCC1_MUX_BATSNS_SUBTR = 0x10,
2260 + PCF50633_ADCC1_MUX_ADCIN2_RES = 0x20,
2261 + PCF50633_ADCC1_MUX_ADCIN2_SUBTR = 0x30,
2262 + PCF50633_ADCC1_MUX_BATTEMP = 0x60,
2263 + PCF50633_ADCC1_MUX_ADCIN1 = 0x70,
2264 +};
2265 +#define PCF50633_ADCC1_AVERAGE_MASK 0x0c
2266 +#define PCF50633_ADCC1_ADCMUX_MASK 0xf0
2267 +
2268 +enum pcf50633_reg_adcc2 {
2269 + PCF50633_ADCC2_RATIO_NONE = 0x00,
2270 + PCF50633_ADCC2_RATIO_BATTEMP = 0x01,
2271 + PCF50633_ADCC2_RATIO_ADCIN1 = 0x02,
2272 + PCF50633_ADCC2_RATIO_BOTH = 0x03,
2273 + PCF50633_ADCC2_RATIOSETTL_100US = 0x04,
2274 +};
2275 +#define PCF50633_ADCC2_RATIO_MASK 0x03
2276 +
2277 +enum pcf50633_reg_adcc3 {
2278 + PCF50633_ADCC3_ACCSW_EN = 0x01,
2279 + PCF50633_ADCC3_NTCSW_EN = 0x04,
2280 + PCF50633_ADCC3_RES_DIV_TWO = 0x10,
2281 + PCF50633_ADCC3_RES_DIV_THREE = 0x00,
2282 +};
2283 +
2284 +enum pcf50633_reg_adcs3 {
2285 + PCF50633_ADCS3_REF_NTCSW = 0x00,
2286 + PCF50633_ADCS3_REF_ACCSW = 0x10,
2287 + PCF50633_ADCS3_REF_2V0 = 0x20,
2288 + PCF50633_ADCS3_REF_VISA = 0x30,
2289 + PCF50633_ADCS3_REF_2V0_2 = 0x70,
2290 + PCF50633_ADCS3_ADCRDY = 0x80,
2291 +};
2292 +#define PCF50633_ADCS3_ADCDAT1L_MASK 0x03
2293 +#define PCF50633_ADCS3_ADCDAT2L_MASK 0x0c
2294 +#define PCF50633_ADCS3_ADCDAT2L_SHIFT 2
2295 +#define PCF50633_ASCS3_REF_MASK 0x70
2296 +
2297 +enum pcf50633_regulator_enable {
2298 + PCF50633_REGULATOR_ON = 0x01,
2299 + PCF50633_REGULATOR_ON_GPIO1 = 0x02,
2300 + PCF50633_REGULATOR_ON_GPIO2 = 0x04,
2301 + PCF50633_REGULATOR_ON_GPIO3 = 0x08,
2302 +};
2303 +#define PCF50633_REGULATOR_ON_MASK 0x0f
2304 +
2305 +enum pcf50633_regulator_phase {
2306 + PCF50633_REGULATOR_ACTPH1 = 0x00,
2307 + PCF50633_REGULATOR_ACTPH2 = 0x10,
2308 + PCF50633_REGULATOR_ACTPH3 = 0x20,
2309 + PCF50633_REGULATOR_ACTPH4 = 0x30,
2310 +};
2311 +#define PCF50633_REGULATOR_ACTPH_MASK 0x30
2312 +
2313 +enum pcf50633_reg_gpocfg {
2314 + PCF50633_GPOCFG_GPOSEL_0 = 0x00,
2315 + PCF50633_GPOCFG_GPOSEL_LED_NFET = 0x01,
2316 + PCF50633_GPOCFG_GPOSEL_SYSxOK = 0x02,
2317 + PCF50633_GPOCFG_GPOSEL_CLK32K = 0x03,
2318 + PCF50633_GPOCFG_GPOSEL_ADAPUSB = 0x04,
2319 + PCF50633_GPOCFG_GPOSEL_USBxOK = 0x05,
2320 + PCF50633_GPOCFG_GPOSEL_ACTPH4 = 0x06,
2321 + PCF50633_GPOCFG_GPOSEL_1 = 0x07,
2322 + PCF50633_GPOCFG_GPOSEL_INVERSE = 0x08,
2323 +};
2324 +#define PCF50633_GPOCFG_GPOSEL_MASK 0x07
2325 +
2326 +#if 0
2327 +enum pcf50633_reg_mbcc1 {
2328 + PCF50633_MBCC1_CHGENA = 0x01,
2329 + PCF50633_MBCC1_AUTOSTOP = 0x02,
2330 + PCF50633_MBCC1_AUTORES = 0x04,
2331 + PCF50633_MBCC1_RESUME = 0x08,
2332 + PCF50633_MBCC1_RESTART = 0x10,
2333 + PCF50633_MBCC1_PREWDTIME_30MIN = 0x00,
2334 + PCF50633_MBCC1_PREWDTIME_60MIN = 0x20,
2335 + PCF50633_MBCC1_WDTIME_2HRS = 0x40,
2336 + PCF50633_MBCC1_WDTIME_4HRS = 0x80,
2337 + PCF50633_MBCC1_WDTIME_6HRS = 0xc0,
2338 +};
2339 +
2340 +enum pcf50633_reg_mbcc2 {
2341 + PCF50633_MBCC2_VBATCOND_2V7 = 0x00,
2342 + PCF50633_MBCC2_VBATCOND_2V85 = 0x01,
2343 + PCF50633_MBCC2_VBATCOND_3V0 = 0x02,
2344 + PCF50633_MBCC2_VBATCOND_3V15 = 0x03,
2345 + PCF50633_MBCC2_VRESDEBTIME_64S = 0x80,
2346 +};
2347 +#define PCF50633_MBCC2_VMAX_MASK 0x3c
2348 +#endif
2349 +
2350 +enum pcf50633_reg_mbcc7 {
2351 + PCF50633_MBCC7_USB_100mA = 0x00,
2352 + PCF50633_MBCC7_USB_500mA = 0x01,
2353 + PCF50633_MBCC7_USB_1000mA = 0x02,
2354 + PCF50633_MBCC7_USB_SUSPEND = 0x03,
2355 + PCF50633_MBCC7_BATTEMP_EN = 0x04,
2356 + PCF50633_MBCC7_BATSYSIMAX_1A6 = 0x00,
2357 + PCF50633_MBCC7_BATSYSIMAX_1A8 = 0x40,
2358 + PCF50633_MBCC7_BATSYSIMAX_2A0 = 0x80,
2359 + PCF50633_MBCC7_BATSYSIMAX_2A2 = 0xc0,
2360 +};
2361 +#define PCF56033_MBCC7_USB_MASK 0x03
2362 +
2363 +enum pcf50633_reg_mbcc8 {
2364 + PCF50633_MBCC8_USBENASUS = 0x10,
2365 +};
2366 +
2367 +enum pcf50633_reg_mbcs1 {
2368 + PCF50633_MBCS1_USBPRES = 0x01,
2369 + PCF50633_MBCS1_USBOK = 0x02,
2370 + PCF50633_MBCS1_ADAPTPRES = 0x04,
2371 + PCF50633_MBCS1_ADAPTOK = 0x08,
2372 + PCF50633_MBCS1_TBAT_OK = 0x00,
2373 + PCF50633_MBCS1_TBAT_ABOVE = 0x10,
2374 + PCF50633_MBCS1_TBAT_BELOW = 0x20,
2375 + PCF50633_MBCS1_TBAT_UNDEF = 0x30,
2376 + PCF50633_MBCS1_PREWDTEXP = 0x40,
2377 + PCF50633_MBCS1_WDTEXP = 0x80,
2378 +};
2379 +
2380 +enum pcf50633_reg_mbcs2_mbcmod {
2381 + PCF50633_MBCS2_MBC_PLAY = 0x00,
2382 + PCF50633_MBCS2_MBC_USB_PRE = 0x01,
2383 + PCF50633_MBCS2_MBC_USB_PRE_WAIT = 0x02,
2384 + PCF50633_MBCS2_MBC_USB_FAST = 0x03,
2385 + PCF50633_MBCS2_MBC_USB_FAST_WAIT= 0x04,
2386 + PCF50633_MBCS2_MBC_USB_SUSPEND = 0x05,
2387 + PCF50633_MBCS2_MBC_ADP_PRE = 0x06,
2388 + PCF50633_MBCS2_MBC_ADP_PRE_WAIT = 0x07,
2389 + PCF50633_MBCS2_MBC_ADP_FAST = 0x08,
2390 + PCF50633_MBCS2_MBC_ADP_FAST_WAIT= 0x09,
2391 + PCF50633_MBCS2_MBC_BAT_FULL = 0x0a,
2392 + PCF50633_MBCS2_MBC_HALT = 0x0b,
2393 +};
2394 +#define PCF50633_MBCS2_MBC_MASK 0x0f
2395 +enum pcf50633_reg_mbcs2_chgstat {
2396 + PCF50633_MBCS2_CHGS_NONE = 0x00,
2397 + PCF50633_MBCS2_CHGS_ADAPTER = 0x10,
2398 + PCF50633_MBCS2_CHGS_USB = 0x20,
2399 + PCF50633_MBCS2_CHGS_BOTH = 0x30,
2400 +};
2401 +#define PCF50633_MBCS2_RESSTAT_AUTO 0x40
2402 +
2403 +enum pcf50633_reg_mbcs3 {
2404 + PCF50633_MBCS3_USBLIM_PLAY = 0x01,
2405 + PCF50633_MBCS3_USBLIM_CGH = 0x02,
2406 + PCF50633_MBCS3_TLIM_PLAY = 0x04,
2407 + PCF50633_MBCS3_TLIM_CHG = 0x08,
2408 + PCF50633_MBCS3_ILIM = 0x10, /* 1: Ibat > Icutoff */
2409 + PCF50633_MBCS3_VLIM = 0x20, /* 1: Vbat == Vmax */
2410 + PCF50633_MBCS3_VBATSTAT = 0x40, /* 1: Vbat > Vbatcond */
2411 + PCF50633_MBCS3_VRES = 0x80, /* 1: Vbat > Vth(RES) */
2412 +};
2413 +
2414 +/* this is to be provided by the board implementation */
2415 +extern const u_int8_t pcf50633_initial_regs[__NUM_PCF50633_REGS];
2416 +
2417 +void pcf50633_reg_write(u_int8_t reg, u_int8_t val);
2418 +
2419 +u_int8_t pcf50633_reg_read(u_int8_t reg);
2420 +
2421 +void pcf50633_reg_set_bit_mask(u_int8_t reg, u_int8_t mask, u_int8_t val);
2422 +void pcf50633_reg_clear_bits(u_int8_t reg, u_int8_t bits);
2423 +
2424 +void pcf50633_charge_autofast(int on);
2425 +
2426 +#endif /* _PCF50606_H */
2427 +
2428 diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
2429 index 2cda699..90f53e1 100644
2430 --- a/include/linux/i2c-id.h
2431 +++ b/include/linux/i2c-id.h
2432 @@ -95,6 +95,7 @@
2433
2434 #define I2C_DRIVERID_OV7670 1048 /* Omnivision 7670 camera */
2435 #define I2C_DRIVERID_PCF50606 1049
2436 +#define I2C_DRIVERID_PCF50633 1051
2437
2438 /*
2439 * ---- Adapter types ----------------------------------------------------
2440 diff --git a/include/linux/pcf50633.h b/include/linux/pcf50633.h
2441 new file mode 100644
2442 index 0000000..5f32004
2443 --- /dev/null
2444 +++ b/include/linux/pcf50633.h
2445 @@ -0,0 +1,114 @@
2446 +#ifndef _LINUX_PCF50633_H
2447 +#define _LINUX_PCF50633_H
2448 +
2449 +/* public in-kernel pcf50633 api */
2450 +enum pcf50633_regulator_id {
2451 + PCF50633_REGULATOR_AUTO,
2452 + PCF50633_REGULATOR_DOWN1,
2453 + PCF50633_REGULATOR_DOWN2,
2454 + PCF50633_REGULATOR_MEMLDO,
2455 + PCF50633_REGULATOR_LDO1,
2456 + PCF50633_REGULATOR_LDO2,
2457 + PCF50633_REGULATOR_LDO3,
2458 + PCF50633_REGULATOR_LDO4,
2459 + PCF50633_REGULATOR_LDO5,
2460 + PCF50633_REGULATOR_LDO6,
2461 + PCF50633_REGULATOR_HCLDO,
2462 + __NUM_PCF50633_REGULATORS
2463 +};
2464 +
2465 +struct pcf50633_data;
2466 +extern struct pcf50633_data *pcf50633_global;
2467 +
2468 +extern void
2469 +pcf50633_go_standby(void);
2470 +
2471 +enum pcf50633_gpio {
2472 + PCF50633_GPIO1 = 1,
2473 + PCF50633_GPIO2 = 2,
2474 + PCF50633_GPIO3 = 3,
2475 + PCF50633_GPO = 4,
2476 +};
2477 +
2478 +extern void
2479 +pcf50633_gpio_set(struct pcf50633_data *pcf, enum pcf50633_gpio gpio, int on);
2480 +
2481 +extern int
2482 +pcf50633_gpio_get(struct pcf50633_data *pcf, enum pcf50633_gpio gpio);
2483 +
2484 +extern int
2485 +pcf50633_voltage_set(struct pcf50633_data *pcf,
2486 + enum pcf50633_regulator_id reg,
2487 + unsigned int millivolts);
2488 +extern unsigned int
2489 +pcf50633_voltage_get(struct pcf50633_data *pcf,
2490 + enum pcf50633_regulator_id reg);
2491 +extern int
2492 +pcf50633_onoff_get(struct pcf50633_data *pcf,
2493 + enum pcf50633_regulator_id reg);
2494 +
2495 +extern int
2496 +pcf50633_onoff_set(struct pcf50633_data *pcf,
2497 + enum pcf50633_regulator_id reg, int on);
2498 +
2499 +extern void
2500 +pcf50633_usb_curlim_set(struct pcf50633_data *pcf, int ma);
2501 +
2502 +extern void
2503 +pcf50633_charge_enable(struct pcf50633_data *pcf, int on);
2504 +
2505 +/* FIXME: sharded with pcf50606 */
2506 +#define PMU_VRAIL_F_SUSPEND_ON 0x00000001 /* Remains on during suspend */
2507 +#define PMU_VRAIL_F_UNUSED 0x00000002 /* This rail is not used */
2508 +struct pmu_voltage_rail {
2509 + char *name;
2510 + unsigned int flags;
2511 + struct {
2512 + unsigned int init;
2513 + unsigned int max;
2514 + } voltage;
2515 +};
2516 +
2517 +enum pmu_event {
2518 + PMU_EVT_NONE,
2519 + PMU_EVT_INSERT,
2520 + PMU_EVT_REMOVE,
2521 + PMU_EVT_USB_INSERT,
2522 + PMU_EVT_USB_REMOVE,
2523 + __NUM_PMU_EVTS
2524 +};
2525 +
2526 +typedef int pmu_cb(struct device *dev, unsigned int feature,
2527 + enum pmu_event event);
2528 +
2529 +#define PCF50633_FEAT_EXTON 0x00000001 /* not yet supported */
2530 +#define PCF50633_FEAT_MBC 0x00000002
2531 +#define PCF50633_FEAT_BBC 0x00000004 /* not yet supported */
2532 +#define PCF50633_FEAT_RTC 0x00000040
2533 +#define PCF50633_FEAT_CHGCUR 0x00000100
2534 +#define PCF50633_FEAT_BATVOLT 0x00000200
2535 +#define PCF50633_FEAT_BATTEMP 0x00000400
2536 +#define PCF50633_FEAT_PWM_BL 0x00000800
2537 +
2538 +struct pcf50633_platform_data {
2539 + /* general */
2540 + unsigned int used_features;
2541 + unsigned int onkey_seconds_sig_init;
2542 + unsigned int onkey_seconds_shutdown;
2543 +
2544 + /* voltage regulator related */
2545 + struct pmu_voltage_rail rails[__NUM_PCF50633_REGULATORS];
2546 + unsigned int used_regulators;
2547 +
2548 + /* charger related */
2549 + unsigned int r_fix_batt;
2550 + unsigned int r_fix_batt_par;
2551 + unsigned int r_sense_milli;
2552 +
2553 + struct {
2554 + u_int8_t mbcc3; /* charger voltage / current */
2555 + } charger;
2556 + pmu_cb *cb;
2557 +};
2558 +
2559 +#endif /* _PCF50633_H */
2560 --
2561 1.5.6.3
2562
OpenWrt Source Repository