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

Commit 62579266 authored by Rabin Vincent's avatar Rabin Vincent Committed by Samuel Ortiz
Browse files

mfd: New AB8500 driver 



Add a new driver to support the AB8500 Power Management chip, replacing
the current AB4500.  The new driver replaces the old one, instead of an
incremental modification, because this is a substantial overhaul
including:

 - Split of the driver into -core and -spi portions, to allow another
   interface layer to be added

 - Addition of interrupt support

 - Switch to MFD core API for handling subdevices

 - Simplification of the APIs to remove a redundant block parameter

 - Rename of the APIs and macros from ab4500_* to ab8500_*

 - Rename of the files from ab4500* to ab8500*

 - Change of the driver name from ab4500 to ab8500

Acked-by: default avatarLinus Walleij <linus.walleij@stericsson.com>
Acked-by: default avatarSrinidhi Kasagar <srinidhi.kasagar@stericsson.com>
Signed-off-by: default avatarRabin Vincent <rabin.vincent@stericsson.com>
Signed-off-by: default avatarSamuel Ortiz <sameo@linux.intel.com>
parent 75907a11

arch/arm/mach-ux500/board-mop500.c

+1 −1
Original line number Diff line number Diff line
@@ -50,7 +50,7 @@ struct pl022_config_chip ab4500_chip_info = { 


static struct spi_board_info u8500_spi_devices[] = {

	{

		.modalias = "ab4500",

		.modalias = "ab8500",

		.controller_data = &ab4500_chip_info,

		.max_speed_hz = 12000000,

		.bus_num = 0,

drivers/mfd/Kconfig

+5 −4
Original line number Diff line number Diff line
@@ -420,11 +420,12 @@ config EZX_PCAP 
	  This enables the PCAP ASIC present on EZX Phones. This is

	  needed for MMC, TouchScreen, Sound, USB, etc..



config AB4500_CORE

	tristate "ST-Ericsson's AB4500 Mixed Signal Power management chip"

	depends on SPI

config AB8500_CORE

	bool "ST-Ericsson AB8500 Mixed Signal Power Management chip"

	depends on SPI=y && GENERIC_HARDIRQS

	select MFD_CORE

	help

	  Select this option to enable access to AB4500 power management

	  Select this option to enable access to AB8500 power management

	  chip. This connects to U8500 on the SSP/SPI bus and exports

	  read/write functions for the devices to get access to this chip.

	  This chip embeds various other multimedia funtionalities as well.

drivers/mfd/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -64,8 +64,8 @@ obj-$(CONFIG_PCF50633_GPIO) += pcf50633-gpio.o 
obj-$(CONFIG_ABX500_CORE)	+= abx500-core.o

obj-$(CONFIG_AB3100_CORE)	+= ab3100-core.o

obj-$(CONFIG_AB3100_OTP)	+= ab3100-otp.o

obj-$(CONFIG_AB4500_CORE)	+= ab4500-core.o

obj-$(CONFIG_AB3550_CORE)	+= ab3550-core.o

obj-$(CONFIG_AB8500_CORE)	+= ab8500-core.o ab8500-spi.o

obj-$(CONFIG_MFD_TIMBERDALE)    += timberdale.o

obj-$(CONFIG_PMIC_ADP5520)	+= adp5520.o

obj-$(CONFIG_LPC_SCH)		+= lpc_sch.o

drivers/mfd/ab4500-core.c

deleted100644 → 0
+0 −209
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2009 ST-Ericsson

 *

 * Author: Srinidhi KASAGAR <srinidhi.kasagar@stericsson.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.

 *

 * AB4500 is a companion power management chip used with U8500.

 * On this platform, this is interfaced with SSP0 controller

 * which is a ARM primecell pl022.

 *

 * At the moment the module just exports read/write features.

 * Interrupt management to be added - TODO.

 */

#include <linux/kernel.h>

#include <linux/slab.h>

#include <linux/init.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/spi/spi.h>

#include <linux/mfd/ab4500.h>



/* just required if probe fails, we need to

 * unregister the device

 */

static struct spi_driver ab4500_driver;



/*

 * This funtion writes to any AB4500 registers using

 * SPI protocol &  before it writes it packs the data

 * in the below 24 bit frame format

 *

 *	 *|------------------------------------|

 *	 *| 23|22...18|17.......10|9|8|7......0|

 *	 *| r/w  bank       adr          data  |

 *	 * ------------------------------------

 *

 * This function shouldn't be called from interrupt

 * context

 */

int ab4500_write(struct ab4500 *ab4500, unsigned char block,

		unsigned long addr, unsigned char data)

{

	struct spi_transfer xfer;

	struct spi_message	msg;

	int err;

	unsigned long spi_data =

		block << 18 | addr << 10 | data;



	mutex_lock(&ab4500->lock);

	ab4500->tx_buf[0] = spi_data;

	ab4500->rx_buf[0] = 0;



	xfer.tx_buf	= ab4500->tx_buf;

	xfer.rx_buf 	= NULL;

	xfer.len	= sizeof(unsigned long);



	spi_message_init(&msg);

	spi_message_add_tail(&xfer, &msg);



	err = spi_sync(ab4500->spi, &msg);

	mutex_unlock(&ab4500->lock);



	return err;

}

EXPORT_SYMBOL(ab4500_write);



int ab4500_read(struct ab4500 *ab4500, unsigned char block,

		unsigned long addr)

{

	struct spi_transfer xfer;

	struct spi_message	msg;

	unsigned long spi_data =

		1 << 23 | block << 18 | addr << 10;



	mutex_lock(&ab4500->lock);

	ab4500->tx_buf[0] = spi_data;

	ab4500->rx_buf[0] = 0;



	xfer.tx_buf	= ab4500->tx_buf;

	xfer.rx_buf 	= ab4500->rx_buf;

	xfer.len	= sizeof(unsigned long);



	spi_message_init(&msg);

	spi_message_add_tail(&xfer, &msg);



	spi_sync(ab4500->spi, &msg);

	mutex_unlock(&ab4500->lock);



	return  ab4500->rx_buf[0];

}

EXPORT_SYMBOL(ab4500_read);



/* ref: ab3100 core */

#define AB4500_DEVICE(devname, devid)				\

static struct platform_device ab4500_##devname##_device = {	\

	.name	= devid,					\

	.id	= -1,						\

}



/* list of childern devices of ab4500 - all are

 * not populated here - TODO

 */

AB4500_DEVICE(charger, "ab4500-charger");

AB4500_DEVICE(audio, "ab4500-audio");

AB4500_DEVICE(usb, "ab4500-usb");

AB4500_DEVICE(tvout, "ab4500-tvout");

AB4500_DEVICE(sim, "ab4500-sim");

AB4500_DEVICE(gpadc, "ab4500-gpadc");

AB4500_DEVICE(clkmgt, "ab4500-clkmgt");

AB4500_DEVICE(misc, "ab4500-misc");



static struct platform_device *ab4500_platform_devs[] = {

	&ab4500_charger_device,

	&ab4500_audio_device,

	&ab4500_usb_device,

	&ab4500_tvout_device,

	&ab4500_sim_device,

	&ab4500_gpadc_device,

	&ab4500_clkmgt_device,

	&ab4500_misc_device,

};



static int __init ab4500_probe(struct spi_device *spi)

{

	struct ab4500	*ab4500;

	unsigned char revision;

	int err = 0;

	int i;



	ab4500 = kzalloc(sizeof *ab4500, GFP_KERNEL);

	if (!ab4500) {

		dev_err(&spi->dev, "could not allocate AB4500\n");

		err = -ENOMEM;

		goto not_detect;

	}



	ab4500->spi = spi;

	spi_set_drvdata(spi, ab4500);



	mutex_init(&ab4500->lock);



	/* read the revision register */

	revision = ab4500_read(ab4500, AB4500_MISC, AB4500_REV_REG);



	/* revision id 0x0 is for early drop, 0x10 is for cut1.0 */

	if (revision == 0x0 || revision == 0x10)

		dev_info(&spi->dev, "Detected chip: %s, revision = %x\n",

			ab4500_driver.driver.name, revision);

	else	{

		dev_err(&spi->dev, "unknown chip: 0x%x\n", revision);

		goto not_detect;

	}



	for (i = 0; i < ARRAY_SIZE(ab4500_platform_devs); i++)	{

		ab4500_platform_devs[i]->dev.parent =

			&spi->dev;

		platform_set_drvdata(ab4500_platform_devs[i], ab4500);

	}



	/* register the ab4500 platform devices */

	platform_add_devices(ab4500_platform_devs,

			ARRAY_SIZE(ab4500_platform_devs));



	return err;



 not_detect:

	spi_unregister_driver(&ab4500_driver);

	kfree(ab4500);

	return err;

}



static int __devexit ab4500_remove(struct spi_device *spi)

{

	struct ab4500 *ab4500 =

		spi_get_drvdata(spi);



	kfree(ab4500);



	return 0;

}



static struct spi_driver ab4500_driver = {

	.driver = {

		.name = "ab4500",

		.owner = THIS_MODULE,

	},

	.probe = ab4500_probe,

	.remove = __devexit_p(ab4500_remove)

};



static int __devinit ab4500_init(void)

{

	return spi_register_driver(&ab4500_driver);

}



static void __exit ab4500_exit(void)

{

	spi_unregister_driver(&ab4500_driver);

}



subsys_initcall(ab4500_init);

module_exit(ab4500_exit);



MODULE_AUTHOR("Srinidhi KASAGAR <srinidhi.kasagar@stericsson.com");

MODULE_DESCRIPTION("AB4500 core driver");

MODULE_LICENSE("GPL");

drivers/mfd/ab8500-core.c

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

 * Copyright (C) ST-Ericsson SA 2010

 *

 * License Terms: GNU General Public License v2

 * Author: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com>

 * Author: Rabin Vincent <rabin.vincent@stericsson.com>

 */



#include <linux/kernel.h>

#include <linux/slab.h>

#include <linux/init.h>

#include <linux/irq.h>

#include <linux/delay.h>

#include <linux/interrupt.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/mfd/core.h>

#include <linux/mfd/ab8500.h>



/*

 * Interrupt register offsets

 * Bank : 0x0E

 */

#define AB8500_IT_SOURCE1_REG		0x0E00

#define AB8500_IT_SOURCE2_REG		0x0E01

#define AB8500_IT_SOURCE3_REG		0x0E02

#define AB8500_IT_SOURCE4_REG		0x0E03

#define AB8500_IT_SOURCE5_REG		0x0E04

#define AB8500_IT_SOURCE6_REG		0x0E05

#define AB8500_IT_SOURCE7_REG		0x0E06

#define AB8500_IT_SOURCE8_REG		0x0E07

#define AB8500_IT_SOURCE19_REG		0x0E12

#define AB8500_IT_SOURCE20_REG		0x0E13

#define AB8500_IT_SOURCE21_REG		0x0E14

#define AB8500_IT_SOURCE22_REG		0x0E15

#define AB8500_IT_SOURCE23_REG		0x0E16

#define AB8500_IT_SOURCE24_REG		0x0E17



/*

 * latch registers

 */

#define AB8500_IT_LATCH1_REG		0x0E20

#define AB8500_IT_LATCH2_REG		0x0E21

#define AB8500_IT_LATCH3_REG		0x0E22

#define AB8500_IT_LATCH4_REG		0x0E23

#define AB8500_IT_LATCH5_REG		0x0E24

#define AB8500_IT_LATCH6_REG		0x0E25

#define AB8500_IT_LATCH7_REG		0x0E26

#define AB8500_IT_LATCH8_REG		0x0E27

#define AB8500_IT_LATCH9_REG		0x0E28

#define AB8500_IT_LATCH10_REG		0x0E29

#define AB8500_IT_LATCH19_REG		0x0E32

#define AB8500_IT_LATCH20_REG		0x0E33

#define AB8500_IT_LATCH21_REG		0x0E34

#define AB8500_IT_LATCH22_REG		0x0E35

#define AB8500_IT_LATCH23_REG		0x0E36

#define AB8500_IT_LATCH24_REG		0x0E37



/*

 * mask registers

 */



#define AB8500_IT_MASK1_REG		0x0E40

#define AB8500_IT_MASK2_REG		0x0E41

#define AB8500_IT_MASK3_REG		0x0E42

#define AB8500_IT_MASK4_REG		0x0E43

#define AB8500_IT_MASK5_REG		0x0E44

#define AB8500_IT_MASK6_REG		0x0E45

#define AB8500_IT_MASK7_REG		0x0E46

#define AB8500_IT_MASK8_REG		0x0E47

#define AB8500_IT_MASK9_REG		0x0E48

#define AB8500_IT_MASK10_REG		0x0E49

#define AB8500_IT_MASK11_REG		0x0E4A

#define AB8500_IT_MASK12_REG		0x0E4B

#define AB8500_IT_MASK13_REG		0x0E4C

#define AB8500_IT_MASK14_REG		0x0E4D

#define AB8500_IT_MASK15_REG		0x0E4E

#define AB8500_IT_MASK16_REG		0x0E4F

#define AB8500_IT_MASK17_REG		0x0E50

#define AB8500_IT_MASK18_REG		0x0E51

#define AB8500_IT_MASK19_REG		0x0E52

#define AB8500_IT_MASK20_REG		0x0E53

#define AB8500_IT_MASK21_REG		0x0E54

#define AB8500_IT_MASK22_REG		0x0E55

#define AB8500_IT_MASK23_REG		0x0E56

#define AB8500_IT_MASK24_REG		0x0E57



#define AB8500_REV_REG			0x1080



/*

 * Map interrupt numbers to the LATCH and MASK register offsets, Interrupt

 * numbers are indexed into this array with (num / 8).

 *

 * This is one off from the register names, i.e. AB8500_IT_MASK1_REG is at

 * offset 0.

 */

static const int ab8500_irq_regoffset[AB8500_NUM_IRQ_REGS] = {

	0, 1, 2, 3, 4, 6, 7, 8, 9, 18, 19, 20, 21,

};



static int __ab8500_write(struct ab8500 *ab8500, u16 addr, u8 data)

{

	int ret;



	dev_vdbg(ab8500->dev, "wr: addr %#x <= %#x\n", addr, data);



	ret = ab8500->write(ab8500, addr, data);

	if (ret < 0)

		dev_err(ab8500->dev, "failed to write reg %#x: %d\n",

			addr, ret);



	return ret;

}



/**

 * ab8500_write() - write an AB8500 register

 * @ab8500: device to write to

 * @addr: address of the register

 * @data: value to write

 */

int ab8500_write(struct ab8500 *ab8500, u16 addr, u8 data)

{

	int ret;



	mutex_lock(&ab8500->lock);

	ret = __ab8500_write(ab8500, addr, data);

	mutex_unlock(&ab8500->lock);



	return ret;

}

EXPORT_SYMBOL_GPL(ab8500_write);



static int __ab8500_read(struct ab8500 *ab8500, u16 addr)

{

	int ret;



	ret = ab8500->read(ab8500, addr);

	if (ret < 0)

		dev_err(ab8500->dev, "failed to read reg %#x: %d\n",

			addr, ret);



	dev_vdbg(ab8500->dev, "rd: addr %#x => data %#x\n", addr, ret);



	return ret;

}



/**

 * ab8500_read() - read an AB8500 register

 * @ab8500: device to read from

 * @addr: address of the register

 */

int ab8500_read(struct ab8500 *ab8500, u16 addr)

{

	int ret;



	mutex_lock(&ab8500->lock);

	ret = __ab8500_read(ab8500, addr);

	mutex_unlock(&ab8500->lock);



	return ret;

}

EXPORT_SYMBOL_GPL(ab8500_read);



/**

 * ab8500_set_bits() - set a bitfield in an AB8500 register

 * @ab8500: device to read from

 * @addr: address of the register

 * @mask: mask of the bitfield to modify

 * @data: value to set to the bitfield

 */

int ab8500_set_bits(struct ab8500 *ab8500, u16 addr, u8 mask, u8 data)

{

	int ret;



	mutex_lock(&ab8500->lock);



	ret = __ab8500_read(ab8500, addr);

	if (ret < 0)

		goto out;



	ret &= ~mask;

	ret |= data;



	ret = __ab8500_write(ab8500, addr, ret);



out:

	mutex_unlock(&ab8500->lock);

	return ret;

}

EXPORT_SYMBOL_GPL(ab8500_set_bits);



static void ab8500_irq_lock(unsigned int irq)

{

	struct ab8500 *ab8500 = get_irq_chip_data(irq);



	mutex_lock(&ab8500->irq_lock);

}



static void ab8500_irq_sync_unlock(unsigned int irq)

{

	struct ab8500 *ab8500 = get_irq_chip_data(irq);

	int i;



	for (i = 0; i < AB8500_NUM_IRQ_REGS; i++) {

		u8 old = ab8500->oldmask[i];

		u8 new = ab8500->mask[i];

		int reg;



		if (new == old)

			continue;



		ab8500->oldmask[i] = new;



		reg = AB8500_IT_MASK1_REG + ab8500_irq_regoffset[i];

		ab8500_write(ab8500, reg, new);

	}



	mutex_unlock(&ab8500->irq_lock);

}



static void ab8500_irq_mask(unsigned int irq)

{

	struct ab8500 *ab8500 = get_irq_chip_data(irq);

	int offset = irq - ab8500->irq_base;

	int index = offset / 8;

	int mask = 1 << (offset % 8);



	ab8500->mask[index] |= mask;

}



static void ab8500_irq_unmask(unsigned int irq)

{

	struct ab8500 *ab8500 = get_irq_chip_data(irq);

	int offset = irq - ab8500->irq_base;

	int index = offset / 8;

	int mask = 1 << (offset % 8);



	ab8500->mask[index] &= ~mask;

}



static struct irq_chip ab8500_irq_chip = {

	.name			= "ab8500",

	.bus_lock		= ab8500_irq_lock,

	.bus_sync_unlock	= ab8500_irq_sync_unlock,

	.mask			= ab8500_irq_mask,

	.unmask			= ab8500_irq_unmask,

};



static irqreturn_t ab8500_irq(int irq, void *dev)

{

	struct ab8500 *ab8500 = dev;

	int i;



	dev_vdbg(ab8500->dev, "interrupt\n");



	for (i = 0; i < AB8500_NUM_IRQ_REGS; i++) {

		int regoffset = ab8500_irq_regoffset[i];

		int status;



		status = ab8500_read(ab8500, AB8500_IT_LATCH1_REG + regoffset);

		if (status <= 0)

			continue;



		do {

			int bit = __ffs(status);

			int line = i * 8 + bit;



			handle_nested_irq(ab8500->irq_base + line);

			status &= ~(1 << bit);

		} while (status);

	}



	return IRQ_HANDLED;

}



static int ab8500_irq_init(struct ab8500 *ab8500)

{

	int base = ab8500->irq_base;

	int irq;



	for (irq = base; irq < base + AB8500_NR_IRQS; irq++) {

		set_irq_chip_data(irq, ab8500);

		set_irq_chip_and_handler(irq, &ab8500_irq_chip,

					 handle_simple_irq);

		set_irq_nested_thread(irq, 1);

#ifdef CONFIG_ARM

		set_irq_flags(irq, IRQF_VALID);

#else

		set_irq_noprobe(irq);

#endif

	}



	return 0;

}



static void ab8500_irq_remove(struct ab8500 *ab8500)

{

	int base = ab8500->irq_base;

	int irq;



	for (irq = base; irq < base + AB8500_NR_IRQS; irq++) {

#ifdef CONFIG_ARM

		set_irq_flags(irq, 0);

#endif

		set_irq_chip_and_handler(irq, NULL, NULL);

		set_irq_chip_data(irq, NULL);

	}

}



static struct resource ab8500_gpadc_resources[] = {

	{

		.name	= "HW_CONV_END",

		.start	= AB8500_INT_GP_HW_ADC_CONV_END,

		.end	= AB8500_INT_GP_HW_ADC_CONV_END,

		.flags	= IORESOURCE_IRQ,

	},

	{

		.name	= "SW_CONV_END",

		.start	= AB8500_INT_GP_SW_ADC_CONV_END,

		.end	= AB8500_INT_GP_SW_ADC_CONV_END,

		.flags	= IORESOURCE_IRQ,

	},

};



static struct resource ab8500_rtc_resources[] = {

	{

		.name	= "60S",

		.start	= AB8500_INT_RTC_60S,

		.end	= AB8500_INT_RTC_60S,

		.flags	= IORESOURCE_IRQ,

	},

	{

		.name	= "ALARM",

		.start	= AB8500_INT_RTC_ALARM,

		.end	= AB8500_INT_RTC_ALARM,

		.flags	= IORESOURCE_IRQ,

	},

};



static struct mfd_cell ab8500_devs[] = {

	{

		.name = "ab8500-gpadc",

		.num_resources = ARRAY_SIZE(ab8500_gpadc_resources),

		.resources = ab8500_gpadc_resources,

	},

	{

		.name = "ab8500-rtc",

		.num_resources = ARRAY_SIZE(ab8500_rtc_resources),

		.resources = ab8500_rtc_resources,

	},

	{ .name = "ab8500-charger", },

	{ .name = "ab8500-audio", },

	{ .name = "ab8500-usb", },

	{ .name = "ab8500-pwm", },

};



int __devinit ab8500_init(struct ab8500 *ab8500)

{

	struct ab8500_platform_data *plat = dev_get_platdata(ab8500->dev);

	int ret;

	int i;



	if (plat)

		ab8500->irq_base = plat->irq_base;



	mutex_init(&ab8500->lock);

	mutex_init(&ab8500->irq_lock);



	ret = ab8500_read(ab8500, AB8500_REV_REG);

	if (ret < 0)

		return ret;



	/*

	 * 0x0 - Early Drop

	 * 0x10 - Cut 1.0

	 * 0x11 - Cut 1.1

	 */

	if (ret == 0x0 || ret == 0x10 || ret == 0x11) {

		ab8500->revision = ret;

		dev_info(ab8500->dev, "detected chip, revision: %#x\n", ret);

	} else {

		dev_err(ab8500->dev, "unknown chip, revision: %#x\n", ret);

		return -EINVAL;

	}



	if (plat && plat->init)

		plat->init(ab8500);



	/* Clear and mask all interrupts */

	for (i = 0; i < 10; i++) {

		ab8500_read(ab8500, AB8500_IT_LATCH1_REG + i);

		ab8500_write(ab8500, AB8500_IT_MASK1_REG + i, 0xff);

	}



	for (i = 18; i < 24; i++) {

		ab8500_read(ab8500, AB8500_IT_LATCH1_REG + i);

		ab8500_write(ab8500, AB8500_IT_MASK1_REG + i, 0xff);

	}



	for (i = 0; i < AB8500_NUM_IRQ_REGS; i++)

		ab8500->mask[i] = ab8500->oldmask[i] = 0xff;



	if (ab8500->irq_base) {

		ret = ab8500_irq_init(ab8500);

		if (ret)

			return ret;



		ret = request_threaded_irq(ab8500->irq, NULL, ab8500_irq,

					   IRQF_ONESHOT, "ab8500", ab8500);

		if (ret)

			goto out_removeirq;

	}



	ret = mfd_add_devices(ab8500->dev, -1, ab8500_devs,

			      ARRAY_SIZE(ab8500_devs), NULL,

			      ab8500->irq_base);

	if (ret)

		goto out_freeirq;



	return ret;



out_freeirq:

	if (ab8500->irq_base) {

		free_irq(ab8500->irq, ab8500);

out_removeirq:

		ab8500_irq_remove(ab8500);

	}

	return ret;

}



int __devexit ab8500_exit(struct ab8500 *ab8500)

{

	mfd_remove_devices(ab8500->dev);

	if (ab8500->irq_base) {

		free_irq(ab8500->irq, ab8500);

		ab8500_irq_remove(ab8500);

	}



	return 0;

}



MODULE_AUTHOR("Srinidhi Kasagar, Rabin Vincent");

MODULE_DESCRIPTION("AB8500 MFD core");

MODULE_LICENSE("GPL v2");