Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d50f8f33 authored by Haojian Zhuang's avatar Haojian Zhuang Committed by Samuel Ortiz
Browse files

mfd: Initial max8925 support 



Basic Max8925 support, which is a power management IC from Maxim
Semiconductor.

Signed-off-by: default avatarHaojian Zhuang <haojian.zhuang@marvell.com>
Signed-off-by: default avatarSamuel Ortiz <sameo@linux.intel.com>
parent 34a4b239

drivers/mfd/Kconfig

+9 −0
Original line number Diff line number Diff line
@@ -194,6 +194,15 @@ config PMIC_ADP5520 
	  individual components like LCD backlight, LEDs, GPIOs and Kepad

	  under the corresponding menus.



config MFD_MAX8925

	tristate "Maxim Semiconductor MAX8925 PMIC Support"

	depends on I2C

	help

	  Say yes here to support for Maxim Semiconductor MAX8925. This is

	  a Power Management IC. This driver provies common support for

	  accessing the device, additional drivers must be enabled in order

	  to use the functionality of the device.



config MFD_WM8400

	tristate "Support Wolfson Microelectronics WM8400"

	select MFD_CORE

drivers/mfd/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -49,6 +49,8 @@ endif 
obj-$(CONFIG_UCB1400_CORE)	+= ucb1400_core.o



obj-$(CONFIG_PMIC_DA903X)	+= da903x.o

max8925-objs			:= max8925-core.o max8925-i2c.o

obj-$(CONFIG_MFD_MAX8925)	+= max8925.o



obj-$(CONFIG_MFD_PCF50633)	+= pcf50633-core.o

obj-$(CONFIG_PCF50633_ADC)	+= pcf50633-adc.o

drivers/mfd/max8925-core.c

0 → 100644
+262 −0
Original line number Diff line number Diff line 
/*

 * Base driver for Maxim MAX8925

 *

 * Copyright (C) 2009 Marvell International Ltd.

 *	Haojian Zhuang <haojian.zhuang@marvell.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */



#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/i2c.h>

#include <linux/interrupt.h>

#include <linux/platform_device.h>

#include <linux/mfd/core.h>

#include <linux/mfd/max8925.h>



#define IRQ_MODE_STATUS		0

#define IRQ_MODE_MASK		1



static int __get_irq_offset(struct max8925_chip *chip, int irq, int mode,

			    int *offset, int *bit)

{

	if (!offset || !bit)

		return -EINVAL;



	switch (chip->chip_id) {

	case MAX8925_GPM:

		*bit = irq % BITS_PER_BYTE;

		if (irq < (BITS_PER_BYTE << 1)) {	/* irq = [0,15] */

			*offset = (mode) ? MAX8925_CHG_IRQ1_MASK

				: MAX8925_CHG_IRQ1;

			if (irq >= BITS_PER_BYTE)

				(*offset)++;

		} else {				/* irq = [16,31] */

			*offset = (mode) ? MAX8925_ON_OFF_IRQ1_MASK

				: MAX8925_ON_OFF_IRQ1;

			if (irq >= (BITS_PER_BYTE * 3))

				(*offset)++;

		}

		break;

	case MAX8925_ADC:

		*bit = irq % BITS_PER_BYTE;

		*offset = (mode) ? MAX8925_TSC_IRQ_MASK : MAX8925_TSC_IRQ;

		break;

	default:

		goto out;

	}

	return 0;

out:

	dev_err(chip->dev, "Wrong irq #%d is assigned\n", irq);

	return -EINVAL;

}



static int __check_irq(int irq)

{

	if ((irq < 0) || (irq >= MAX8925_NUM_IRQ))

		return -EINVAL;

	return 0;

}



int max8925_mask_irq(struct max8925_chip *chip, int irq)

{

	int offset, bit, ret;



	ret = __get_irq_offset(chip, irq, IRQ_MODE_MASK, &offset, &bit);

	if (ret < 0)

		return ret;

	ret = max8925_set_bits(chip->i2c, offset, 1 << bit, 1 << bit);

	return ret;

}



int max8925_unmask_irq(struct max8925_chip *chip, int irq)

{

	int offset, bit, ret;



	ret = __get_irq_offset(chip, irq, IRQ_MODE_MASK, &offset, &bit);

	if (ret < 0)

		return ret;

	ret = max8925_set_bits(chip->i2c, offset, 1 << bit, 0);

	return ret;

}



#define INT_STATUS_NUM		(MAX8925_NUM_IRQ / BITS_PER_BYTE)



static irqreturn_t max8925_irq_thread(int irq, void *data)

{

	struct max8925_chip *chip = data;

	unsigned long irq_status[INT_STATUS_NUM];

	unsigned char status_buf[INT_STATUS_NUM << 1];

	int i, ret;



	memset(irq_status, 0, sizeof(unsigned long) * INT_STATUS_NUM);



	/* all these interrupt status registers are read-only */

	switch (chip->chip_id) {

	case MAX8925_GPM:

		ret = max8925_bulk_read(chip->i2c, MAX8925_CHG_IRQ1,

					4, status_buf);

		if (ret < 0)

			goto out;

		ret = max8925_bulk_read(chip->i2c, MAX8925_ON_OFF_IRQ1,

					2, &status_buf[4]);

		if (ret < 0)

			goto out;

		ret = max8925_bulk_read(chip->i2c, MAX8925_ON_OFF_IRQ2,

					2, &status_buf[6]);

		if (ret < 0)

			goto out;

		/* clear masked interrupt status */

		status_buf[0] &= (~status_buf[2] & CHG_IRQ1_MASK);

		irq_status[0] |= status_buf[0];

		status_buf[1] &= (~status_buf[3] & CHG_IRQ2_MASK);

		irq_status[0] |= (status_buf[1] << BITS_PER_BYTE);

		status_buf[4] &= (~status_buf[5] & ON_OFF_IRQ1_MASK);

		irq_status[0] |= (status_buf[4] << (BITS_PER_BYTE * 2));

		status_buf[6] &= (~status_buf[7] & ON_OFF_IRQ2_MASK);

		irq_status[0] |= (status_buf[6] << (BITS_PER_BYTE * 3));

		break;

	case MAX8925_ADC:

		ret = max8925_bulk_read(chip->i2c, MAX8925_TSC_IRQ,

					2, status_buf);

		if (ret < 0)

			goto out;

		/* clear masked interrupt status */

		status_buf[0] &= (~status_buf[1] & TSC_IRQ_MASK);

		irq_status[0] |= status_buf[0];

		break;

	default:

		goto out;

	}



	for_each_bit(i, &irq_status[0], MAX8925_NUM_IRQ) {

		clear_bit(i, irq_status);

		dev_dbg(chip->dev, "Servicing IRQ #%d in %s\n", i, chip->name);



		mutex_lock(&chip->irq_lock);

		if (chip->irq[i].handler)

			chip->irq[i].handler(i, chip->irq[i].data);

		else {

			max8925_mask_irq(chip, i);

			dev_err(chip->dev, "Noboday cares IRQ #%d in %s. "

				"Now mask it.\n", i, chip->name);

		}

		mutex_unlock(&chip->irq_lock);

	}

out:

	return IRQ_HANDLED;

}



int max8925_request_irq(struct max8925_chip *chip, int irq,

			irq_handler_t handler, void *data)

{

	if ((__check_irq(irq) < 0) || !handler)

		return -EINVAL;



	mutex_lock(&chip->irq_lock);

	chip->irq[irq].handler = handler;

	chip->irq[irq].data = data;

	mutex_unlock(&chip->irq_lock);

	return 0;

}

EXPORT_SYMBOL(max8925_request_irq);



int max8925_free_irq(struct max8925_chip *chip, int irq)

{

	if (__check_irq(irq) < 0)

		return -EINVAL;



	mutex_lock(&chip->irq_lock);

	chip->irq[irq].handler = NULL;

	chip->irq[irq].data = NULL;

	mutex_unlock(&chip->irq_lock);

	return 0;

}

EXPORT_SYMBOL(max8925_free_irq);



static int __devinit device_gpm_init(struct max8925_chip *chip,

				      struct i2c_client *i2c,

				      struct max8925_platform_data *pdata)

{

	int ret;



	/* mask all IRQs */

	ret = max8925_set_bits(i2c, MAX8925_CHG_IRQ1_MASK, 0x7, 0x7);

	if (ret < 0)

		goto out;

	ret = max8925_set_bits(i2c, MAX8925_CHG_IRQ2_MASK, 0xff, 0xff);

	if (ret < 0)

		goto out;

	ret = max8925_set_bits(i2c, MAX8925_ON_OFF_IRQ1_MASK, 0xff, 0xff);

	if (ret < 0)

		goto out;

	ret = max8925_set_bits(i2c, MAX8925_ON_OFF_IRQ2_MASK, 0x3, 0x3);

	if (ret < 0)

		goto out;



	chip->name = "GPM";

	memset(chip->irq, 0, sizeof(struct max8925_irq) * MAX8925_NUM_IRQ);

	ret = request_threaded_irq(i2c->irq, NULL, max8925_irq_thread,

				IRQF_ONESHOT | IRQF_TRIGGER_LOW,

				"max8925-gpm", chip);

	if (ret < 0) {

		dev_err(chip->dev, "Failed to request IRQ #%d.\n", i2c->irq);

		goto out;

	}

	chip->chip_irq = i2c->irq;



	/* enable hard-reset for ONKEY power-off */

	max8925_set_bits(i2c, MAX8925_SYSENSEL, 0x80, 0x80);

out:

	return ret;

}



static int __devinit device_adc_init(struct max8925_chip *chip,

				     struct i2c_client *i2c,

				     struct max8925_platform_data *pdata)

{

	int ret;



	/* mask all IRQs */

	ret = max8925_set_bits(i2c, MAX8925_TSC_IRQ_MASK, 3, 3);



	chip->name = "ADC";

	memset(chip->irq, 0, sizeof(struct max8925_irq) * MAX8925_NUM_IRQ);

	ret = request_threaded_irq(i2c->irq, NULL, max8925_irq_thread,

				IRQF_ONESHOT | IRQF_TRIGGER_LOW,

				"max8925-adc", chip);

	if (ret < 0) {

		dev_err(chip->dev, "Failed to request IRQ #%d.\n", i2c->irq);

		goto out;

	}

	chip->chip_irq = i2c->irq;

out:

	return ret;

}



int __devinit max8925_device_init(struct max8925_chip *chip,

				  struct max8925_platform_data *pdata)

{

	switch (chip->chip_id) {

	case MAX8925_GPM:

		device_gpm_init(chip, chip->i2c, pdata);

		break;

	case MAX8925_ADC:

		device_adc_init(chip, chip->i2c, pdata);

		break;

	}

	return 0;

}



void max8925_device_exit(struct max8925_chip *chip)

{

	if (chip->chip_irq >= 0)

		free_irq(chip->chip_irq, chip);

}



MODULE_DESCRIPTION("PMIC Driver for Maxim MAX8925");

MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com");

MODULE_LICENSE("GPL");

drivers/mfd/max8925-i2c.c

0 → 100644
+210 −0
Original line number Diff line number Diff line 
/*

 * I2C driver for Maxim MAX8925

 *

 * Copyright (C) 2009 Marvell International Ltd.

 *	Haojian Zhuang <haojian.zhuang@marvell.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/i2c.h>

#include <linux/mfd/max8925.h>



static inline int max8925_read_device(struct i2c_client *i2c,

				      int reg, int bytes, void *dest)

{

	unsigned char data;

	unsigned char *buf;

	int ret;



	buf = kzalloc(bytes + 1, GFP_KERNEL);

	if (!buf)

		return -ENOMEM;



	data = (unsigned char)reg;

	ret = i2c_master_send(i2c, &data, 1);

	if (ret < 0)

		return ret;



	ret = i2c_master_recv(i2c, buf, bytes + 1);

	if (ret < 0)

		return ret;

	memcpy(dest, buf, bytes);

	return 0;

}



static inline int max8925_write_device(struct i2c_client *i2c,

				       int reg, int bytes, void *src)

{

	unsigned char buf[bytes + 1];

	int ret;



	buf[0] = (unsigned char)reg;

	memcpy(&buf[1], src, bytes);



	ret = i2c_master_send(i2c, buf, bytes + 1);

	if (ret < 0)

		return ret;

	return 0;

}



int max8925_reg_read(struct i2c_client *i2c, int reg)

{

	struct max8925_chip *chip = i2c_get_clientdata(i2c);

	unsigned char data;

	int ret;



	mutex_lock(&chip->io_lock);

	ret = max8925_read_device(i2c, reg, 1, &data);

	mutex_unlock(&chip->io_lock);



	if (ret < 0)

		return ret;

	else

		return (int)data;

}

EXPORT_SYMBOL(max8925_reg_read);



int max8925_reg_write(struct i2c_client *i2c, int reg,

		unsigned char data)

{

	struct max8925_chip *chip = i2c_get_clientdata(i2c);

	int ret;



	mutex_lock(&chip->io_lock);

	ret = max8925_write_device(i2c, reg, 1, &data);

	mutex_unlock(&chip->io_lock);



	return ret;

}

EXPORT_SYMBOL(max8925_reg_write);



int max8925_bulk_read(struct i2c_client *i2c, int reg,

		int count, unsigned char *buf)

{

	struct max8925_chip *chip = i2c_get_clientdata(i2c);

	int ret;



	mutex_lock(&chip->io_lock);

	ret = max8925_read_device(i2c, reg, count, buf);

	mutex_unlock(&chip->io_lock);



	return ret;

}

EXPORT_SYMBOL(max8925_bulk_read);



int max8925_bulk_write(struct i2c_client *i2c, int reg,

		int count, unsigned char *buf)

{

	struct max8925_chip *chip = i2c_get_clientdata(i2c);

	int ret;



	mutex_lock(&chip->io_lock);

	ret = max8925_write_device(i2c, reg, count, buf);

	mutex_unlock(&chip->io_lock);



	return ret;

}

EXPORT_SYMBOL(max8925_bulk_write);



int max8925_set_bits(struct i2c_client *i2c, int reg,

		unsigned char mask, unsigned char data)

{

	struct max8925_chip *chip = i2c_get_clientdata(i2c);

	unsigned char value;

	int ret;



	mutex_lock(&chip->io_lock);

	ret = max8925_read_device(i2c, reg, 1, &value);

	if (ret < 0)

		goto out;

	value &= ~mask;

	value |= data;

	ret = max8925_write_device(i2c, reg, 1, &value);

out:

	mutex_unlock(&chip->io_lock);

	return ret;

}

EXPORT_SYMBOL(max8925_set_bits);





static const struct i2c_device_id max8925_id_table[] = {

	{ "max8925", 0 },

	{}

};

MODULE_DEVICE_TABLE(i2c, max8925_id_table);



static int __devinit max8925_probe(struct i2c_client *client,

				   const struct i2c_device_id *id)

{

	struct max8925_platform_data *pdata = client->dev.platform_data;

	struct max8925_chip *chip;



	if (!pdata) {

		pr_info("%s: platform data is missing\n", __func__);

		return -EINVAL;

	}

	if ((pdata->chip_id <= MAX8925_INVALID)

		|| (pdata->chip_id >= MAX8925_MAX)) {

		pr_info("#%s: wrong chip identification\n", __func__);

		return -EINVAL;

	}



	chip = kzalloc(sizeof(struct max8925_chip), GFP_KERNEL);

	if (chip == NULL)

		return -ENOMEM;

	chip->i2c = client;

	chip->chip_id = pdata->chip_id;

	i2c_set_clientdata(client, chip);

	chip->dev = &client->dev;

	mutex_init(&chip->io_lock);

	dev_set_drvdata(chip->dev, chip);

	max8925_device_init(chip, pdata);



	return 0;

}



static int __devexit max8925_remove(struct i2c_client *client)

{

	struct max8925_chip *chip = i2c_get_clientdata(client);



	max8925_device_exit(chip);

	i2c_set_clientdata(client, NULL);

	kfree(chip);

	return 0;

}



static struct i2c_driver max8925_driver = {

	.driver	= {

		.name	= "max8925",

		.owner	= THIS_MODULE,

	},

	.probe		= max8925_probe,

	.remove		= __devexit_p(max8925_remove),

	.id_table	= max8925_id_table,

};



static int __init max8925_i2c_init(void)

{

	int ret;



	ret = i2c_add_driver(&max8925_driver);

	if (ret != 0)

		pr_err("Failed to register MAX8925 I2C driver: %d\n", ret);

	return ret;

}

subsys_initcall(max8925_i2c_init);



static void __exit max8925_i2c_exit(void)

{

	i2c_del_driver(&max8925_driver);

}

module_exit(max8925_i2c_exit);



MODULE_DESCRIPTION("I2C Driver for Maxim 8925");

MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");

MODULE_LICENSE("GPL");

include/linux/mfd/max8925.h

0 → 100644
+119 −0
Original line number Diff line number Diff line 
/*

 * Maxim8925 Interface

 *

 * Copyright (C) 2009 Marvell International Ltd.

 *	Haojian Zhuang <haojian.zhuang@marvell.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */



#ifndef __LINUX_MFD_MAX8925_H

#define __LINUX_MFD_MAX8925_H



#include <linux/interrupt.h>



/* Charger registers */

#define MAX8925_CHG_IRQ1		(0x7e)

#define MAX8925_CHG_IRQ2		(0x7f)

#define MAX8925_CHG_IRQ1_MASK		(0x80)

#define MAX8925_CHG_IRQ2_MASK		(0x81)



/* GPM registers */

#define MAX8925_SYSENSEL		(0x00)

#define MAX8925_ON_OFF_IRQ1		(0x01)

#define MAX8925_ON_OFF_IRQ1_MASK	(0x02)

#define MAX8925_ON_OFF_STAT		(0x03)

#define MAX8925_ON_OFF_IRQ2		(0x0d)

#define MAX8925_ON_OFF_IRQ2_MASK	(0x0e)

#define MAX8925_RESET_CNFG		(0x0f)



/* Touch registers */

#define MAX8925_TSC_IRQ			(0x00)

#define MAX8925_TSC_IRQ_MASK		(0x01)



/* RTC registers */

#define MAX8925_RTC_STATUS		(0x1a)

#define MAX8925_RTC_IRQ			(0x1c)

#define MAX8925_RTC_IRQ_MASK		(0x1d)



/* bit definitions */

#define CHG_IRQ1_MASK			(0x07)

#define CHG_IRQ2_MASK			(0xff)

#define ON_OFF_IRQ1_MASK		(0xff)

#define ON_OFF_IRQ2_MASK		(0x03)

#define TSC_IRQ_MASK			(0x03)

#define RTC_IRQ_MASK			(0x0c)



#define MAX8925_NUM_IRQ			(32)



#define MAX8925_NAME_SIZE		(32)



enum {

	MAX8925_INVALID = 0,

	MAX8925_RTC,

	MAX8925_ADC,

	MAX8925_GPM,	/* general power management */

	MAX8925_MAX,

};



#define MAX8925_IRQ_VCHG_OVP		(0)

#define MAX8925_IRQ_VCHG_F		(1)

#define MAX8925_IRQ_VCHG_R		(2)

#define MAX8925_IRQ_VCHG_THM_OK_R	(8)

#define MAX8925_IRQ_VCHG_THM_OK_F	(9)

#define MAX8925_IRQ_VCHG_BATTLOW_F	(10)

#define MAX8925_IRQ_VCHG_BATTLOW_R	(11)

#define MAX8925_IRQ_VCHG_RST		(12)

#define MAX8925_IRQ_VCHG_DONE		(13)

#define MAX8925_IRQ_VCHG_TOPOFF		(14)

#define MAX8925_IRQ_VCHG_TMR_FAULT	(15)

#define MAX8925_IRQ_GPM_RSTIN		(16)

#define MAX8925_IRQ_GPM_MPL		(17)

#define MAX8925_IRQ_GPM_SW_3SEC		(18)

#define MAX8925_IRQ_GPM_EXTON_F		(19)

#define MAX8925_IRQ_GPM_EXTON_R		(20)

#define MAX8925_IRQ_GPM_SW_1SEC		(21)

#define MAX8925_IRQ_GPM_SW_F		(22)

#define MAX8925_IRQ_GPM_SW_R		(23)

#define MAX8925_IRQ_GPM_SYSCKEN_F	(24)

#define MAX8925_IRQ_GPM_SYSCKEN_R	(25)



#define MAX8925_IRQ_TSC_STICK		(0)

#define MAX8925_IRQ_TSC_NSTICK		(1)



struct max8925_irq {

	irq_handler_t		handler;

	void			*data;

};



struct max8925_chip {

	struct device		*dev;

	struct mutex		io_lock;

	struct mutex		irq_lock;

	struct i2c_client	*i2c;

	struct max8925_irq	irq[MAX8925_NUM_IRQ];



	const char		*name;

	int			chip_id;

	int			chip_irq;

};



struct max8925_platform_data {

	int	chip_id;

	int	chip_irq;

};



extern int max8925_reg_read(struct i2c_client *, int);

extern int max8925_reg_write(struct i2c_client *, int, unsigned char);

extern int max8925_bulk_read(struct i2c_client *, int, int, unsigned char *);

extern int max8925_bulk_write(struct i2c_client *, int, int, unsigned char *);

extern int max8925_set_bits(struct i2c_client *, int, unsigned char,

			unsigned char);



extern int max8925_device_init(struct max8925_chip *,

				struct max8925_platform_data *);

extern void max8925_device_exit(struct max8925_chip *);

#endif /* __LINUX_MFD_MAX8925_H */