From ee73a861f3273b9603577468a06b433d5f5be129 Mon Sep 17 00:00:00 2001 From: Lars-Peter Clausen Date: Sat, 17 Oct 2009 01:51:11 +0200 Subject: Inital pcf50606 support --- drivers/input/misc/Kconfig | 7 + drivers/input/misc/Makefile | 1 + drivers/input/misc/pcf50606-input.c | 140 +++++++ drivers/mfd/Kconfig | 23 ++ drivers/mfd/Makefile | 5 + drivers/mfd/pcf50606-adc.c | 279 ++++++++++++++ drivers/mfd/pcf50606-core.c | 680 +++++++++++++++++++++++++++++++++ drivers/mfd/pcf50606-gpo.c | 119 ++++++ drivers/power/Kconfig | 6 + drivers/power/Makefile | 1 + drivers/power/pcf50606-charger.c | 244 ++++++++++++ drivers/regulator/Kconfig | 6 + drivers/regulator/Makefile | 1 + drivers/regulator/pcf50606-regulator.c | 381 ++++++++++++++++++ drivers/rtc/Kconfig | 7 + drivers/rtc/Makefile | 1 + drivers/rtc/rtc-pcf50606.c | 342 +++++++++++++++++ drivers/watchdog/Kconfig | 7 + drivers/watchdog/Makefile | 1 + drivers/watchdog/pcf50606_wdt.c | 223 +++++++++++ include/linux/mfd/pcf50606/adc.h | 72 ++++ include/linux/mfd/pcf50606/core.h | 170 +++++++++ include/linux/mfd/pcf50606/gpo.h | 42 ++ include/linux/mfd/pcf50606/mbc.h | 52 +++ include/linux/mfd/pcf50606/pmic.h | 73 ++++ 25 files changed, 2883 insertions(+) create mode 100644 drivers/input/misc/pcf50606-input.c create mode 100644 drivers/mfd/pcf50606-adc.c create mode 100644 drivers/mfd/pcf50606-core.c create mode 100644 drivers/mfd/pcf50606-gpo.c create mode 100644 drivers/power/pcf50606-charger.c create mode 100644 drivers/regulator/pcf50606-regulator.c create mode 100644 drivers/rtc/rtc-pcf50606.c create mode 100644 drivers/watchdog/pcf50606_wdt.c create mode 100644 include/linux/mfd/pcf50606/adc.h create mode 100644 include/linux/mfd/pcf50606/core.h create mode 100644 include/linux/mfd/pcf50606/gpo.h create mode 100644 include/linux/mfd/pcf50606/mbc.h create mode 100644 include/linux/mfd/pcf50606/pmic.h diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig index 1acfa3a05aa..558b73f0100 100644 --- a/drivers/input/misc/Kconfig +++ b/drivers/input/misc/Kconfig @@ -237,6 +237,13 @@ config INPUT_PCF50633_PMU Say Y to include support for delivering PMU events via input layer on NXP PCF50633. +config INPUT_PCF50606_PMU + tristate "PCF50606 PMU events" + depends on MFD_PCF50606 + help + Say Y to include support for delivering PMU events via input + layer on NXP PCF50606. + config INPUT_GPIO_ROTARY_ENCODER tristate "Rotary encoders connected to GPIO pins" depends on GPIOLIB && GENERIC_GPIO diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile index 0d979fd4cd5..730857b6674 100644 --- a/drivers/input/misc/Makefile +++ b/drivers/input/misc/Makefile @@ -16,6 +16,7 @@ obj-$(CONFIG_INPUT_IXP4XX_BEEPER) += ixp4xx-beeper.o obj-$(CONFIG_INPUT_KEYSPAN_REMOTE) += keyspan_remote.o obj-$(CONFIG_INPUT_M68K_BEEP) += m68kspkr.o obj-$(CONFIG_INPUT_PCF50633_PMU) += pcf50633-input.o +obj-$(CONFIG_INPUT_PCF50606_PMU) += pcf50606-input.o obj-$(CONFIG_INPUT_PCSPKR) += pcspkr.o obj-$(CONFIG_INPUT_POWERMATE) += powermate.o obj-$(CONFIG_INPUT_RB532_BUTTON) += rb532_button.o diff --git a/drivers/input/misc/pcf50606-input.c b/drivers/input/misc/pcf50606-input.c new file mode 100644 index 00000000000..044438ed662 --- /dev/null +++ b/drivers/input/misc/pcf50606-input.c @@ -0,0 +1,140 @@ +/* Philips PCF50606 Input Driver + * + * (C) 2006-2008 by Openmoko, Inc. + * Author: Balaji Rao + * All rights reserved. + * + * Broken down from monstrous PCF50606 driver mainly by + * Harald Welte, Matt Hsu, Andy Green and Werner Almesberger + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + */ + +#include +#include +#include +#include +#include +#include + +#include + +#define PCF50606_OOCS_ONKEY 0x01 +#define PCF50606_OOCS_EXTON 0x02 + +#define PCF50606_OOCC2_ONKEYDB_NONE 0x00 +#define PCF50606_OOCC2_ONKEYDB_14ms 0x01 +#define PCF50606_OOCC2_ONKEYDB_62ms 0x02 +#define PCF50606_OOCC2_ONKEYDB_500ms 0x03 +#define PCF50606_OOCC2_EXTONDB_NONE 0x00 +#define PCF50606_OOCC2_EXTONDB_14ms 0x04 +#define PCF50606_OOCC2_EXTONDB_62ms 0x08 +#define PCF50606_OOCC2_EXTONDB_500ms 0x0c + +#define PCF50606_REG_OOCS 0x01 + +struct pcf50606_input { + struct pcf50606 *pcf; + struct input_dev *input_dev; +}; + +static void +pcf50606_input_irq(int irq, void *data) +{ + struct pcf50606_input *input; + int onkey_released; + + input = data; + onkey_released = pcf50606_reg_read(input->pcf, PCF50606_REG_OOCS) & + PCF50606_OOCS_ONKEY; + + if (irq == PCF50606_IRQ_ONKEYF && !onkey_released) + input_report_key(input->input_dev, KEY_POWER, 1); + else if (irq == PCF50606_IRQ_ONKEYR && onkey_released) + input_report_key(input->input_dev, KEY_POWER, 0); + + input_sync(input->input_dev); +} + +static int __devinit pcf50606_input_probe(struct platform_device *pdev) +{ + struct pcf50606_input *input; + struct pcf50606_subdev_pdata *pdata = pdev->dev.platform_data; + struct input_dev *input_dev; + int ret; + + + input = kzalloc(sizeof(*input), GFP_KERNEL); + if (!input) + return -ENOMEM; + + input_dev = input_allocate_device(); + if (!input_dev) { + kfree(input); + return -ENOMEM; + } + + platform_set_drvdata(pdev, input); + input->pcf = pdata->pcf; + input->input_dev = input_dev; + + input_dev->name = "PCF50606 PMU events"; + input_dev->id.bustype = BUS_I2C; + input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_PWR); + set_bit(KEY_POWER, input_dev->keybit); + + ret = input_register_device(input_dev); + if (ret) { + input_free_device(input_dev); + kfree(input); + return ret; + } + pcf50606_register_irq(pdata->pcf, PCF50606_IRQ_ONKEYR, + pcf50606_input_irq, input); + pcf50606_register_irq(pdata->pcf, PCF50606_IRQ_ONKEYF, + pcf50606_input_irq, input); + + return 0; +} + +static int __devexit pcf50606_input_remove(struct platform_device *pdev) +{ + struct pcf50606_input *input = platform_get_drvdata(pdev); + + input_unregister_device(input->input_dev); + pcf50606_free_irq(input->pcf, PCF50606_IRQ_ONKEYR); + pcf50606_free_irq(input->pcf, PCF50606_IRQ_ONKEYF); + + kfree(input); + + return 0; +} + +static struct platform_driver pcf50606_input_driver = { + .driver = { + .name = "pcf50606-input", + }, + .probe = pcf50606_input_probe, + .remove = __devexit_p(pcf50606_input_remove), +}; + +static int __init pcf50606_input_init(void) +{ + return platform_driver_register(&pcf50606_input_driver); +} +module_init(pcf50606_input_init); + +static void __exit pcf50606_input_exit(void) +{ + platform_driver_unregister(&pcf50606_input_driver); +} +module_exit(pcf50606_input_exit); + +MODULE_AUTHOR("Balaji Rao "); +MODULE_DESCRIPTION("PCF50606 input driver"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:pcf50606-input"); diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig index 491ac0f800d..4e952cc7a8f 100644 --- a/drivers/mfd/Kconfig +++ b/drivers/mfd/Kconfig @@ -263,6 +263,29 @@ config EZX_PCAP This enables the PCAP ASIC present on EZX Phones. This is needed for MMC, TouchScreen, Sound, USB, etc.. +config MFD_PCF50606 + tristate "Support for NXP PCF50606" + depends on I2C + help + Say yes here if you have NXP PCF50606 chip on your board. + This core driver provides register access and IRQ handling + facilities, and registers devices for the various functions + so that function-specific drivers can bind to them. + +config PCF50606_ADC + tristate "Support for NXP PCF50606 ADC" + depends on MFD_PCF50606 + help + Say yes here if you want to include support for ADC in the + NXP PCF50606 chip. + +config PCF50606_GPO + tristate "Support for NXP PCF50606 GPO" + depends on MFD_PCF50606 + help + Say yes here if you want to include support GPO for pins on + the PCF50606 chip. + endmenu menu "Multimedia Capabilities Port drivers" diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile index 6f8a9a1af20..ba41b36f2c5 100644 --- a/drivers/mfd/Makefile +++ b/drivers/mfd/Makefile @@ -44,3 +44,8 @@ obj-$(CONFIG_MFD_PCF50633) += pcf50633-core.o obj-$(CONFIG_PCF50633_ADC) += pcf50633-adc.o obj-$(CONFIG_PCF50633_GPIO) += pcf50633-gpio.o obj-$(CONFIG_AB3100_CORE) += ab3100-core.o + +obj-$(CONFIG_MFD_PCF50606) += pcf50606-core.o +obj-$(CONFIG_PCF50606_ADC) += pcf50606-adc.o +obj-$(CONFIG_PCF50606_GPO) += pcf50606-gpo.o + diff --git a/drivers/mfd/pcf50606-adc.c b/drivers/mfd/pcf50606-adc.c new file mode 100644 index 00000000000..38f5b5c0593 --- /dev/null +++ b/drivers/mfd/pcf50606-adc.c @@ -0,0 +1,279 @@ +/* Philips PCF50606 ADC Driver + * + * (C) 2006-2008 by Openmoko, Inc. + * Author: Balaji Rao + * All rights reserved. + * + * Broken down from monstrous PCF50606 driver mainly by + * Harald Welte, Andy Green, Werner Almesberger and Matt Hsu + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * NOTE: This driver does not yet support subtractive ADC mode, which means + * you can do only one measurement per read request. + */ + +#include +#include +#include +#include +#include +#include + +#include +#include + +struct pcf50606_adc_request { + int mux; + int result; + void (*callback)(struct pcf50606 *, void *, int); + void *callback_param; + + /* Used in case of sync requests */ + struct completion completion; + +}; + +#define PCF50606_MAX_ADC_FIFO_DEPTH 8 + +struct pcf50606_adc { + struct pcf50606 *pcf; + + /* Private stuff */ + struct pcf50606_adc_request *queue[PCF50606_MAX_ADC_FIFO_DEPTH]; + int queue_head; + int queue_tail; + struct mutex queue_mutex; +}; + +static inline struct pcf50606_adc *__to_adc(struct pcf50606 *pcf) +{ + return platform_get_drvdata(pcf->adc_pdev); +} + +static void adc_setup(struct pcf50606 *pcf, int channel) +{ + channel &= PCF50606_ADCC2_ADCMUX_MASK; + + /* start ADC conversion of selected channel */ + pcf50606_reg_write(pcf, PCF50606_REG_ADCC2, channel | + PCF50606_ADCC2_ADCSTART | PCF50606_ADCC2_RES_10BIT); + +} + +static void trigger_next_adc_job_if_any(struct pcf50606 *pcf) +{ + struct pcf50606_adc *adc = __to_adc(pcf); + int head, tail; + + mutex_lock(&adc->queue_mutex); + + head = adc->queue_head; + tail = adc->queue_tail; + + if (!adc->queue[head]) + goto out; + + adc_setup(pcf, adc->queue[head]->mux); +out: + mutex_unlock(&adc->queue_mutex); +} + +static int +adc_enqueue_request(struct pcf50606 *pcf, struct pcf50606_adc_request *req) +{ + struct pcf50606_adc *adc = __to_adc(pcf); + int head, tail; + + mutex_lock(&adc->queue_mutex); + head = adc->queue_head; + tail = adc->queue_tail; + + if (adc->queue[tail]) { + mutex_unlock(&adc->queue_mutex); + return -EBUSY; + } + + adc->queue[tail] = req; + + adc->queue_tail = + (tail + 1) & (PCF50606_MAX_ADC_FIFO_DEPTH - 1); + + mutex_unlock(&adc->queue_mutex); + + trigger_next_adc_job_if_any(pcf); + + return 0; +} + +static void +pcf50606_adc_sync_read_callback(struct pcf50606 *pcf, void *param, int result) +{ + struct pcf50606_adc_request *req; + + /*We know here that the passed param is an adc_request object */ + req = (struct pcf50606_adc_request *)param; + + req->result = result; + complete(&req->completion); +} + +int pcf50606_adc_sync_read(struct pcf50606 *pcf, int mux) +{ + + struct pcf50606_adc_request *req; + int result; + + /* req is freed when the result is ready, in irq handler*/ + req = kzalloc(sizeof(*req), GFP_KERNEL); + if (!req) + return -ENOMEM; + + req->mux = mux; + req->callback = pcf50606_adc_sync_read_callback; + req->callback_param = req; + init_completion(&req->completion); + + adc_enqueue_request(pcf, req); + + if (wait_for_completion_timeout(&req->completion, 5 * HZ) == 5 * HZ) { + dev_err(pcf->dev, "ADC read timed out \n"); + } + + result = req->result; + + return result; +} +EXPORT_SYMBOL_GPL(pcf50606_adc_sync_read); + +int pcf50606_adc_async_read(struct pcf50606 *pcf, int mux, + void (*callback)(struct pcf50606 *, void *, int), + void *callback_param) +{ + struct pcf50606_adc_request *req; + + /* req is freed when the result is ready, in pcf50606_work*/ + req = kmalloc(sizeof(*req), GFP_KERNEL); + if (!req) + return -ENOMEM; + + req->mux = mux; + req->callback = callback; + req->callback_param = callback_param; + + adc_enqueue_request(pcf, req); + + return 0; +} +EXPORT_SYMBOL_GPL(pcf50606_adc_async_read); + +static int adc_result(struct pcf50606 *pcf) +{ + u16 ret = (pcf50606_reg_read(pcf, PCF50606_REG_ADCS1) << 2) | + (pcf50606_reg_read(pcf, PCF50606_REG_ADCS2) & 0x03); + + dev_dbg(pcf->dev, "adc result = %d\n", ret); + + return ret; +} + +static void pcf50606_adc_irq(int irq, void *data) +{ + struct pcf50606_adc *adc = data; + struct pcf50606 *pcf = adc->pcf; + struct pcf50606_adc_request *req; + int head; + + mutex_lock(&adc->queue_mutex); + head = adc->queue_head; + + req = adc->queue[head]; + if (WARN_ON(!req)) { + dev_err(pcf->dev, "pcf50606-adc irq: ADC queue empty!\n"); + mutex_unlock(&adc->queue_mutex); + return; + } + + adc->queue[head] = NULL; + adc->queue_head = (head + 1) & + (PCF50606_MAX_ADC_FIFO_DEPTH - 1); + + mutex_unlock(&adc->queue_mutex); + + req->callback(pcf, req->callback_param, adc_result(pcf)); + kfree(req); + + trigger_next_adc_job_if_any(pcf); +} + +static int __devinit pcf50606_adc_probe(struct platform_device *pdev) +{ + struct pcf50606_subdev_pdata *pdata = pdev->dev.platform_data; + struct pcf50606_adc *adc; + + adc = kzalloc(sizeof(*adc), GFP_KERNEL); + if (!adc) + return -ENOMEM; + + adc->pcf = pdata->pcf; + platform_set_drvdata(pdev, adc); + + pcf50606_register_irq(pdata->pcf, PCF50606_IRQ_ADCRDY, + pcf50606_adc_irq, adc); + + mutex_init(&adc->queue_mutex); + + return 0; +} + +static int __devexit pcf50606_adc_remove(struct platform_device *pdev) +{ + struct pcf50606_adc *adc = platform_get_drvdata(pdev); + int i, head; + + pcf50606_free_irq(adc->pcf, PCF50606_IRQ_ADCRDY); + + mutex_lock(&adc->queue_mutex); + head = adc->queue_head; + + if (WARN_ON(adc->queue[head])) + dev_err(adc->pcf->dev, + "adc driver removed with request pending\n"); + + for (i = 0; i < PCF50606_MAX_ADC_FIFO_DEPTH; i++) + kfree(adc->queue[i]); + + mutex_unlock(&adc->queue_mutex); + kfree(adc); + + return 0; +} + +struct platform_driver pcf50606_adc_driver = { + .driver = { + .name = "pcf50606-adc", + }, + .probe = pcf50606_adc_probe, + .remove = __devexit_p(pcf50606_adc_remove), +}; + +static int __init pcf50606_adc_init(void) +{ + return platform_driver_register(&pcf50606_adc_driver); +} +module_init(pcf50606_adc_init); + +static void __exit pcf50606_adc_exit(void) +{ + platform_driver_unregister(&pcf50606_adc_driver); +} +module_exit(pcf50606_adc_exit); + +MODULE_AUTHOR("Balaji Rao "); +MODULE_DESCRIPTION("PCF50606 adc driver"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:pcf50606-adc"); + diff --git a/drivers/mfd/pcf50606-core.c b/drivers/mfd/pcf50606-core.c new file mode 100644 index 00000000000..09ce70b9b79 --- /dev/null +++ b/drivers/mfd/pcf50606-core.c @@ -0,0 +1,680 @@ +/* Philips PCF50606 Power Management Unit (PMU) driver + * + * (C) 2006-2008 by Openmoko, Inc. + * Author: Harald Welte + * Matt Hsu + * All rights reserved. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +static int __pcf50606_read(struct pcf50606 *pcf, u8 reg, int num, u8 *data) +{ + int ret; + + ret = i2c_smbus_read_i2c_block_data(pcf->i2c_client, reg, + num, data); + if (ret < 0) + dev_err(pcf->dev, "Error reading %d regs at %d\n", num, reg); + + return ret; +} + +static int __pcf50606_write(struct pcf50606 *pcf, u8 reg, int num, u8 *data) +{ + int ret; + + ret = i2c_smbus_write_i2c_block_data(pcf->i2c_client, reg, + num, data); + if (ret < 0) + dev_err(pcf->dev, "Error writing %d regs at %d\n", num, reg); + + return ret; + +} + +/* Read a block of upto 32 regs */ +int pcf50606_read_block(struct pcf50606 *pcf, u8 reg, + int nr_regs, u8 *data) +{ + int ret; + + mutex_lock(&pcf->lock); + ret = __pcf50606_read(pcf, reg, nr_regs, data); + mutex_unlock(&pcf->lock); + + return ret; +} +EXPORT_SYMBOL_GPL(pcf50606_read_block); + +/* Write a block of upto 32 regs */ +int pcf50606_write_block(struct pcf50606 *pcf , u8 reg, + int nr_regs, u8 *data) +{ + int ret; + + mutex_lock(&pcf->lock); + ret = __pcf50606_write(pcf, reg, nr_regs, data); + mutex_unlock(&pcf->lock); + + return ret; +} +EXPORT_SYMBOL_GPL(pcf50606_write_block); + +u8 pcf50606_reg_read(struct pcf50606 *pcf, u8 reg) +{ + u8 val; + + mutex_lock(&pcf->lock); + __pcf50606_read(pcf, reg, 1, &val); + mutex_unlock(&pcf->lock); + + return val; +} +EXPORT_SYMBOL_GPL(pcf50606_reg_read); + +int pcf50606_reg_write(struct pcf50606 *pcf, u8 reg, u8 val) +{ + int ret; + + mutex_lock(&pcf->lock); + ret = __pcf50606_write(pcf, reg, 1, &val); + mutex_unlock(&pcf->lock); + + return ret; +} +EXPORT_SYMBOL_GPL(pcf50606_reg_write); + +int pcf50606_reg_set_bit_mask(struct pcf50606 *pcf, u8 reg, u8 mask, u8 val) +{ + int ret; + u8 tmp; + + val &= mask; + + mutex_lock(&pcf->lock); + ret = __pcf50606_read(pcf, reg, 1, &tmp); + if (ret < 0) + goto out; + + tmp &= ~mask; + tmp |= val; + ret = __pcf50606_write(pcf, reg, 1, &tmp); + +out: + mutex_unlock(&pcf->lock); + + return ret; +} +EXPORT_SYMBOL_GPL(pcf50606_reg_set_bit_mask); + +int pcf50606_reg_clear_bits(struct pcf50606 *pcf, u8 reg, u8 val) +{ + int ret; + u8 tmp; + + mutex_lock(&pcf->lock); + ret = __pcf50606_read(pcf, reg, 1, &tmp); + if (ret < 0) + goto out; + + tmp &= ~val; + ret = __pcf50606_write(pcf, reg, 1, &tmp); + +out: + mutex_unlock(&pcf->lock); + + return ret; +} +EXPORT_SYMBOL_GPL(pcf50606_reg_clear_bits); + +/* sysfs attributes */ +static ssize_t show_dump_regs(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct pcf50606 *pcf = dev_get_drvdata(dev); + u8 dump[16]; + int n, n1, idx = 0; + char *buf1 = buf; + static u8 address_no_read[] = { /* must be ascending */ + PCF50606_REG_INT1, + PCF50606_REG_INT2, + PCF50606_REG_INT3, + 0 /* terminator */ + }; + + for (n = 0; n < 256; n += sizeof(dump)) { + for (n1 = 0; n1 < sizeof(dump); n1++) + if (n == address_no_read[idx]) { + idx++; + dump[n1] = 0x00; + } else + dump[n1] = pcf50606_reg_read(pcf, n + n1); + + hex_dump_to_buffer(dump, sizeof(dump), 16, 1, buf1, 128, 0); + buf1 += strlen(buf1); + *buf1++ = '\n'; + *buf1 = '\0'; + } + + return buf1 - buf; +} +static DEVICE_ATTR(dump_regs, 0400, show_dump_regs, NULL); + +static ssize_t show_resume_reason(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct pcf50606 *pcf = dev_get_drvdata(dev); + int n; + + n = sprintf(buf, "%02x%02x%02x\n", + pcf->resume_reason[0], + pcf->resume_reason[1], + pcf->resume_reason[2]); + + return n; +} +static DEVICE_ATTR(resume_reason, 0400, show_resume_reason, NULL); + +static struct attribute *pcf_sysfs_entries[] = { + &dev_attr_dump_regs.attr, + &dev_attr_resume_reason.attr, + NULL, +}; + +static struct attribute_group pcf_attr_group = { + .name = NULL, /* put in device directory */ + .attrs = pcf_sysfs_entries, +}; + +int pcf50606_register_irq(struct pcf50606 *pcf, int irq, + void (*handler) (int, void *), void *data) +{ + if (irq < 0 || irq > PCF50606_NUM_IRQ || !handler) + return -EINVAL; + + if (WARN_ON(pcf->irq_handler[irq].handler)) + return -EBUSY; + + mutex_lock(&pcf->lock); + pcf->irq_handler[irq].handler = handler; + pcf->irq_handler[irq].data = data; + mutex_unlock(&pcf->lock); + + return 0; +} +EXPORT_SYMBOL_GPL(pcf50606_register_irq); + +int pcf50606_free_irq(struct pcf50606 *pcf, int irq) +{ + if (irq < 0 || irq > PCF50606_NUM_IRQ) + return -EINVAL; + + mutex_lock(&pcf->lock); + pcf->irq_handler[irq].handler = NULL; + mutex_unlock(&pcf->lock); + + return 0; +} +EXPORT_SYMBOL_GPL(pcf50606_free_irq); + +static int __pcf50606_irq_mask_set(struct pcf50606 *pcf, int irq, u8 mask) +{ + u8 reg, bits, tmp; + int ret = 0, idx; + + idx = irq >> 3; + reg = PCF50606_REG_INT1M + idx; + bits = 1 << (irq & 0x07); + + mutex_lock(&pcf->lock); + + if (mask) { + ret = __pcf50606_read(pcf, reg, 1, &tmp); + if (ret < 0) + goto out; + + tmp |= bits; + + ret = __pcf50606_write(pcf, reg, 1, &tmp); + if (ret < 0) + goto out; + + pcf->mask_regs[idx] &= ~bits; + pcf->mask_regs[idx] |= bits; + } else { + ret = __pcf50606_read(pcf, reg, 1, &tmp); + if (ret < 0) + goto out; + + tmp &= ~bits; + + ret = __pcf50606_write(pcf, reg, 1, &tmp); + if (ret < 0) + goto out; + + pcf->mask_regs[idx] &= ~bits; + } +out: + mutex_unlock(&pcf->lock); + + return ret; +} + +int pcf50606_irq_mask(struct pcf50606 *pcf, int irq) +{ + dev_dbg(pcf->dev, "Masking IRQ %d\n", irq); + + return __pcf50606_irq_mask_set(pcf, irq, 1); +} +EXPORT_SYMBOL_GPL(pcf50606_irq_mask); + +int pcf50606_irq_unmask(struct pcf50606 *pcf, int irq) +{ + dev_dbg(pcf->dev, "Unmasking IRQ %d\n", irq); + + return __pcf50606_irq_mask_set(pcf, irq, 0); +} +EXPORT_SYMBOL_GPL(pcf50606_irq_unmask); + +int pcf50606_irq_mask_get(struct pcf50606 *pcf, int irq) +{ + u8 reg, bits; + + reg = (irq / 8); + bits = (1 << (irq % 8)); + + return pcf->mask_regs[reg] & bits; +} +EXPORT_SYMBOL_GPL(pcf50606_irq_mask_get); + +static void pcf50606_irq_call_handler(struct pcf50606 *pcf, + int irq) +{ + if (pcf->irq_handler[irq].handler) + pcf->irq_handler[irq].handler(irq, pcf->irq_handler[irq].data); +} + +#define PCF50606_ONKEY1S_TIMEOUT 8 + +#define PCF50606_REG_MBCS1 0x2c + +static void pcf50606_irq_worker(struct work_struct *work) +{ + struct pcf50606 *pcf; + int ret, i, j; + u8 pcf_int[3], chgstat; + + pcf = container_of(work, struct pcf50606, irq_work); + + /* Read the 3 INT regs in one transaction */ + ret = pcf50606_read_block(pcf, PCF50606_REG_INT1, + ARRAY_SIZE(pcf_int), pcf_int); + if (ret != ARRAY_SIZE(pcf_int)) { + dev_err(pcf->dev, "Error reading INT registers\n"); + + /* + * If this doesn't ACK the interrupt to the chip, we'll be + * called once again as we're level triggered. + */ + goto out; + } + + /* We immediately read the charger status. We thus make sure + * only of CHGINS/CHGRM interrupt handlers are called */ + if (pcf_int[1] & (PCF50606_INT2_CHGINS | PCF50606_INT2_CHGRM)) { + chgstat = pcf50606_reg_read(pcf, PCF50606_REG_MBCS1); + if (chgstat & (0x1 << 4)) + pcf_int[1] &= ~(1 << PCF50606_INT2_CHGRM); + else + pcf_int[1] &= ~(1 << PCF50606_INT2_CHGINS); + } + + dev_dbg(pcf->dev, "INT1=0x%02x INT2=0x%02x INT3=0x%02x\n", + pcf_int[0], pcf_int[1], pcf_int[2]); + + /* Some revisions of the chip don't have a 8s standby mode on + * ONKEY1S press. We try to manually do it in such cases. */ + if (pcf_int[0] & PCF50606_INT1_SECOND && pcf->onkey1s_held) { + dev_info(pcf->dev, "ONKEY1S held for %d secs\n", + pcf->onkey1s_held); + if (pcf->onkey1s_held++ == PCF50606_ONKEY1S_TIMEOUT) + if (pcf->pdata->force_shutdown) + pcf->pdata->force_shutdown(pcf); + } + + if (pcf_int[0] & PCF50606_INT1_ONKEY1S) { + dev_info(pcf->dev, "ONKEY1S held\n"); + pcf->onkey1s_held = 1 ; + + /* Unmask IRQ_SECOND */ + pcf50606_reg_clear_bits(pcf, PCF50606_REG_INT1M, + PCF50606_INT1_SECOND); + + /* Unmask IRQ_ONKEYF */ + pcf50606_reg_clear_bits(pcf, PCF50606_REG_INT1M, + PCF50606_INT1_ONKEYF); + } + + if ((pcf_int[0] & PCF50606_INT1_ONKEYR) && pcf->onkey1s_held) { + pcf->onkey1s_held = 0; + + /* Mask SECOND and ONKEYF interrupts */ + if (pcf->mask_regs[0] & PCF50606_INT1_SECOND) + pcf50606_reg_set_bit_mask(pcf, + PCF50606_REG_INT1M, + PCF50606_INT1_SECOND, + PCF50606_INT1_SECOND); + + if (pcf->mask_regs[0] & PCF50606_INT1_ONKEYF) + pcf50606_reg_set_bit_mask(pcf, + PCF50606_REG_INT1M, + PCF50606_INT1_ONKEYF, + PCF50606_INT1_ONKEYF); + } + + /* Have we just resumed ? */ + if (pcf->is_suspended) { + + pcf->is_suspended = 0; + + /* Set the resume reason filtering out non resumers */ + for (i = 0; i < ARRAY_SIZE(pcf_int); i++) + pcf->resume_reason[i] = pcf_int[i] & + pcf->pdata->resumers[i]; + + /* Make sure we don't pass on ONKEY events to + * userspace now */ + pcf_int[1] &= ~(PCF50606_INT1_ONKEYR | PCF50606_INT1_ONKEYF); + } + + for (i = 0; i < ARRAY_SIZE(pcf_int); i++) { + /* Unset masked interrupts */ + pcf_int[i] &= ~pcf->mask_regs[i]; + + for (j = 0; j < 8 ; j++) + if (pcf_int[i] & (1 << j)) + pcf50606_irq_call_handler(pcf, (i * 8) + j); + } + +out: + put_device(pcf->dev); + enable_irq(pcf->irq); +} + +static irqreturn_t pcf50606_irq(int irq, void *data) +{ + struct pcf50606 *pcf = data; + + get_device(pcf->dev); + disable_irq(pcf->irq); + schedule_work(&pcf->irq_work); + + return IRQ_HANDLED; +} + +static void +pcf50606_client_dev_register(struct pcf50606 *pcf, const char *name, + struct platform_device **pdev) +{ + struct pcf50606_subdev_pdata subdev_pdata; + int ret; + + *pdev = platform_device_alloc(name, -1); + if (!*pdev) { + dev_err(pcf->dev, "Falied to allocate %s\n", name); + return; + } + + subdev_pdata.pcf = pcf; + platform_device_add_data(*pdev, &subdev_pdata, sizeof(subdev_pdata)); + + (*pdev)->dev.parent = pcf->dev; + + ret = platform_device_add(*pdev); + if (ret) { + dev_err(pcf->dev, "Failed to register %s: %d\n", name, ret); + platform_device_put(*pdev); + *pdev = NULL; + } +} + +#ifdef CONFIG_PM +static int pcf50606_suspend(struct device *dev, pm_message_t state) +{ + struct pcf50606 *pcf; + int ret, i; + u8 res[3]; + + pcf = dev_get_drvdata(dev); + + /* Make sure our interrupt handlers are not called + * henceforth */ + disable_irq(pcf->irq); + + /* Make sure that any running IRQ worker has quit */ + cancel_work_sync(&pcf->irq_work); + + /* Save the masks */ + ret = pcf50606_read_block(pcf, PCF50606_REG_INT1M, + ARRAY_SIZE(pcf->suspend_irq_masks), + pcf->suspend_irq_masks); + if (ret < 0) { + dev_err(pcf->dev, "error saving irq masks\n"); + goto out; + } + + /* Write wakeup irq masks */ + for (i = 0; i < ARRAY_SIZE(res); i++) + res[i] = ~pcf->pdata->resumers[i]; + + ret = pcf50606_write_block(pcf, PCF50606_REG_INT1M, + ARRAY_SIZE(res), &res[0]); + if (ret < 0) { + dev_err(pcf->dev, "error writing wakeup irq masks\n"); + goto out; + } + + pcf->is_suspended = 1; + +out: + return ret; +} + +static int pcf50606_resume(struct device *dev) +{ + struct pcf50606 *pcf; + int ret; + + pcf = dev_get_drvdata(dev); + + /* Write the saved mask registers */ + ret = pcf50606_write_block(pcf, PCF50606_REG_INT1M, + ARRAY_SIZE(pcf->suspend_irq_masks), + pcf->suspend_irq_masks); + if (ret < 0) + dev_err(pcf->dev, "Error restoring saved suspend masks\n"); + + get_device(pcf->dev); + + /* + * Clear any pending interrupts and set resume reason if any. + * This will leave with enable_irq() + */ + pcf50606_irq_worker(&pcf->irq_work); + + return 0; +} +#else +#define pcf50606_suspend NULL +#define pcf50606_resume NULL +#endif + +static int pcf50606_probe(struct i2c_client *client, + const struct i2c_device_id *ids) +{ + struct pcf50606 *pcf; + struct pcf50606_platform_data *pdata = client->dev.platform_data; + int i, ret = 0; + int version, variant; + + pcf = kzalloc(sizeof(*pcf), GFP_KERNEL); + if (!pcf) + return -ENOMEM; + + pcf->pdata = pdata; + + mutex_init(&pcf->lock); + + i2c_set_clientdata(client, pcf); + pcf->dev = &client->dev; + pcf->i2c_client = client; + pcf->irq = client->irq; + + INIT_WORK(&pcf->irq_work, pcf50606_irq_worker); + + version = pcf50606_reg_read(pcf, 0); + variant = pcf50606_reg_read(pcf, 1); + if (version < 0 || variant < 0) { + dev_err(pcf->dev, "Unable to probe pcf50606\n"); + ret = -ENODEV; + goto err; + } + + dev_info(pcf->dev, "Probed device version %d variant %d\n", + version, variant); + /* Enable all inteerupts except RTC SECOND */ + pcf->mask_regs[0] = 0x40; + pcf50606_reg_write(pcf, PCF50606_REG_INT1M, pcf->mask_regs[0]); + pcf50606_reg_write(pcf, PCF50606_REG_INT2M, 0x00); + pcf50606_reg_write(pcf, PCF50606_REG_INT3M, 0x00); + + pcf50606_client_dev_register(pcf, "pcf50606-input", + &pcf->input_pdev); + pcf50606_client_dev_register(pcf, "pcf50606-rtc", + &pcf->rtc_pdev); + pcf50606_client_dev_register(pcf, "pcf50606-mbc", + &pcf->mbc_pdev); + pcf50606_client_dev_register(pcf, "pcf50606-adc", + &pcf->adc_pdev); + pcf50606_client_dev_register(pcf, "pcf50606-wdt", + &pcf->wdt_pdev); + for (i = 0; i < PCF50606_NUM_REGULATORS; i++) { + struct platform_device *pdev; + + pdev = platform_device_alloc("pcf50606-regltr", i); + if (!pdev) { + dev_err(pcf->dev, "Cannot create regulator\n"); + continue; + } + + pdev->dev.parent = pcf->dev; + pdev->dev.platform_data = &pdata->reg_init_data[i]; + pdev->dev.driver_data = pcf; + pcf->regulator_pdev[i] = pdev; + + platform_device_add(pdev); + } + + if (client->irq) { + set_irq_handler(client->irq, handle_level_irq); + ret = request_irq(client->irq, pcf50606_irq, + IRQF_TRIGGER_LOW, "pcf50606", pcf); + + if (ret) { + dev_err(pcf->dev, "Failed to request IRQ %d\n", ret); + goto err; + } + } else { + dev_err(pcf->dev, "No IRQ configured\n"); + goto err; + } + + if (enable_irq_wake(client->irq) < 0) + dev_err(pcf->dev, "IRQ %u cannot be enabled as wake-up source" + "in this hardware revision", client->irq); + + ret = sysfs_create_group(&client->dev.kobj, &pcf_attr_group); + if (ret) + dev_err(pcf->dev, "error creating sysfs entries\n"); + + if (pdata->probe_done) + pdata->probe_done(pcf); + + return 0; + +err: + kfree(pcf); + return ret; +} + +static int pcf50606_remove(struct i2c_client *client) +{ + struct pcf50606 *pcf = i2c_get_clientdata(client); + int i; + + free_irq(pcf->irq, pcf); + + platform_device_unregister(pcf->input_pdev); + platform_device_unregister(pcf->rtc_pdev); + platform_device_unregister(pcf->mbc_pdev); + platform_device_unregister(pcf->adc_pdev); + + for (i = 0; i < PCF50606_NUM_REGULATORS; i++) + platform_device_unregister(pcf->regulator_pdev[i]); + + kfree(pcf); + + return 0; +} + +static struct i2c_device_id pcf50606_id_table[] = { + {"pcf50606", 0x08}, +}; + +static struct i2c_driver pcf50606_driver = { + .driver = { + .name = "pcf50606", + .suspend = pcf50606_suspend, + .resume = pcf50606_resume, + }, + .id_table = pcf50606_id_table, + .probe = pcf50606_probe, + .remove = pcf50606_remove, +}; + +static int __init pcf50606_init(void) +{ + return i2c_add_driver(&pcf50606_driver); +} + +static void pcf50606_exit(void) +{ + i2c_del_driver(&pcf50606_driver); +} + +MODULE_DESCRIPTION("I2C chip driver for NXP PCF50606 PMU"); +MODULE_AUTHOR("Harald Welte "); +MODULE_LICENSE("GPL"); + +module_init(pcf50606_init); +module_exit(pcf50606_exit); diff --git a/drivers/mfd/pcf50606-gpo.c b/drivers/mfd/pcf50606-gpo.c new file mode 100644 index 00000000000..3510f8b48e9 --- /dev/null +++ b/drivers/mfd/pcf50606-gpo.c @@ -0,0 +1,119 @@ +/* Philips PCF50606 GPO Driver + * + * (C) 2006-2008 by Openmoko, Inc. + * Author: Balaji Rao + * All rights reserved. + * + * Broken down from monstrous PCF50606 driver mainly by + * Harald Welte, Andy Green Werner Almesberger and Matt Hsu + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + */ + +#include + +#include +#include + +void pcf50606_gpo_set_active(struct pcf50606 *pcf, int gpo, int val) +{ + u8 reg, value, mask; + + reg = gpo; + value = val; + mask = 0x07; + + if (gpo == PCF50606_GPO2) { + value = val << 4; + mask = 0x07 << 4; + } + pcf50606_reg_set_bit_mask(pcf, reg, mask, value); +} +EXPORT_SYMBOL_GPL(pcf50606_gpo_set_active); + +int pcf50606_gpo_get_active(struct pcf50606 *pcf, int gpo) +{ + u8 reg, value, shift = 0; + + reg = gpo; + if (gpo == PCF50606_GPO2) + shift = 4; + + value = pcf50606_reg_read(pcf, reg); + + return (value >> shift) & 0x07; +} +EXPORT_SYMBOL_GPL(pcf50606_gpo_get_active); + +void pcf50606_gpo_set_standby(struct pcf50606 *pcf, int gpo, int val) +{ + u8 reg; + + if (gpo == PCF50606_GPO1 || gpo == PCF50606_GPO2) { + dev_err(pcf->dev, "Can't set standby settings for GPO[12]n"); + return; + } + + reg = gpo; + + pcf50606_reg_set_bit_mask(pcf, gpo, 0x07 << 3, val); +} +EXPORT_SYMBOL_GPL(pcf50606_gpo_set_standby); + +int pcf50606_gpo_get_standby(struct pcf50606 *pcf, int gpo) +{ + u8 reg, value; + + if (gpo == PCF50606_GPO1 || gpo == PCF50606_GPO2) { + dev_err(pcf->dev, "Can't get standby settings for GPO[12]n"); + return -EINVAL; + } + + reg = gpo; + value = pcf50606_reg_read(pcf, reg); + + return (value >> 3) & 0x07; +} +EXPORT_SYMBOL_GPL(pcf50606_gpo_get_standby); + +void pcf50606_gpo_invert_set(struct pcf50606 *pcf, int gpo, int invert) +{ + u8 reg, value, mask; + + reg = gpo; + value = !!invert << 6; + mask = 0x01 << 6; + + if (gpo == PCF50606_GPO1) { + mask = 0x01 << 4; + value = !!invert << 4; + } + else if (gpo == PCF50606_GPO2) { + mask = 0x01 << 7; + value = !!invert << 7; + } + + pcf50606_reg_set_bit_mask(pcf, reg, mask, value); +} +EXPORT_SYMBOL_GPL(pcf50606_gpo_invert_set); + +int pcf50606_gpo_invert_get(struct pcf50606 *pcf, int gpo) +{ + u8 reg, value, shift; + + reg = gpo; + shift = 6; + + if (gpo == PCF50606_GPO1) + shift = 4; + else if (gpo == PCF50606_GPO2) + shift = 7; + + value = pcf50606_reg_read(pcf, reg); + + return (value >> shift) & 0x01; +} +EXPORT_SYMBOL_GPL(pcf50606_gpo_invert_get); diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig index bdbc4f73fcd..60a0813936d 100644 --- a/drivers/power/Kconfig +++ b/drivers/power/Kconfig @@ -103,4 +103,10 @@ config CHARGER_PCF50633 help Say Y to include support for NXP PCF50633 Main Battery Charger. +config CHARGER_PCF50606 + tristate "Support for NXP PCF50606 MBC" + depends on MFD_PCF50606 + help + Say Y to include support for NXP PCF50606 Battery Charger. + endif # POWER_SUPPLY diff --git a/drivers/power/Makefile b/drivers/power/Makefile index 380d17c9ae2..5e992240d61 100644 --- a/drivers/power/Makefile +++ b/drivers/power/Makefile @@ -28,3 +28,4 @@ obj-$(CONFIG_BATTERY_BQ27x00) += bq27x00_battery.o obj-$(CONFIG_BATTERY_DA9030) += da9030_battery.o obj-$(CONFIG_BATTERY_MAX17040) += max17040_battery.o obj-$(CONFIG_CHARGER_PCF50633) += pcf50633-charger.o +obj-$(CONFIG_CHARGER_PCF50606) += pcf50606-charger.o diff --git a/drivers/power/pcf50606-charger.c b/drivers/power/pcf50606-charger.c new file mode 100644 index 00000000000..a566fe3ed56 --- /dev/null +++ b/drivers/power/pcf50606-charger.c @@ -0,0 +1,244 @@ +/* NXP PCF50606 Main Battery Charger Driver + * + * (C) 2006-2008 by Openmoko, Inc. + * Author: Balaji Rao + * All rights reserved. + * + * Broken down from monstrous PCF50606 driver mainly by + * Harald Welte, Andy Green and Werner Almesberger + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +struct pcf50606_mbc { + struct pcf50606 *pcf; + + int charger_online; + struct power_supply charger; +}; + +void pcf50606_charge_fast(struct pcf50606 *pcf, int on) +{ + struct pcf50606_mbc *mbc = platform_get_drvdata(pcf->mbc_pdev); + + /* + * This is a fix to work around boot-time ordering problems if + * the s3c2410_udc is initialized before the pcf50606 mbc is + * ready. + */ + if (!mbc) + return; + + if (on) { + pcf50606_reg_set_bit_mask(pcf, PCF50606_REG_MBCC1, + PCF50606_MBCC1_AUTOFST, + PCF50606_MBCC1_AUTOFST);\ + mbc->charger_online = 1; + } else { + /* disable automatic fast-charge */ + pcf50606_reg_clear_bits(pcf, PCF50606_REG_MBCC1, + PCF50606_MBCC1_AUTOFST); + /* switch to idle mode to abort existing charge process */ + pcf50606_reg_set_bit_mask(pcf, PCF50606_REG_MBCC1, + PCF50606_MBCC1_CHGMOD_MASK, + PCF50606_MBCC1_CHGMOD_IDLE); + mbc->charger_online = 0; + } +} +EXPORT_SYMBOL_GPL(pcf50606_charge_fast); + +static ssize_t +show_chgmode(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct pcf50606_mbc *mbc = dev_get_drvdata(dev); + + u8 mbcc1 = pcf50606_reg_read(mbc->pcf, PCF50606_REG_MBCC1); + u8 chgmod = (mbcc1 & PCF50606_MBCC1_CHGMOD_MASK); + + return sprintf(buf, "%d\n", chgmod); +} + +static ssize_t set_chgmode(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + struct pcf50606_mbc *mbc = dev_get_drvdata(dev); + u_int8_t mbcc1 = pcf50606_reg_read(mbc->pcf, PCF50606_REG_MBCC1); + + mbcc1 &= ~PCF50606_MBCC1_CHGMOD_MASK; + + if (!strcmp(buf, "qualification")) + mbcc1 |= PCF50606_MBCC1_CHGMOD_QUAL; + else if (!strcmp(buf, "pre")) + mbcc1 |= PCF50606_MBCC1_CHGMOD_PRE; + else if (!strcmp(buf, "trickle")) + mbcc1 |= PCF50606_MBCC1_CHGMOD_TRICKLE; + else if (!strcmp(buf, "fast_cccv")) + mbcc1 |= PCF50606_MBCC1_CHGMOD_FAST_CCCV; + /* We don't allow the other fast modes for security reasons */ + else if (!strcmp(buf, "idle")) + mbcc1 |= PCF50606_MBCC1_CHGMOD_IDLE; + else + return -EINVAL; + + pcf50606_reg_write(mbc->pcf, PCF50606_REG_MBCC1, mbcc1); + + return count; +} + +static DEVICE_ATTR(chgmode, S_IRUGO, show_chgmode, set_chgmode); + + +static struct attribute *pcf50606_mbc_sysfs_entries[] = { + &dev_attr_chgmode.attr, + NULL, +}; + +static struct attribute_group mbc_attr_group = { + .name = NULL, /* put in device directory */ + .attrs = pcf50606_mbc_sysfs_entries, +}; + +static void +pcf50606_mbc_irq_handler(int irq, void *data) +{ + struct pcf50606_mbc *mbc = data; + + power_supply_changed(&mbc->charger); + + if (mbc->pcf->pdata->mbc_event_callback) + mbc->pcf->pdata->mbc_event_callback(mbc->pcf, irq); +} + +static int charger_get_property(struct power_supply *psy, + enum power_supply_property psp, + union power_supply_propval *val) +{ + struct pcf50606_mbc *mbc = container_of(psy, struct pcf50606_mbc, charger); + int ret = 0; + + switch (psp) { + case POWER_SUPPLY_PROP_ONLINE: + val->intval = mbc->charger_online; + break; + default: + ret = -EINVAL; + break; + } + return ret; +} + +static enum power_supply_property power_props[] = { + POWER_SUPPLY_PROP_ONLINE, +}; + +static const u8 mbc_irq_handlers[] = { + PCF50606_IRQ_CHGINS, + PCF50606_IRQ_CHGRM, + PCF50606_IRQ_CHGFOK, + PCF50606_IRQ_CHGERR, + PCF50606_IRQ_CHGFRDY, + PCF50606_IRQ_CHGPROT, +}; + +static int __devinit pcf50606_mbc_probe(struct platform_device *pdev) +{ + struct pcf50606_mbc *mbc; + struct pcf50606_subdev_pdata *pdata = pdev->dev.platform_data; + int ret; + int i; + u8 oocs; + + mbc = kzalloc(sizeof(*mbc), GFP_KERNEL); + if (!mbc) + return -ENOMEM; + + platform_set_drvdata(pdev, mbc); + mbc->pcf = pdata->pcf; + + /* Set up IRQ handlers */ + for (i = 0; i < ARRAY_SIZE(mbc_irq_handlers); i++) + pcf50606_register_irq(mbc->pcf, mbc_irq_handlers[i], + pcf50606_mbc_irq_handler, mbc); + + mbc->charger.name = "charger"; + mbc->charger.type = POWER_SUPPLY_TYPE_MAINS; + mbc->charger.properties = power_props; + mbc->charger.num_properties = ARRAY_SIZE(power_props); + mbc->charger.get_property = &charger_get_property; + mbc->charger.supplied_to = mbc->pcf->pdata->batteries; + mbc->charger.num_supplicants = mbc->pcf->pdata->num_batteries; + + ret = power_supply_register(&pdev->dev, &mbc->charger); + if (ret) { + dev_err(mbc->pcf->dev, "failed to register charger\n"); + kfree(mbc); + return ret; + } + + ret = sysfs_create_group(&pdev->dev.kobj, &mbc_attr_group); + if (ret) + dev_err(mbc->pcf->dev, "failed to create sysfs entries\n"); + + oocs = pcf50606_reg_read(mbc->pcf, PCF50606_REG_OOCS); + if (oocs & PCF50606_OOCS_CHGOK) + pcf50606_mbc_irq_handler(PCF50606_IRQ_CHGINS, mbc); + + return 0; +} + +static int __devexit pcf50606_mbc_remove(struct platform_device *pdev) +{ + struct pcf50606_mbc *mbc = platform_get_drvdata(pdev); + int i; + + /* Remove IRQ handlers */ + for (i = 0; i < ARRAY_SIZE(mbc_irq_handlers); i++) + pcf50606_free_irq(mbc->pcf, mbc_irq_handlers[i]); + + power_supply_unregister(&mbc->charger); + + kfree(mbc); + + return 0; +} + +static struct platform_driver pcf50606_mbc_driver = { + .driver = { + .name = "pcf50606-mbc", + }, + .probe = pcf50606_mbc_probe, + .remove = __devexit_p(pcf50606_mbc_remove), +}; + +static int __init pcf50606_mbc_init(void) +{ + return platform_driver_register(&pcf50606_mbc_driver); +} +module_init(pcf50606_mbc_init); + +static void __exit pcf50606_mbc_exit(void) +{ + platform_driver_unregister(&pcf50606_mbc_driver); +} +module_exit(pcf50606_mbc_exit); + +MODULE_AUTHOR("Balaji Rao "); +MODULE_DESCRIPTION("PCF50606 mbc driver"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:pcf50606-mbc"); diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig index f4317798e47..29f34a4de25 100644 --- a/drivers/regulator/Kconfig +++ b/drivers/regulator/Kconfig @@ -117,4 +117,10 @@ config REGULATOR_LP3971 Say Y here to support the voltage regulators and convertors on National Semiconductors LP3971 PMIC +config REGULATOR_PCF50606 + bool "PCF50606 regulator driver" + depends on MFD_PCF50606 + help + Say Y here to support the voltage regulators and convertors + on PCF50606 endif diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile index 4d762c4cccf..ac5b42ae95c 100644 --- a/drivers/regulator/Makefile +++ b/drivers/regulator/Makefile @@ -16,5 +16,6 @@ obj-$(CONFIG_REGULATOR_WM8350) += wm8350-regulator.o obj-$(CONFIG_REGULATOR_WM8400) += wm8400-regulator.o obj-$(CONFIG_REGULATOR_DA903X) += da903x.o obj-$(CONFIG_REGULATOR_PCF50633) += pcf50633-regulator.o +obj-$(CONFIG_REGULATOR_PCF50606) += pcf50606-regulator.o ccflags-$(CONFIG_REGULATOR_DEBUG) += -DDEBUG diff --git a/drivers/regulator/pcf50606-regulator.c b/drivers/regulator/pcf50606-regulator.c new file mode 100644 index 00000000000..58d020ef93c --- /dev/null +++ b/drivers/regulator/pcf50606-regulator.c @@ -0,0 +1,381 @@ +/* NXP PCF50606 PMIC Driver + * + * (C) 2006-2008 by Openmoko, Inc. + * Author: Balaji Rao + * All rights reserved. + * + * Broken down from monstrous PCF50606 driver mainly by + * Harald Welte and Andy Green and Werner Almesberger + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + */ + +#include +#include +#include +#include +#include +#include + +#include +#include + +#define PCF50606_REGULATOR(_name, _id) \ + { \ + .name = _name, \ + .id = _id, \ + .ops = &pcf50606_regulator_ops, \ + .type = REGULATOR_VOLTAGE, \ + .owner = THIS_MODULE, \ + } + +static const u8 pcf50606_regulator_registers[PCF50606_NUM_REGULATORS] = { + [PCF50606_REGULATOR_DCD] = PCF50606_REG_DCDC1, + [PCF50606_REGULATOR_DCDE] = PCF50606_REG_DCDEC1, + [PCF50606_REGULATOR_DCUD] = PCF50606_REG_DCUDC1, + [PCF50606_REGULATOR_D1REG] = PCF50606_REG_D1REGC1, + [PCF50606_REGULATOR_D2REG] = PCF50606_REG_D2REGC1, + [PCF50606_REGULATOR_D3REG] = PCF50606_REG_D3REGC1, + [PCF50606_REGULATOR_LPREG] = PCF50606_REG_LPREGC1, + [PCF50606_REGULATOR_IOREG] = PCF50606_REG_IOREGC, +}; + +static u8 dcudc_voltage(unsigned int millivolts) +{ + if (millivolts < 900) + return 0; + if (millivolts > 5500) + return 0x1f; + if (millivolts <= 3300) { + millivolts -= 900; + return millivolts/300; + } + if (millivolts < 4000) + return 0x0f; + else { + millivolts -= 4000; + return millivolts/100; + } +} + +static unsigned int dcudc_2voltage(u8 bits) +{ + bits &= 0x1f; + if (bits < 0x08) + return 900 + bits * 300; + else if (bits < 0x10) + return 3300; + else + return 4000 + bits * 100; +} + +static u8 dcdec_voltage(unsigned int millivolts) +{ + if (millivolts < 900) + return 0; + else if (millivolts > 3300) + return 0x0f; + + millivolts -= 900; + return millivolts/300; +} + +static unsigned int dcdec_2voltage(u8 bits) +{ + bits &= 0x0f; + return 900 + bits*300; +} + +static u8 dcdc_voltage(unsigned int millivolts) +{ + if (millivolts < 900) + return 0; + else if (millivolts > 3600) + return 0x1f; + + if (millivolts < 1500) { + millivolts -= 900; + return millivolts/25; + } else { + millivolts -= 1500; + return 0x18 + millivolts/300; + } +} + +static unsigned int dcdc_2voltage(u8 bits) +{ + bits &= 0x1f; + if ((bits & 0x18) == 0x18) + return 1500 + ((bits & 0x7) * 300); + else + return 900 + (bits * 25); +} + +static u8 dx_voltage(unsigned int millivolts) +{ + if (millivolts < 900) + return 0; + else if (millivolts > 3300) + return 0x18; + + millivolts -= 900; + return millivolts/100; +} + +static unsigned int dx_2voltage(u8 bits) +{ + bits &= 0x1f; + return 900 + (bits * 100); +} + +static int pcf50606_regulator_set_voltage(struct regulator_dev *rdev, + int min_uV, int max_uV) +{ + struct pcf50606 *pcf; + int regulator_id, millivolts, rc; + u8 volt_bits, regnr; + + pcf = rdev_get_drvdata(rdev); + + regulator_id = rdev_get_id(rdev); + if (regulator_id >= PCF50606_NUM_REGULATORS) + return -EINVAL; + + millivolts = min_uV / 1000; + + switch (regulator_id) { + case PCF50606_REGULATOR_DCD: + volt_bits = dcdc_voltage(millivolts); + rc = pcf50606_reg_set_bit_mask(pcf, PCF50606_REG_DCDC1, 0x1f, + volt_bits); + break; + case PCF50606_REGULATOR_DCDE: + volt_bits = dcdec_voltage(millivolts); + rc = pcf50606_reg_set_bit_mask(pcf, PCF50606_REG_DCDEC1, 0x0f, + volt_bits); + break; + case PCF50606_REGULATOR_DCUD: + volt_bits = dcudc_voltage(millivolts); + rc = pcf50606_reg_set_bit_mask(pcf, PCF50606_REG_DCUDC1, 0x1f, + volt_bits); + break; + case PCF50606_REGULATOR_D1REG: + case PCF50606_REGULATOR_D2REG: + case PCF50606_REGULATOR_D3REG: + regnr = PCF50606_REG_D1REGC1 + + (regulator_id - PCF50606_REGULATOR_D1REG); + volt_bits = dx_voltage(millivolts); + rc = pcf50606_reg_set_bit_mask(pcf, regnr, 0x1f, volt_bits); + break; + case PCF50606_REGULATOR_LPREG: + volt_bits = dx_voltage(millivolts); + rc = pcf50606_reg_set_bit_mask(pcf, PCF50606_REG_LPREGC1, 0x1f, + volt_bits); + break; + case PCF50606_REGULATOR_IOREG: + if (millivolts < 1800) + return -EINVAL; + volt_bits = dx_voltage(millivolts); + rc = pcf50606_reg_set_bit_mask(pcf, PCF50606_REG_IOREGC, 0x1f, + volt_bits); + break; + default: + return -EINVAL; + } + + return rc; +} + +static int pcf50606_regulator_get_voltage(struct regulator_dev *rdev) +{ + struct pcf50606 *pcf; + u8 volt_bits, regnr; + int rc = 0, regulator_id; + + + pcf = rdev_get_drvdata(rdev); + + regulator_id = rdev_get_id(rdev); + if (regulator_id >= PCF50606_NUM_REGULATORS) + return -EINVAL; + + switch (regulator_id) { + case PCF50606_REGULATOR_DCD: + volt_bits = pcf50606_reg_read(pcf, PCF50606_REG_DCDC1) & 0x1f; + rc = dcdc_2voltage(volt_bits); + break; + case PCF50606_REGULATOR_DCDE: + volt_bits = pcf50606_reg_read(pcf, PCF50606_REG_DCDEC1) & 0x0f; + rc = dcdec_2voltage(volt_bits); + break; + case PCF50606_REGULATOR_DCUD: + volt_bits = pcf50606_reg_read(pcf, PCF50606_REG_DCUDC1) & 0x1f; + rc = dcudc_2voltage(volt_bits); + break; + case PCF50606_REGULATOR_D1REG: + case PCF50606_REGULATOR_D2REG: + case PCF50606_REGULATOR_D3REG: + regnr = PCF50606_REG_D1REGC1 + (regulator_id - PCF50606_REGULATOR_D1REG); + volt_bits = pcf50606_reg_read(pcf, regnr) & 0x1f; + if (volt_bits > 0x18) + volt_bits = 0x18; + rc = dx_2voltage(volt_bits); + break; + case PCF50606_REGULATOR_LPREG: + volt_bits = pcf50606_reg_read(pcf, PCF50606_REG_LPREGC1) & 0x1f; + if (volt_bits > 0x18) + volt_bits = 0x18; + rc = dx_2voltage(volt_bits); + break; + case PCF50606_REGULATOR_IOREG: + volt_bits = pcf50606_reg_read(pcf, PCF50606_REG_IOREGC) & 0x1f; + if (volt_bits > 0x18) + volt_bits = 0x18; + rc = dx_2voltage(volt_bits); + break; + default: + return -EINVAL; + } + + return rc * 1000; + +} + +static int pcf50606_regulator_enable(struct regulator_dev *rdev) +{ + struct pcf50606 *pcf = rdev_get_drvdata(rdev); + int regulator_id; + u8 regnr; + + regulator_id = rdev_get_id(rdev); + if (regulator_id >= PCF50606_NUM_REGULATORS) + return -EINVAL; + + regnr = pcf50606_regulator_registers[regulator_id]; + + return pcf50606_reg_set_bit_mask(pcf, regnr, 0xe0, 0xe0); +} + +static int pcf50606_regulator_disable(struct regulator_dev *rdev) +{ + struct pcf50606 *pcf = rdev_get_drvdata(rdev); + int regulator_id; + u8 regnr; + + regulator_id = rdev_get_id(rdev); + if (regulator_id >= PCF50606_NUM_REGULATORS) + return -EINVAL; + + /* IOREG cannot be powered off since it powers the PMU I2C */ + if (regulator_id == PCF50606_REGULATOR_IOREG) + return -EINVAL; + + regnr = pcf50606_regulator_registers[regulator_id]; + + return pcf50606_reg_set_bit_mask(pcf, regnr, 0xe0, 0); +} + +static int pcf50606_regulator_is_enabled(struct regulator_dev *rdev) +{ + struct pcf50606 *pcf = rdev_get_drvdata(rdev); + int regulator_id = rdev_get_id(rdev); + u8 regnr, val; + + regulator_id = rdev_get_id(rdev); + if (regulator_id >= PCF50606_NUM_REGULATORS) + return -EINVAL; + + /* the *ENA register is always one after the *OUT register */ + regnr = pcf50606_regulator_registers[regulator_id]; + val = (pcf50606_reg_read(pcf, regnr) & 0xe0) >> 5; + + /* PWREN1 = 1, PWREN2 = 1, see table 16 of datasheet */ + if (val == 0 || val == 5) + return 0; + + return 1; +} + +static struct regulator_ops pcf50606_regulator_ops = { + .set_voltage = pcf50606_regulator_set_voltage, + .get_voltage = pcf50606_regulator_get_voltage, + .enable = pcf50606_regulator_enable, + .disable = pcf50606_regulator_disable, + .is_enabled = pcf50606_regulator_is_enabled, +}; + +static struct regulator_desc regulators[] = { + [PCF50606_REGULATOR_DCD] = + PCF50606_REGULATOR("dcd", PCF50606_REGULATOR_DCD), + [PCF50606_REGULATOR_DCDE] = + PCF50606_REGULATOR("dcde", PCF50606_REGULATOR_DCDE), + [PCF50606_REGULATOR_DCUD] = + PCF50606_REGULATOR("dcud", PCF50606_REGULATOR_DCUD), + [PCF50606_REGULATOR_D1REG] = + PCF50606_REGULATOR("d1reg", PCF50606_REGULATOR_D1REG), + [PCF50606_REGULATOR_D2REG] = + PCF50606_REGULATOR("d2reg", PCF50606_REGULATOR_D2REG), + [PCF50606_REGULATOR_D3REG] = + PCF50606_REGULATOR("d3reg", PCF50606_REGULATOR_D3REG), + [PCF50606_REGULATOR_LPREG] = + PCF50606_REGULATOR("lpreg", PCF50606_REGULATOR_LPREG), + [PCF50606_REGULATOR_IOREG] = + PCF50606_REGULATOR("ioreg", PCF50606_REGULATOR_IOREG), +}; + +static int __devinit pcf50606_regulator_probe(struct platform_device *pdev) +{ + struct regulator_dev *rdev; + struct pcf50606 *pcf; + + /* Already set by core driver */ + pcf = platform_get_drvdata(pdev); + + rdev = regulator_register(®ulators[pdev->id], &pdev->dev, + pdev->dev.platform_data, pcf); + if (IS_ERR(rdev)) + return PTR_ERR(rdev); + + if (pcf->pdata->regulator_registered) + pcf->pdata->regulator_registered(pcf, pdev->id); + + return 0; +} + +static int __devexit pcf50606_regulator_remove(struct platform_device *pdev) +{ + struct regulator_dev *rdev = platform_get_drvdata(pdev); + + regulator_unregister(rdev); + + return 0; +} + +static struct platform_driver pcf50606_regulator_driver = { + .driver = { + .name = "pcf50606-regltr", + }, + .probe = pcf50606_regulator_probe, + .remove = __devexit_p(pcf50606_regulator_remove), +}; + +static int __init pcf50606_regulator_init(void) +{ + return platform_driver_register(&pcf50606_regulator_driver); +} +module_init(pcf50606_regulator_init); + +static void __exit pcf50606_regulator_exit(void) +{ + platform_driver_unregister(&pcf50606_regulator_driver); +} +module_exit(pcf50606_regulator_exit); + +MODULE_AUTHOR("Balaji Rao "); +MODULE_DESCRIPTION("PCF50606 regulator driver"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:pcf50606-regulator"); diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig index 81adbdbd504..7e0a1a4763e 100644 --- a/drivers/rtc/Kconfig +++ b/drivers/rtc/Kconfig @@ -535,6 +535,13 @@ config RTC_DRV_PCF50633 If you say yes here you get support for the RTC subsystem of the NXP PCF50633 used in embedded systems. +config RTC_DRV_PCF50606 + depends on MFD_PCF50606 + tristate "NXP PCF50606 RTC" + help + If you say yes here you get support for the RTC subsystem of the + NXP PCF50606 used in embedded systems. + comment "on-CPU RTC drivers" config RTC_DRV_OMAP diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile index 3c0f2b2ac92..8082cbfcfa5 100644 --- a/drivers/rtc/Makefile +++ b/drivers/rtc/Makefile @@ -77,4 +77,5 @@ obj-$(CONFIG_RTC_DRV_VR41XX) += rtc-vr41xx.o obj-$(CONFIG_RTC_DRV_WM8350) += rtc-wm8350.o obj-$(CONFIG_RTC_DRV_X1205) += rtc-x1205.o obj-$(CONFIG_RTC_DRV_PCF50633) += rtc-pcf50633.o +obj-$(CONFIG_RTC_DRV_PCF50606) += rtc-pcf50606.o obj-$(CONFIG_RTC_DRV_PS3) += rtc-ps3.o diff --git a/drivers/rtc/rtc-pcf50606.c b/drivers/rtc/rtc-pcf50606.c new file mode 100644 index 00000000000..6bd93b0b672 --- /dev/null +++ b/drivers/rtc/rtc-pcf50606.c @@ -0,0 +1,342 @@ +/* NXP PCF50606 RTC Driver + * + * (C) 2006-2008 by Openmoko, Inc. + * Author: Balaji Rao + * All rights reserved. + * + * Broken down from monstrous PCF50606 driver mainly by + * Harald Welte, Andy Green and Werner Almesberger + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define PCF50606_REG_RTCSC 0x0a /* Second */ +#define PCF50606_REG_RTCMN 0x0b /* Minute */ +#define PCF50606_REG_RTCHR 0x0c /* Hour */ +#define PCF50606_REG_RTCWD 0x0d /* Weekday */ +#define PCF50606_REG_RTCDT 0x0e /* Day */ +#define PCF50606_REG_RTCMT 0x0f /* Month */ +#define PCF50606_REG_RTCYR 0x10 /* Year */ +#define PCF50606_REG_RTCSCA 0x11 /* Alarm Second */ +#define PCF50606_REG_RTCMNA 0x12 /* Alarm Minute */ +#define PCF50606_REG_RTCHRA 0x13 /* Alarm Hour */ +#define PCF50606_REG_RTCWDA 0x14 /* Alarm Weekday */ +#define PCF50606_REG_RTCDTA 0x15 /* Alarm Day */ +#define PCF50606_REG_RTCMTA 0x16 /* Alarm Month */ +#define PCF50606_REG_RTCYRA 0x17 /* Alarm Year */ + +enum pcf50606_time_indexes { + PCF50606_TI_SEC, + PCF50606_TI_MIN, + PCF50606_TI_HOUR, + PCF50606_TI_WKDAY, + PCF50606_TI_DAY, + PCF50606_TI_MONTH, + PCF50606_TI_YEAR, + PCF50606_TI_EXTENT /* always last */ +}; + +struct pcf50606_time { + u_int8_t time[PCF50606_TI_EXTENT]; +}; + +struct pcf50606_rtc { + int alarm_enabled; + int second_enabled; + int alarm_pending; + + struct pcf50606 *pcf; + struct rtc_device *rtc_dev; +}; + +static void pcf2rtc_time(struct rtc_time *rtc, struct pcf50606_time *pcf) +{ + rtc->tm_sec = bcd2bin(pcf->time[PCF50606_TI_SEC]); + rtc->tm_min = bcd2bin(pcf->time[PCF50606_TI_MIN]); + rtc->tm_hour = bcd2bin(pcf->time[PCF50606_TI_HOUR]); + rtc->tm_wday = bcd2bin(pcf->time[PCF50606_TI_WKDAY]); + rtc->tm_mday = bcd2bin(pcf->time[PCF50606_TI_DAY]); + rtc->tm_mon = bcd2bin(pcf->time[PCF50606_TI_MONTH]) - 1; + rtc->tm_year = bcd2bin(pcf->time[PCF50606_TI_YEAR]) + 100; +} + +static void rtc2pcf_time(struct pcf50606_time *pcf, struct rtc_time *rtc) +{ + pcf->time[PCF50606_TI_SEC] = bin2bcd(rtc->tm_sec); + pcf->time[PCF50606_TI_MIN] = bin2bcd(rtc->tm_min); + pcf->time[PCF50606_TI_HOUR] = bin2bcd(rtc->tm_hour); + pcf->time[PCF50606_TI_WKDAY] = bin2bcd(rtc->tm_wday); + pcf->time[PCF50606_TI_DAY] = bin2bcd(rtc->tm_mday); + pcf->time[PCF50606_TI_MONTH] = bin2bcd(rtc->tm_mon + 1); + pcf->time[PCF50606_TI_YEAR] = bin2bcd(rtc->tm_year % 100); +} + +static int +pcf50606_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) +{ + struct pcf50606_rtc *rtc = dev_get_drvdata(dev); + + switch (cmd) { + case RTC_AIE_OFF: + rtc->alarm_enabled = 0; + pcf50606_irq_mask(rtc->pcf, PCF50606_IRQ_ALARM); + return 0; + case RTC_AIE_ON: + rtc->alarm_enabled = 1; + pcf50606_irq_unmask(rtc->pcf, PCF50606_IRQ_ALARM); + return 0; + case RTC_UIE_OFF: + rtc->second_enabled = 0; + pcf50606_irq_mask(rtc->pcf, PCF50606_IRQ_SECOND); + return 0; + case RTC_UIE_ON: + rtc->second_enabled = 1; + pcf50606_irq_unmask(rtc->pcf, PCF50606_IRQ_SECOND); + return 0; + } + + return -ENOIOCTLCMD; +} + +static int pcf50606_rtc_read_time(struct device *dev, struct rtc_time *tm) +{ + struct pcf50606_rtc *rtc; + struct pcf50606_time pcf_tm; + int ret; + + rtc = dev_get_drvdata(dev); + + ret = pcf50606_read_block(rtc->pcf, PCF50606_REG_RTCSC, + PCF50606_TI_EXTENT, + &pcf_tm.time[0]); + if (ret != PCF50606_TI_EXTENT) { + dev_err(dev, "Failed to read time\n"); + return -EIO; + } + + dev_dbg(dev, "PCF_TIME: %02x.%02x.%02x %02x:%02x:%02x\n", + pcf_tm.time[PCF50606_TI_DAY], + pcf_tm.time[PCF50606_TI_MONTH], + pcf_tm.time[PCF50606_TI_YEAR], + pcf_tm.time[PCF50606_TI_HOUR], + pcf_tm.time[PCF50606_TI_MIN], + pcf_tm.time[PCF50606_TI_SEC]); + + pcf2rtc_time(tm, &pcf_tm); + + dev_dbg(dev, "RTC_TIME: %u.%u.%u %u:%u:%u\n", + tm->tm_mday, tm->tm_mon, tm->tm_year, + tm->tm_hour, tm->tm_min, tm->tm_sec); + + return rtc_valid_tm(tm); +} + +static int pcf50606_rtc_set_time(struct device *dev, struct rtc_time *tm) +{ + struct pcf50606_rtc *rtc; + struct pcf50606_time pcf_tm; + int second_masked, alarm_masked, ret = 0; + + rtc = dev_get_drvdata(dev); + + dev_dbg(dev, "RTC_TIME: %u.%u.%u %u:%u:%u\n", + tm->tm_mday, tm->tm_mon, tm->tm_year, + tm->tm_hour, tm->tm_min, tm->tm_sec); + + rtc2pcf_time(&pcf_tm, tm); + + dev_dbg(dev, "PCF_TIME: %02x.%02x.%02x %02x:%02x:%02x\n", + pcf_tm.time[PCF50606_TI_DAY], + pcf_tm.time[PCF50606_TI_MONTH], + pcf_tm.time[PCF50606_TI_YEAR], + pcf_tm.time[PCF50606_TI_HOUR], + pcf_tm.time[PCF50606_TI_MIN], + pcf_tm.time[PCF50606_TI_SEC]); + + + second_masked = pcf50606_irq_mask_get(rtc->pcf, PCF50606_IRQ_SECOND); + alarm_masked = pcf50606_irq_mask_get(rtc->pcf, PCF50606_IRQ_ALARM); + + if (!second_masked) + pcf50606_irq_mask(rtc->pcf, PCF50606_IRQ_SECOND); + if (!alarm_masked) + pcf50606_irq_mask(rtc->pcf, PCF50606_IRQ_ALARM); + + /* Returns 0 on success */ + ret = pcf50606_write_block(rtc->pcf, PCF50606_REG_RTCSC, + PCF50606_TI_EXTENT, + &pcf_tm.time[0]); + + if (!second_masked) + pcf50606_irq_unmask(rtc->pcf, PCF50606_IRQ_SECOND); + if (!alarm_masked) + pcf50606_irq_unmask(rtc->pcf, PCF50606_IRQ_ALARM); + + return ret; +} + +static int pcf50606_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) +{ + struct pcf50606_rtc *rtc; + struct pcf50606_time pcf_tm; + int ret = 0; + + rtc = dev_get_drvdata(dev); + + alrm->enabled = rtc->alarm_enabled; + alrm->pending = rtc->alarm_pending; + + ret = pcf50606_read_block(rtc->pcf, PCF50606_REG_RTCSCA, + PCF50606_TI_EXTENT, &pcf_tm.time[0]); + if (ret != PCF50606_TI_EXTENT) { + dev_err(dev, "Failed to read time\n"); + return -EIO; + } + + pcf2rtc_time(&alrm->time, &pcf_tm); + + return rtc_valid_tm(&alrm->time); +} + +static int pcf50606_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) +{ + struct pcf50606_rtc *rtc; + struct pcf50606_time pcf_tm; + int alarm_masked, ret = 0; + + rtc = dev_get_drvdata(dev); + + rtc2pcf_time(&pcf_tm, &alrm->time); + + /* do like mktime does and ignore tm_wday */ + pcf_tm.time[PCF50606_TI_WKDAY] = 7; + + alarm_masked = pcf50606_irq_mask_get(rtc->pcf, PCF50606_IRQ_ALARM); + + /* disable alarm interrupt */ + if (!alarm_masked) + pcf50606_irq_mask(rtc->pcf, PCF50606_IRQ_ALARM); + + /* Returns 0 on success */ + ret = pcf50606_write_block(rtc->pcf, PCF50606_REG_RTCSCA, + PCF50606_TI_EXTENT, &pcf_tm.time[0]); + + if (!alrm->enabled) + rtc->alarm_pending = 0; + + if (!alarm_masked || alrm->enabled) + pcf50606_irq_unmask(rtc->pcf, PCF50606_IRQ_ALARM); + rtc->alarm_enabled = alrm->enabled; + + return ret; +} + +static struct rtc_class_ops pcf50606_rtc_ops = { + .ioctl = pcf50606_rtc_ioctl, + .read_time = pcf50606_rtc_read_time, + .set_time = pcf50606_rtc_set_time, + .read_alarm = pcf50606_rtc_read_alarm, + .set_alarm = pcf50606_rtc_set_alarm, +}; + +static void pcf50606_rtc_irq(int irq, void *data) +{ + struct pcf50606_rtc *rtc = data; + + switch (irq) { + case PCF50606_IRQ_ALARM: + rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF); + rtc->alarm_pending = 1; + break; + case PCF50606_IRQ_SECOND: + rtc_update_irq(rtc->rtc_dev, 1, RTC_UF | RTC_IRQF); + break; + } +} + +static int __devinit pcf50606_rtc_probe(struct platform_device *pdev) +{ + struct pcf50606_subdev_pdata *pdata; + struct pcf50606_rtc *rtc; + + + rtc = kzalloc(sizeof(*rtc), GFP_KERNEL); + if (!rtc) + return -ENOMEM; + + pdata = pdev->dev.platform_data; + rtc->pcf = pdata->pcf; + platform_set_drvdata(pdev, rtc); + rtc->rtc_dev = rtc_device_register("pcf50606-rtc", &pdev->dev, + &pcf50606_rtc_ops, THIS_MODULE); + + if (IS_ERR(rtc->rtc_dev)) { + kfree(rtc); + return PTR_ERR(rtc->rtc_dev); + } + + pcf50606_register_irq(rtc->pcf, PCF50606_IRQ_ALARM, + pcf50606_rtc_irq, rtc); + pcf50606_register_irq(rtc->pcf, PCF50606_IRQ_SECOND, + pcf50606_rtc_irq, rtc); + + return 0; +} + + +static int __devexit pcf50606_rtc_remove(struct platform_device *pdev) +{ + struct pcf50606_rtc *rtc; + + rtc = platform_get_drvdata(pdev); + + pcf50606_free_irq(rtc->pcf, PCF50606_IRQ_ALARM); + pcf50606_free_irq(rtc->pcf, PCF50606_IRQ_SECOND); + + rtc_device_unregister(rtc->rtc_dev); + + kfree(rtc); + + return 0; +} + + +static struct platform_driver pcf50606_rtc_driver = { + .driver = { + .name = "pcf50606-rtc", + }, + .probe = pcf50606_rtc_probe, + .remove = __devexit_p(pcf50606_rtc_remove), +}; + +static int __init pcf50606_rtc_init(void) +{ + return platform_driver_register(&pcf50606_rtc_driver); +} +module_init(pcf50606_rtc_init); + +static void __exit pcf50606_rtc_exit(void) +{ + platform_driver_unregister(&pcf50606_rtc_driver); +} +module_exit(pcf50606_rtc_exit); + +MODULE_DESCRIPTION("PCF50606 RTC driver"); +MODULE_AUTHOR("Balaji Rao "); +MODULE_LICENSE("GPL"); + diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig index b1ccc04f3c9..618cc10acc6 100644 --- a/drivers/watchdog/Kconfig +++ b/drivers/watchdog/Kconfig @@ -154,6 +154,13 @@ config S3C2410_WATCHDOG The driver can be built as a module by choosing M, and will be called s3c2410_wdt +config PCF50606_WATCHDOG + depends on MFD_PCF50606 + tristate "Philips PCF50606 watchdog" + help + If you say yes here you get support for the Philips PCF50606 + PMU's watchdog. + config SA1100_WATCHDOG tristate "SA1100/PXA2xx watchdog" depends on ARCH_SA1100 || ARCH_PXA diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile index 3d774294a2b..638e1c1d743 100644 --- a/drivers/watchdog/Makefile +++ b/drivers/watchdog/Makefile @@ -35,6 +35,7 @@ obj-$(CONFIG_IXP2000_WATCHDOG) += ixp2000_wdt.o obj-$(CONFIG_IXP4XX_WATCHDOG) += ixp4xx_wdt.o obj-$(CONFIG_KS8695_WATCHDOG) += ks8695_wdt.o obj-$(CONFIG_S3C2410_WATCHDOG) += s3c2410_wdt.o +obj-$(CONFIG_PCF50606_WATCHDOG) += pcf50606_wdt.o obj-$(CONFIG_SA1100_WATCHDOG) += sa1100_wdt.o obj-$(CONFIG_MPCORE_WATCHDOG) += mpcore_wdt.o obj-$(CONFIG_EP93XX_WATCHDOG) += ep93xx_wdt.o diff --git a/drivers/watchdog/pcf50606_wdt.c b/drivers/watchdog/pcf50606_wdt.c new file mode 100644 index 00000000000..f0858747bf9 --- /dev/null +++ b/drivers/watchdog/pcf50606_wdt.c @@ -0,0 +1,223 @@ +/* Philips PCF50606 Watchdog Timer Driver + * + * (C) 2006-2008 by Openmoko, Inc. + * Author: Balaji Rao + * All rights reserved. + * + * Broken down from monstrous PCF50606 driver mainly by + * Harald Welte, Matt Hsu, Andy Green and Werner Almesberger + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +static struct pcf50606 *pcf = NULL; +static unsigned long wdt_status; + +#define WDT_IN_USE 0 +#define WDT_OK_TO_CLOSE 1 +#define WDT_REGION_INITED 2 +#define WDT_DEVICE_INITED 3 + +static int allow_close; +#define CLOSE_STATE_NOT 0x0000 +#define CLOSE_STATE_ALLOW 0x2342 + +#define PCF50606_REG_OOCC1 0x08 +#define PCF50606_REG_OOCS 0x01 + +#define PCF50606_OOCS_WDTEXP 0x80 +#define PCF50606_OOCC1_WDTRST 0x08 + +static void pcf50606_wdt_start(void) +{ + pcf50606_reg_set_bit_mask(pcf, PCF50606_REG_OOCC1, PCF50606_OOCC1_WDTRST, + PCF50606_OOCC1_WDTRST); +} + +static void pcf50606_wdt_stop(void) +{ + pcf50606_reg_clear_bits(pcf, PCF50606_REG_OOCS, PCF50606_OOCS_WDTEXP); +} + +static void pcf50606_wdt_keepalive(void) +{ + pcf50606_wdt_start(); +} + +static int pcf50606_wdt_open(struct inode *inode, struct file *file) +{ + if (test_and_set_bit(WDT_IN_USE, &wdt_status)) + return -EBUSY; + + pcf50606_wdt_start(); + + return nonseekable_open(inode, file); +} + +static int pcf50606_wdt_release(struct inode *inode, struct file *file) +{ + if (allow_close == CLOSE_STATE_ALLOW) + pcf50606_wdt_stop(); + else { + printk(KERN_CRIT "Unexpected close, not stopping watchdog!\n"); + pcf50606_wdt_keepalive(); + } + + allow_close = CLOSE_STATE_NOT; + clear_bit(WDT_IN_USE, &wdt_status); + + return 0; +} + +static ssize_t pcf50606_wdt_write(struct file *file, const char __user *data, + size_t len, loff_t *ppos) +{ + if (len) { + size_t i; + + for (i = 0; i != len; i++) { + char c; + if (get_user(c, data + i)) + return -EFAULT; + if (c == 'V') + allow_close = CLOSE_STATE_ALLOW; + } + pcf50606_wdt_keepalive(); + } + + return len; +} + +static struct watchdog_info pcf50606_wdt_ident = { + .options = WDIOF_MAGICCLOSE, + .firmware_version = 0, + .identity = "PCF50606 Watchdog", +}; + +static int pcf50606_wdt_ioctl(struct inode *inode, struct file *file, + unsigned int cmd, unsigned long arg) +{ + void __user *argp = (void __user *)arg; + int __user *p = argp; + + switch (cmd) { + case WDIOC_GETSUPPORT: + return copy_to_user(argp, &pcf50606_wdt_ident, + sizeof(pcf50606_wdt_ident)) ? -EFAULT : 0; + break; + case WDIOC_GETSTATUS: + case WDIOC_GETBOOTSTATUS: + return put_user(0, p); + case WDIOC_KEEPALIVE: + pcf50606_wdt_keepalive(); + return 0; + case WDIOC_GETTIMEOUT: + return put_user(8, p); + default: + return -ENOIOCTLCMD; + } +} + +static struct file_operations pcf50606_wdt_fops = { + .owner = THIS_MODULE, + .llseek = no_llseek, + .write = &pcf50606_wdt_write, + .ioctl = &pcf50606_wdt_ioctl, + .open = &pcf50606_wdt_open, + .release = &pcf50606_wdt_release, +}; + +static struct miscdevice pcf50606_wdt_miscdev = { + .minor = WATCHDOG_MINOR, + .name = "watchdog", + .fops = &pcf50606_wdt_fops, +}; + +static void pcf50606_wdt_irq(int irq, void *unused) +{ + pcf50606_reg_set_bit_mask(pcf, PCF50606_REG_OOCC1, + PCF50606_OOCC1_WDTRST, + PCF50606_OOCC1_WDTRST); +} + +int __init pcf50606_wdt_probe(struct platform_device *pdev) +{ + struct pcf50606_subdev_pdata *pdata; + int err; + + if (pcf) { + dev_err(pcf->dev, "Only one instance of WDT supported\n"); + return -ENODEV; + } + + pdata = pdev->dev.platform_data; + if (!pdata) { + dev_err(&pdev->dev, "No platform data available\n"); + return -EINVAL; + } + + pcf = pdata->pcf; + + err = misc_register(&pcf50606_wdt_miscdev); + if (err) { + dev_err(&pdev->dev, "cannot register miscdev on " + "minor=%d (%d)\n", WATCHDOG_MINOR, err); + return err; + } + set_bit(WDT_DEVICE_INITED, &wdt_status); + + pcf50606_register_irq(pcf, PCF50606_IRQ_CHGWD10S, pcf50606_wdt_irq, NULL); + + return 0; +} + +static int __devexit pcf50606_wdt_remove(struct platform_device *pdev) +{ + pcf50606_free_irq(pcf, PCF50606_IRQ_CHGWD10S); + misc_deregister(&pcf50606_wdt_miscdev); + pcf = NULL; + + return 0; +} + +struct platform_driver pcf50606_wdt_driver = { + .driver = { + .name = "pcf50606-wdt", + }, + .probe = pcf50606_wdt_probe, + .remove = __devexit_p(pcf50606_wdt_remove), +}; + +static int __init pcf50606_wdt_init(void) +{ + return platform_driver_register(&pcf50606_wdt_driver); +} +module_init(pcf50606_wdt_init); + +static void __exit pcf50606_wdt_exit(void) +{ + platform_driver_unregister(&pcf50606_wdt_driver); +} +module_exit(pcf50606_wdt_exit); + +MODULE_AUTHOR("Balaji Rao "); +MODULE_DESCRIPTION("PCF50606 wdt driver"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:pcf50606-wdt"); + diff --git a/include/linux/mfd/pcf50606/adc.h b/include/linux/mfd/pcf50606/adc.h new file mode 100644 index 00000000000..fd4840300dd --- /dev/null +++ b/include/linux/mfd/pcf50606/adc.h @@ -0,0 +1,72 @@ +/* + * adc.h -- Driver for NXP PCF50606 ADC + * + * (C) 2006-2008 by Openmoko, Inc. + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + */ + +#ifndef __LINUX_MFD_PCF50606_ADC_H +#define __LINUX_MFD_PCF50606_ADC_H + +#include +#include + +/* ADC Registers */ +#define PCF50606_REG_ADCC1 0x2e +#define PCF50606_REG_ADCC2 0x2f +#define PCF50606_REG_ADCS1 0x30 +#define PCF50606_REG_ADCS2 0x31 +#define PCF50606_REG_ADCS3 0x32 + +#define PCF50606_ADCC1_TSCMODACT 0x01 +#define PCF50606_ADCC1_TSCMODSTB 0x02 +#define PCF50606_ADCC1_TRATSET 0x04 +#define PCF50606_ADCC1_NTCSWAPE 0x08 +#define PCF50606_ADCC1_NTCSWAOFF 0x10 +#define PCF50606_ADCC1_EXTSYNCBREAK 0x20 + /* reserved */ +#define PCF50606_ADCC1_TSCINT 0x80 + +#define PCF50606_ADCC2_ADCSTART 0x01 + /* see enum pcf50606_adcc2_adcmux */ +#define PCF50606_ADCC2_SYNC_NONE 0x00 +#define PCF50606_ADCC2_SYNC_TXON 0x20 +#define PCF50606_ADCC2_SYNC_PWREN1 0x40 +#define PCF50606_ADCC2_SYNC_PWREN2 0x60 +#define PCF50606_ADCC2_RES_10BIT 0x00 +#define PCF50606_ADCC2_RES_8BIT 0x80 + +#define PCF50606_ADCC2_ADCMUX_MASK (0xf << 1) + +#define ADCMUX_SHIFT 1 +#define PCF50606_ADCMUX_BATVOLT_RES (0x0 << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_BATVOLT_SUBTR (0x1 << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_ADCIN1_RES (0x2 << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_ADCIN1_SUBTR (0x3 << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_BATTEMP (0x4 << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_ADCIN2 (0x5 << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_ADCIN3 (0x6 << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_ADCIN3_RATIO (0x7 << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_XPOS (0x8 << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_YPOS (0x9 << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_P1 (0xa << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_P2 (0xb << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_BATVOLT_ADCIN1 (0xc << ADCMUX_SHIFT) +#define PCF50606_ADCMUX_XY_SEQUENCE (0xe << ADCMUX_SHIFT) +#define PCF50606_P1_P2_RESISTANCE (0xf << ADCMUX_SHIFT) + +#define PCF50606_ADCS2_ADCRDY 0x80 + +extern int +pcf50606_adc_async_read(struct pcf50606 *pcf, int mux, + void (*callback)(struct pcf50606 *, void *, int), + void *callback_param); +extern int +pcf50606_adc_sync_read(struct pcf50606 *pcf, int mux); + +#endif /* __LINUX_PCF50606_ADC_H */ diff --git a/include/linux/mfd/pcf50606/core.h b/include/linux/mfd/pcf50606/core.h new file mode 100644 index 00000000000..a51b1b548c2 --- /dev/null +++ b/include/linux/mfd/pcf50606/core.h @@ -0,0 +1,170 @@ +/* + * core.h -- Core driver for NXP PCF50606 + * + * (C) 2006-2008 by Openmoko, Inc. + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + */ + +#ifndef __LINUX_MFD_PCF50606_CORE_H +#define __LINUX_MFD_PCF50606_CORE_H + +#include +#include +#include +#include +#include + +struct pcf50606; + +#define PCF50606_NUM_REGULATORS 8 + +struct pcf50606_platform_data { + struct regulator_init_data reg_init_data[PCF50606_NUM_REGULATORS]; + + char **batteries; + int num_batteries; + + /* Callbacks */ + void (*probe_done)(struct pcf50606 *); + void (*mbc_event_callback)(struct pcf50606 *, int); + void (*regulator_registered)(struct pcf50606 *, int); + void (*force_shutdown)(struct pcf50606 *); + + u8 resumers[3]; +}; + +struct pcf50606_subdev_pdata { + struct pcf50606 *pcf; +}; + +struct pcf50606_irq { + void (*handler)(int, void *); + void *data; +}; + +int pcf50606_register_irq(struct pcf50606 *pcf, int irq, + void (*handler) (int, void *), void *data); +int pcf50606_free_irq(struct pcf50606 *pcf, int irq); + +int pcf50606_irq_mask(struct pcf50606 *pcf, int irq); +int pcf50606_irq_unmask(struct pcf50606 *pcf, int irq); +int pcf50606_irq_mask_get(struct pcf50606 *pcf, int irq); + +int pcf50606_read_block(struct pcf50606 *, u8 reg, + int nr_regs, u8 *data); +int pcf50606_write_block(struct pcf50606 *pcf, u8 reg, + int nr_regs, u8 *data); +u8 pcf50606_reg_read(struct pcf50606 *, u8 reg); +int pcf50606_reg_write(struct pcf50606 *pcf, u8 reg, u8 val); + +int pcf50606_reg_set_bit_mask(struct pcf50606 *pcf, u8 reg, u8 mask, u8 val); +int pcf50606_reg_clear_bits(struct pcf50606 *pcf, u8 reg, u8 bits); + +/* Interrupt registers */ + +#define PCF50606_REG_INT1 0x02 +#define PCF50606_REG_INT2 0x03 +#define PCF50606_REG_INT3 0x04 + +#define PCF50606_REG_INT1M 0x05 +#define PCF50606_REG_INT2M 0x06 +#define PCF50606_REG_INT3M 0x07 + +enum { + /* Chip IRQs */ + PCF50606_IRQ_ONKEYR, + PCF50606_IRQ_ONKEYF, + PCF50606_IRQ_ONKEY1S, + PCF50606_IRQ_EXTONR, + PCF50606_IRQ_EXTONF, + PCF50606_IRQ_RESERVED_1, + PCF50606_IRQ_SECOND, + PCF50606_IRQ_ALARM, + PCF50606_IRQ_CHGINS, + PCF50606_IRQ_CHGRM, + PCF50606_IRQ_CHGFOK, + PCF50606_IRQ_CHGERR, + PCF50606_IRQ_CHGFRDY, + PCF50606_IRQ_CHGPROT, + PCF50606_IRQ_CHGWD10S, + PCF50606_IRQ_CHGWDEXP, + PCF50606_IRQ_ADCRDY, + PCF50606_IRQ_ACDINS, + PCF50606_IRQ_ACDREM, + PCF50606_IRQ_TSCPRES, + PCF50606_IRQ_RESERVED_2, + PCF50606_IRQ_RESERVED_3, + PCF50606_IRQ_LOWBAT, + PCF50606_IRQ_HIGHTMP, + + /* Always last */ + PCF50606_NUM_IRQ, +}; + +struct pcf50606 { + struct device *dev; + struct i2c_client *i2c_client; + + struct pcf50606_platform_data *pdata; + int irq; + struct pcf50606_irq irq_handler[PCF50606_NUM_IRQ]; + struct work_struct irq_work; + struct mutex lock; + + u8 mask_regs[3]; + + u8 suspend_irq_masks[3]; + u8 resume_reason[3]; + int is_suspended; + + int onkey1s_held; + + struct platform_device *rtc_pdev; + struct platform_device *mbc_pdev; + struct platform_device *adc_pdev; + struct platform_device *input_pdev; + struct platform_device *wdt_pdev; + struct platform_device *regulator_pdev[PCF50606_NUM_REGULATORS]; +}; + +enum pcf50606_reg_int1 { + PCF50606_INT1_ONKEYR = 0x01, /* ONKEY rising edge */ + PCF50606_INT1_ONKEYF = 0x02, /* ONKEY falling edge */ + PCF50606_INT1_ONKEY1S = 0x04, /* OMKEY at least 1sec low */ + PCF50606_INT1_EXTONR = 0x08, /* EXTON rising edge */ + PCF50606_INT1_EXTONF = 0x10, /* EXTON falling edge */ + PCF50606_INT1_SECOND = 0x40, /* RTC periodic second interrupt */ + PCF50606_INT1_ALARM = 0x80, /* RTC alarm time is reached */ +}; + +enum pcf50606_reg_int2 { + PCF50606_INT2_CHGINS = 0x01, /* Charger inserted */ + PCF50606_INT2_CHGRM = 0x02, /* Charger removed */ + PCF50606_INT2_CHGFOK = 0x04, /* Fast charging OK */ + PCF50606_INT2_CHGERR = 0x08, /* Error in charging mode */ + PCF50606_INT2_CHGFRDY = 0x10, /* Fast charge completed */ + PCF50606_INT2_CHGPROT = 0x20, /* Charging protection interrupt */ + PCF50606_INT2_CHGWD10S = 0x40, /* Charger watchdig expires in 10s */ + PCF50606_INT2_CHGWDEXP = 0x80, /* Charger watchdog expires */ +}; + +enum pcf50606_reg_int3 { + PCF50606_INT3_ADCRDY = 0x01, /* ADC conversion finished */ + PCF50606_INT3_ACDINS = 0x02, /* Accessory inserted */ + PCF50606_INT3_ACDREM = 0x04, /* Accessory removed */ + PCF50606_INT3_TSCPRES = 0x08, /* Touch screen pressed */ + PCF50606_INT3_LOWBAT = 0x40, /* Low battery voltage */ + PCF50606_INT3_HIGHTMP = 0x80, /* High temperature */ +}; + +/* Misc regs */ + +#define PCF50606_REG_OOCC1 0x08 +#define PCF50606_OOCC1_GOSTDBY 0x01 +#endif + diff --git a/include/linux/mfd/pcf50606/gpo.h b/include/linux/mfd/pcf50606/gpo.h new file mode 100644 index 00000000000..081b127d754 --- /dev/null +++ b/include/linux/mfd/pcf50606/gpo.h @@ -0,0 +1,42 @@ +/* + * gpo.h -- GPO driver for NXP PCF50606 + * + * (C) 2006-2008 by Openmoko, Inc. + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + */ + +#ifndef __LINUX_MFD_PCF50606_GPO_H +#define __LINUX_MFD_PCF50606_GPO_H + +#include + +#define PCF50606_REG_GPOC1 0x38 +#define PCF50606_REG_GPOC2 0x39 +#define PCF50606_REG_GPOC3 0x3a +#define PCF50606_REG_GPOC4 0x3b +#define PCF50606_REG_GPOC5 0x3c + +#define PCF50606_GPO1 PCF50606_REG_GPOC1 +#define PCF50606_GPO2 PCF50606_REG_GPOC1 +#define PCF50606_GPOOD1 PCF50606_REG_GPOC2 +#define PCF50606_GPOOD2 PCF50606_REG_GPOC3 +#define PCF50606_GPOOD3 PCF50606_REG_GPOC4 +#define PCF50606_GPOOD4 PCF50606_REG_GPOC5 + +#define PCF50606_GPOCFG_GPOSEL_MASK 0x07 + +void pcf50606_gpo_set_active(struct pcf50606 *pcf, int gpo, int value); +int pcf50606_gpo_get_active(struct pcf50606 *pcf, int gpo); +void pcf50606_gpo_set_standby(struct pcf50606 *pcf, int gpo, int value); +int pcf50606_gpo_get_standby(struct pcf50606 *pcf, int gpo); + +void pcf50606_gpo_invert_set(struct pcf50606 *, int gpo, int invert); +int pcf50606_gpo_invert_get(struct pcf50606 *pcf, int gpo); + +#endif /* __LINUX_MFD_PCF50606_GPIO_H */ + diff --git a/include/linux/mfd/pcf50606/mbc.h b/include/linux/mfd/pcf50606/mbc.h new file mode 100644 index 00000000000..b793d703a64 --- /dev/null +++ b/include/linux/mfd/pcf50606/mbc.h @@ -0,0 +1,52 @@ +/* + * mbc.h -- Driver for NXP PCF50606 Main Battery Charger + * + * (C) 2006-2008 by Openmoko, Inc. + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + */ + +#ifndef __LINUX_MFD_PCF50606_MBC_H +#define __LINUX_MFD_PCF50606_MBC_H + +#include +#include + +#define PCF50606_REG_OOCS 0x01 + +/* Charger OK */ +#define PCF50606_OOCS_CHGOK 0x20 + +#define PCF50606_REG_MBCC1 0x29 +#define PCF50606_REG_MBCC2 0x2a +#define PCF50606_REG_MBCC3 0x2b +#define PCF50606_REG_MBCS1 0x2c + +#define PCF50606_MBCC1_CHGAPE 0x01 +#define PCF50606_MBCC1_AUTOFST 0x02 +#define PCF50606_MBCC1_CHGMOD_MASK 0x1c +#define PCF50606_MBCC1_CHGMOD_QUAL 0x00 +#define PCF50606_MBCC1_CHGMOD_PRE 0x04 +#define PCF50606_MBCC1_CHGMOD_TRICKLE 0x08 +#define PCF50606_MBCC1_CHGMOD_FAST_CCCV 0x0c +#define PCF50606_MBCC1_CHGMOD_FAST_NOCC 0x10 +#define PCF50606_MBCC1_CHGMOD_FAST_NOCV 0x14 +#define PCF50606_MBCC1_CHGMOD_FAST_SW 0x18 +#define PCF50606_MBCC1_CHGMOD_IDLE 0x1c +#define PCF50606_MBCC1_DETMOD_LOWCHG 0x20 +#define PCF50606_MBCC1_DETMOD_WDRST 0x40 + +#define PCF50606_MBCC1_CHGMOD_SHIFT 2 + +/* Charger status */ +#define PCF50606_MBC_CHARGER_ONLINE 0x01 +#define PCF50606_MBC_CHARGER_ACTIVE 0x02 + +void pcf50606_charge_fast(struct pcf50606 *pcf, int on); + +#endif + diff --git a/include/linux/mfd/pcf50606/pmic.h b/include/linux/mfd/pcf50606/pmic.h new file mode 100644 index 00000000000..1bcfe39025b --- /dev/null +++ b/include/linux/mfd/pcf50606/pmic.h @@ -0,0 +1,73 @@ +#ifndef __LINUX_MFD_PCF50606_PMIC_H +#define __LINUX_MFD_PCF50606_PMIC_H + +#define PCF50606_REG_DCDC1 0x1b +#define PCF50606_REG_DCDC2 0x1c +#define PCF50606_REG_DCDC3 0x1d +#define PCF50606_REG_DCDC4 0x1e +#define PCF50606_REG_DCDEC1 0x1f +#define PCF50606_REG_DCDEC2 0x20 +#define PCF50606_REG_DCUDC1 0x21 +#define PCF50606_REG_DCUDC2 0x22 +#define PCF50606_REG_IOREGC 0x23 +#define PCF50606_REG_D1REGC1 0x24 +#define PCF50606_REG_D2REGC1 0x25 +#define PCF50606_REG_D3REGC1 0x26 +#define PCF50606_REG_LPREGC1 0x27 +#define PCF50606_REG_LPREGC2 0x28 + +/* used by PSSC, PWROKM, PWROKS, */ +enum pcf50606_regu { + PCF50606_REGU_DCD = 0x01, /* DCD in phase 2 */ + PCF50606_REGU_DCDE = 0x02, /* DCDE in phase 2 */ + PCF50606_REGU_DCUD = 0x04, /* DCDU in phase 2 */ + PCF50606_REGU_IO = 0x08, /* IO in phase 2 */ + PCF50606_REGU_D1 = 0x10, /* D1 in phase 2 */ + PCF50606_REGU_D2 = 0x20, /* D2 in phase 2 */ + PCF50606_REGU_D3 = 0x40, /* D3 in phase 2 */ + PCF50606_REGU_LP = 0x80, /* LP in phase 2 */ +}; + +enum pcf50606_reg_dcdc4 { + PCF50606_DCDC4_MODE_AUTO = 0x00, + PCF50606_DCDC4_MODE_PWM = 0x01, + PCF50606_DCDC4_MODE_PCF = 0x02, + PCF50606_DCDC4_OFF_FLOAT = 0x00, + PCF50606_DCDC4_OFF_BYPASS = 0x04, + PCF50606_DCDC4_OFF_PULLDOWN = 0x08, + PCF50606_DCDC4_CURLIM_500mA = 0x00, + PCF50606_DCDC4_CURLIM_750mA = 0x10, + PCF50606_DCDC4_CURLIM_1000mA = 0x20, + PCF50606_DCDC4_CURLIM_1250mA = 0x30, + PCF50606_DCDC4_TOGGLE = 0x40, + PCF50606_DCDC4_REGSEL_DCDC2 = 0x80, +}; + +enum pcf50606_reg_dcdec2 { + PCF50606_DCDEC2_MODE_AUTO = 0x00, + PCF50606_DCDEC2_MODE_PWM = 0x01, + PCF50606_DCDEC2_MODE_PCF = 0x02, + PCF50606_DCDEC2_OFF_FLOAT = 0x00, + PCF50606_DCDEC2_OFF_BYPASS = 0x04, +}; + +enum pcf50606_reg_dcudc2 { + PCF50606_DCUDC2_MODE_AUTO = 0x00, + PCF50606_DCUDC2_MODE_PWM = 0x01, + PCF50606_DCUDC2_MODE_PCF = 0x02, + PCF50606_DCUDC2_OFF_FLOAT = 0x00, + PCF50606_DCUDC2_OFF_BYPASS = 0x04, +}; + +enum pcf50606_regulator_id { + PCF50606_REGULATOR_DCD, + PCF50606_REGULATOR_DCDE, + PCF50606_REGULATOR_DCUD, + PCF50606_REGULATOR_D1REG, + PCF50606_REGULATOR_D2REG, + PCF50606_REGULATOR_D3REG, + PCF50606_REGULATOR_LPREG, + PCF50606_REGULATOR_IOREG, +}; + +#endif -- cgit v1.2.3