Commit 44356090 authored by Dr. David Alan Gilbert's avatar Dr. David Alan Gilbert Committed by Lee Jones
Browse files

mfd: pcf50633: Remove remaining PCF50633 support 

Remove the remaining parts of the 50633, the core, headers and glue.

The pcf50633 was used as part of the OpenMoko devices but
the support for its main chip was recently removed in:
commit 61b7f892 ("ARM: s3c: remove all s3c24xx support")

See https://lore.kernel.org/all/Z8z236h4B5A6Ki3D@gallifrey/



Remove it.

Signed-off-by: default avatar"Dr. David Alan Gilbert" <linux@treblig.org>
Link: https://lore.kernel.org/r/20250311014959.743322-10-linux@treblig.org


Signed-off-by: default avatarLee Jones <lee@kernel.org>
parent 786ad21f

arch/mips/configs/ip27_defconfig

+0 −1
Original line number Diff line number Diff line
@@ -255,7 +255,6 @@ CONFIG_I2C_TAOS_EVM=m 
CONFIG_I2C_STUB=m

# CONFIG_HWMON is not set

CONFIG_THERMAL=y

CONFIG_MFD_PCF50633=m

# CONFIG_VGA_ARB is not set

CONFIG_LEDS_LP3944=m

CONFIG_LEDS_PCA955X=m

drivers/mfd/Kconfig

+0 −10
Original line number Diff line number Diff line
@@ -1132,16 +1132,6 @@ config MFD_RETU 
	  Retu and Tahvo are a multi-function devices found on Nokia

	  Internet Tablets (770, N800 and N810).



config MFD_PCF50633

	tristate "NXP PCF50633"

	depends on I2C

	select REGMAP_I2C

	help

	  Say yes here if you have NXP PCF50633 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 MFD_PM8XXX

	tristate "Qualcomm PM8xxx PMIC chips driver"

	depends on ARM || HEXAGON || COMPILE_TEST

drivers/mfd/Makefile

+0 −2
Original line number Diff line number Diff line
@@ -183,8 +183,6 @@ obj-$(CONFIG_MFD_MT6370) += mt6370.o 
mt6397-objs			:= mt6397-core.o mt6397-irq.o mt6358-irq.o

obj-$(CONFIG_MFD_MT6397)	+= mt6397.o



pcf50633-objs			:= pcf50633-core.o

obj-$(CONFIG_MFD_PCF50633)	+= pcf50633.o

obj-$(CONFIG_RZ_MTU3)		+= rz-mtu3.o

obj-$(CONFIG_ABX500_CORE)	+= abx500-core.o

obj-$(CONFIG_MFD_DB8500_PRCMU)	+= db8500-prcmu.o

drivers/mfd/pcf50633-core.c

deleted100644 → 0
+0 −301
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/* NXP PCF50633 Power Management Unit (PMU) driver

 *

 * (C) 2006-2008 by Openmoko, Inc.

 * Author: Harald Welte <laforge@openmoko.org>

 * 	   Balaji Rao <balajirrao@openmoko.org>

 * All rights reserved.

 */



#include <linux/kernel.h>

#include <linux/device.h>

#include <linux/sysfs.h>

#include <linux/module.h>

#include <linux/types.h>

#include <linux/interrupt.h>

#include <linux/workqueue.h>

#include <linux/platform_device.h>

#include <linux/i2c.h>

#include <linux/pm.h>

#include <linux/slab.h>

#include <linux/regmap.h>

#include <linux/err.h>



#include <linux/mfd/pcf50633/core.h>



/* Read a block of up to 32 regs  */

int pcf50633_read_block(struct pcf50633 *pcf, u8 reg,

					int nr_regs, u8 *data)

{

	int ret;



	ret = regmap_raw_read(pcf->regmap, reg, data, nr_regs);

	if (ret != 0)

		return ret;



	return nr_regs;

}

EXPORT_SYMBOL_GPL(pcf50633_read_block);



/* Write a block of up to 32 regs  */

int pcf50633_write_block(struct pcf50633 *pcf , u8 reg,

					int nr_regs, u8 *data)

{

	return regmap_raw_write(pcf->regmap, reg, data, nr_regs);

}

EXPORT_SYMBOL_GPL(pcf50633_write_block);



u8 pcf50633_reg_read(struct pcf50633 *pcf, u8 reg)

{

	unsigned int val;

	int ret;



	ret = regmap_read(pcf->regmap, reg, &val);

	if (ret < 0)

		return -1;



	return val;

}

EXPORT_SYMBOL_GPL(pcf50633_reg_read);



int pcf50633_reg_write(struct pcf50633 *pcf, u8 reg, u8 val)

{

	return regmap_write(pcf->regmap, reg, val);

}

EXPORT_SYMBOL_GPL(pcf50633_reg_write);



int pcf50633_reg_set_bit_mask(struct pcf50633 *pcf, u8 reg, u8 mask, u8 val)

{

	return regmap_update_bits(pcf->regmap, reg, mask, val);

}

EXPORT_SYMBOL_GPL(pcf50633_reg_set_bit_mask);



int pcf50633_reg_clear_bits(struct pcf50633 *pcf, u8 reg, u8 val)

{

	return regmap_update_bits(pcf->regmap, reg, val, 0);

}

EXPORT_SYMBOL_GPL(pcf50633_reg_clear_bits);



/* sysfs attributes */

static ssize_t dump_regs_show(struct device *dev,

			      struct device_attribute *attr, char *buf)

{

	struct pcf50633 *pcf = dev_get_drvdata(dev);

	u8 dump[16];

	int n, n1, idx = 0;

	char *buf1 = buf;

	static u8 address_no_read[] = { /* must be ascending */

		PCF50633_REG_INT1,

		PCF50633_REG_INT2,

		PCF50633_REG_INT3,

		PCF50633_REG_INT4,

		PCF50633_REG_INT5,

		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] = pcf50633_reg_read(pcf, n + n1);



		buf1 += sprintf(buf1, "%*ph\n", (int)sizeof(dump), dump);

	}



	return buf1 - buf;

}

static DEVICE_ATTR_ADMIN_RO(dump_regs);



static ssize_t resume_reason_show(struct device *dev,

				  struct device_attribute *attr, char *buf)

{

	struct pcf50633 *pcf = dev_get_drvdata(dev);

	int n;



	n = sprintf(buf, "%02x%02x%02x%02x%02x\n",

				pcf->resume_reason[0],

				pcf->resume_reason[1],

				pcf->resume_reason[2],

				pcf->resume_reason[3],

				pcf->resume_reason[4]);



	return n;

}

static DEVICE_ATTR_ADMIN_RO(resume_reason);



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,

};



static void

pcf50633_client_dev_register(struct pcf50633 *pcf, const char *name,

						struct platform_device **pdev)

{

	int ret;



	*pdev = platform_device_alloc(name, -1);

	if (!*pdev) {

		dev_err(pcf->dev, "Failed to allocate %s\n", name);

		return;

	}



	(*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;

	}

}



static const struct regmap_config pcf50633_regmap_config = {

	.reg_bits = 8,

	.val_bits = 8,

};



static int pcf50633_probe(struct i2c_client *client)

{

	struct pcf50633 *pcf;

	struct platform_device *pdev;

	struct pcf50633_platform_data *pdata = dev_get_platdata(&client->dev);

	int i, j, ret;

	int version, variant;



	if (!client->irq) {

		dev_err(&client->dev, "Missing IRQ\n");

		return -ENOENT;

	}



	pcf = devm_kzalloc(&client->dev, sizeof(*pcf), GFP_KERNEL);

	if (!pcf)

		return -ENOMEM;



	i2c_set_clientdata(client, pcf);

	pcf->dev = &client->dev;

	pcf->pdata = pdata;



	mutex_init(&pcf->lock);



	pcf->regmap = devm_regmap_init_i2c(client, &pcf50633_regmap_config);

	if (IS_ERR(pcf->regmap)) {

		ret = PTR_ERR(pcf->regmap);

		dev_err(pcf->dev, "Failed to allocate register map: %d\n", ret);

		return ret;

	}



	version = pcf50633_reg_read(pcf, 0);

	variant = pcf50633_reg_read(pcf, 1);

	if (version < 0 || variant < 0) {

		dev_err(pcf->dev, "Unable to probe pcf50633\n");

		ret = -ENODEV;

		return ret;

	}



	dev_info(pcf->dev, "Probed device version %d variant %d\n",

							version, variant);



	/* Create sub devices */

	pcf50633_client_dev_register(pcf, "pcf50633-input", &pcf->input_pdev);

	pcf50633_client_dev_register(pcf, "pcf50633-rtc", &pcf->rtc_pdev);

	pcf50633_client_dev_register(pcf, "pcf50633-mbc", &pcf->mbc_pdev);

	pcf50633_client_dev_register(pcf, "pcf50633-adc", &pcf->adc_pdev);

	pcf50633_client_dev_register(pcf, "pcf50633-backlight", &pcf->bl_pdev);





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

		pdev = platform_device_alloc("pcf50633-regulator", i);

		if (!pdev) {

			ret = -ENOMEM;

			goto err2;

		}



		pdev->dev.parent = pcf->dev;

		ret = platform_device_add_data(pdev, &pdata->reg_init_data[i],

					       sizeof(pdata->reg_init_data[i]));

		if (ret)

			goto err;



		ret = platform_device_add(pdev);

		if (ret)

			goto err;



		pcf->regulator_pdev[i] = pdev;

	}



	ret = sysfs_create_group(&client->dev.kobj, &pcf_attr_group);

	if (ret)

		dev_warn(pcf->dev, "error creating sysfs entries\n");



	if (pdata->probe_done)

		pdata->probe_done(pcf);



	return 0;



err:

	platform_device_put(pdev);

err2:

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

		platform_device_put(pcf->regulator_pdev[j]);



	return ret;

}



static void pcf50633_remove(struct i2c_client *client)

{

	struct pcf50633 *pcf = i2c_get_clientdata(client);

	int i;



	sysfs_remove_group(&client->dev.kobj, &pcf_attr_group);



	platform_device_unregister(pcf->input_pdev);

	platform_device_unregister(pcf->rtc_pdev);

	platform_device_unregister(pcf->mbc_pdev);

	platform_device_unregister(pcf->adc_pdev);

	platform_device_unregister(pcf->bl_pdev);



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

		platform_device_unregister(pcf->regulator_pdev[i]);

}



static const struct i2c_device_id pcf50633_id_table[] = {

	{"pcf50633", 0x73},

	{/* end of list */}

};

MODULE_DEVICE_TABLE(i2c, pcf50633_id_table);



static struct i2c_driver pcf50633_driver = {

	.driver = {

		.name	= "pcf50633",

		/* going.... .pm	= pm_sleep_ptr(&pcf50633_pm), */

	},

	.id_table = pcf50633_id_table,

	.probe = pcf50633_probe,

	.remove = pcf50633_remove,

};



static int __init pcf50633_init(void)

{

	return i2c_add_driver(&pcf50633_driver);

}



static void __exit pcf50633_exit(void)

{

	i2c_del_driver(&pcf50633_driver);

}



MODULE_DESCRIPTION("I2C chip driver for NXP PCF50633 PMU");

MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");

MODULE_LICENSE("GPL");



subsys_initcall(pcf50633_init);

module_exit(pcf50633_exit);

include/linux/mfd/pcf50633/mbc.h

deleted100644 → 0
+0 −130
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-or-later */

/*

 * mbc.h  -- Driver for NXP PCF50633 Main Battery Charger

 *

 * (C) 2006-2008 by Openmoko, Inc.

 * All rights reserved.

 */



#ifndef __LINUX_MFD_PCF50633_MBC_H

#define __LINUX_MFD_PCF50633_MBC_H



#include <linux/mfd/pcf50633/core.h>

#include <linux/platform_device.h>



#define PCF50633_REG_MBCC1	0x43

#define PCF50633_REG_MBCC2	0x44

#define PCF50633_REG_MBCC3	0x45

#define PCF50633_REG_MBCC4	0x46

#define PCF50633_REG_MBCC5	0x47

#define PCF50633_REG_MBCC6	0x48

#define PCF50633_REG_MBCC7	0x49

#define PCF50633_REG_MBCC8	0x4a

#define PCF50633_REG_MBCS1	0x4b

#define PCF50633_REG_MBCS2	0x4c

#define PCF50633_REG_MBCS3	0x4d



enum pcf50633_reg_mbcc1 {

	PCF50633_MBCC1_CHGENA		= 0x01,	/* Charger enable */

	PCF50633_MBCC1_AUTOSTOP		= 0x02,

	PCF50633_MBCC1_AUTORES		= 0x04, /* automatic resume */

	PCF50633_MBCC1_RESUME		= 0x08, /* explicit resume cmd */

	PCF50633_MBCC1_RESTART		= 0x10, /* restart charging */

	PCF50633_MBCC1_PREWDTIME_60M	= 0x20,	/* max. precharging time */

	PCF50633_MBCC1_WDTIME_1H	= 0x00,

	PCF50633_MBCC1_WDTIME_2H	= 0x40,

	PCF50633_MBCC1_WDTIME_4H	= 0x80,

	PCF50633_MBCC1_WDTIME_6H	= 0xc0,

};

#define PCF50633_MBCC1_WDTIME_MASK	  0xc0



enum pcf50633_reg_mbcc2 {

	PCF50633_MBCC2_VBATCOND_2V7	= 0x00,

	PCF50633_MBCC2_VBATCOND_2V85	= 0x01,

	PCF50633_MBCC2_VBATCOND_3V0	= 0x02,

	PCF50633_MBCC2_VBATCOND_3V15	= 0x03,

	PCF50633_MBCC2_VMAX_4V		= 0x00,

	PCF50633_MBCC2_VMAX_4V20	= 0x28,

	PCF50633_MBCC2_VRESDEBTIME_64S	= 0x80,	/* debounce time (32/64sec) */

};



enum pcf50633_reg_mbcc7 {

	PCF50633_MBCC7_USB_100mA	= 0x00,

	PCF50633_MBCC7_USB_500mA	= 0x01,

	PCF50633_MBCC7_USB_1000mA	= 0x02,

	PCF50633_MBCC7_USB_SUSPEND	= 0x03,

	PCF50633_MBCC7_BATTEMP_EN	= 0x04,

	PCF50633_MBCC7_BATSYSIMAX_1A6	= 0x00,

	PCF50633_MBCC7_BATSYSIMAX_1A8	= 0x40,

	PCF50633_MBCC7_BATSYSIMAX_2A0	= 0x80,

	PCF50633_MBCC7_BATSYSIMAX_2A2	= 0xc0,

};

#define PCF50633_MBCC7_USB_MASK 0x03



enum pcf50633_reg_mbcc8 {

	PCF50633_MBCC8_USBENASUS	= 0x10,

};



enum pcf50633_reg_mbcs1 {

	PCF50633_MBCS1_USBPRES		= 0x01,

	PCF50633_MBCS1_USBOK		= 0x02,

	PCF50633_MBCS1_ADAPTPRES	= 0x04,

	PCF50633_MBCS1_ADAPTOK		= 0x08,

	PCF50633_MBCS1_TBAT_OK		= 0x00,

	PCF50633_MBCS1_TBAT_ABOVE	= 0x10,

	PCF50633_MBCS1_TBAT_BELOW	= 0x20,

	PCF50633_MBCS1_TBAT_UNDEF	= 0x30,

	PCF50633_MBCS1_PREWDTEXP	= 0x40,

	PCF50633_MBCS1_WDTEXP		= 0x80,

};



enum pcf50633_reg_mbcs2_mbcmod {

	PCF50633_MBCS2_MBC_PLAY		= 0x00,

	PCF50633_MBCS2_MBC_USB_PRE	= 0x01,

	PCF50633_MBCS2_MBC_USB_PRE_WAIT	= 0x02,

	PCF50633_MBCS2_MBC_USB_FAST	= 0x03,

	PCF50633_MBCS2_MBC_USB_FAST_WAIT = 0x04,

	PCF50633_MBCS2_MBC_USB_SUSPEND	= 0x05,

	PCF50633_MBCS2_MBC_ADP_PRE	= 0x06,

	PCF50633_MBCS2_MBC_ADP_PRE_WAIT	= 0x07,

	PCF50633_MBCS2_MBC_ADP_FAST	= 0x08,

	PCF50633_MBCS2_MBC_ADP_FAST_WAIT = 0x09,

	PCF50633_MBCS2_MBC_BAT_FULL	= 0x0a,

	PCF50633_MBCS2_MBC_HALT		= 0x0b,

};

#define PCF50633_MBCS2_MBC_MASK		0x0f

enum pcf50633_reg_mbcs2_chgstat {

	PCF50633_MBCS2_CHGS_NONE	= 0x00,

	PCF50633_MBCS2_CHGS_ADAPTER	= 0x10,

	PCF50633_MBCS2_CHGS_USB		= 0x20,

	PCF50633_MBCS2_CHGS_BOTH	= 0x30,

};

#define PCF50633_MBCS2_RESSTAT_AUTO	0x40



enum pcf50633_reg_mbcs3 {

	PCF50633_MBCS3_USBLIM_PLAY	= 0x01,

	PCF50633_MBCS3_USBLIM_CGH	= 0x02,

	PCF50633_MBCS3_TLIM_PLAY	= 0x04,

	PCF50633_MBCS3_TLIM_CHG		= 0x08,

	PCF50633_MBCS3_ILIM		= 0x10,	/* 1: Ibat > Icutoff */

	PCF50633_MBCS3_VLIM		= 0x20,	/* 1: Vbat == Vmax */

	PCF50633_MBCS3_VBATSTAT		= 0x40,	/* 1: Vbat > Vbatcond */

	PCF50633_MBCS3_VRES		= 0x80, /* 1: Vbat > Vth(RES) */

};



#define PCF50633_MBCC2_VBATCOND_MASK	  0x03

#define PCF50633_MBCC2_VMAX_MASK	  0x3c



/* Charger status */

#define PCF50633_MBC_USB_ONLINE		0x01

#define PCF50633_MBC_USB_ACTIVE		0x02

#define PCF50633_MBC_ADAPTER_ONLINE	0x04

#define PCF50633_MBC_ADAPTER_ACTIVE	0x08



int pcf50633_mbc_usb_curlim_set(struct pcf50633 *pcf, int ma);



int pcf50633_mbc_get_status(struct pcf50633 *);

int pcf50633_mbc_get_usb_online_status(struct pcf50633 *);



#endif