[PATCH 11/14] mfd: remove unused wm8350 driver

@@ -296,7 +296,6 @@ Hardware Monitoring Kernel Drivers
    w83l785ts
    w83l786ng
    wm831x
-   wm8350
    xgene-hwmon
    xdp710
    xdpe12284

@@ -1,30 +0,0 @@
-Kernel driver wm8350-hwmon
-==========================
-
-Supported chips:
-
-  * Wolfson Microelectronics WM835x PMICs
-
-    Prefix: 'wm8350'
-
-    Datasheet:
-
-	- http://www.wolfsonmicro.com/products/WM8350
-	- http://www.wolfsonmicro.com/products/WM8351
-	- http://www.wolfsonmicro.com/products/WM8352
-
-Authors: Mark Brown <broonie@opensource.wolfsonmicro.com>
-
-Description
------------
-
-The WM835x series of PMICs include an AUXADC which can be used to
-monitor a range of system operating parameters, including the voltages
-of the major supplies within the system.  Currently the driver provides
-simple access to these major supplies.
-
-Voltage Monitoring
-------------------
-
-Voltages are sampled by a 12 bit ADC.  For the internal supplies the ADC
-is referenced to the system VRTC.

@@ -699,13 +699,6 @@ wm831x_wdt:
 
 -------------------------------------------------
 
-wm8350_wdt:
-    nowayout:
-	Watchdog cannot be stopped once started
-	(default=kernel config parameter)
-
--------------------------------------------------
-
 sun4v_wdt:
     timeout_ms:
 	Watchdog timeout in milliseconds 1..180000, default=60000)

@@ -29385,7 +29385,6 @@ F:	drivers/video/backlight/wm83*_bl.c
 F:	drivers/watchdog/wm83*_wdt.c
 F:	include/linux/mfd/arizona/
 F:	include/linux/mfd/wm831x/
-F:	include/linux/mfd/wm8350/
 F:	include/linux/regulator/arizona*
 F:	include/linux/wm97xx.h
 F:	include/sound/wm????.h

@@ -1792,13 +1792,6 @@ config GPIO_WM831X
 	  Say yes here to access the GPIO signals of WM831x power management
 	  chips from Wolfson Microelectronics.
 
-config GPIO_WM8350
-	tristate "WM8350 GPIOs"
-	depends on MFD_WM8350
-	help
-	  Say yes here to access the GPIO signals of WM8350 power management
-	  chips from Wolfson Microelectronics.
-
 config GPIO_WM8994
 	tristate "WM8994 GPIOs"
 	depends on MFD_WM8994

@@ -211,7 +211,6 @@ obj-$(CONFIG_GPIO_WCD934X)		+= gpio-wcd934x.o
 obj-$(CONFIG_GPIO_WHISKEY_COVE)		+= gpio-wcove.o
 obj-$(CONFIG_GPIO_WINBOND)		+= gpio-winbond.o
 obj-$(CONFIG_GPIO_WM831X)		+= gpio-wm831x.o
-obj-$(CONFIG_GPIO_WM8350)		+= gpio-wm8350.o
 obj-$(CONFIG_GPIO_WM8994)		+= gpio-wm8994.o
 obj-$(CONFIG_GPIO_WS16C48)		+= gpio-ws16c48.o
 obj-$(CONFIG_GPIO_XGENE)		+= gpio-xgene.o

@@ -1,144 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0+
-/*
- * gpiolib support for Wolfson WM835x PMICs
- *
- * Copyright 2009 Wolfson Microelectronics PLC.
- *
- * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
- *
- */
-
-#include <linux/gpio/driver.h>
-#include <linux/kernel.h>
-#include <linux/mfd/core.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-
-#include <linux/mfd/wm8350/core.h>
-#include <linux/mfd/wm8350/gpio.h>
-
-struct wm8350_gpio_data {
-	struct wm8350 *wm8350;
-	struct gpio_chip gpio_chip;
-};
-
-static int wm8350_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
-{
-	struct wm8350_gpio_data *wm8350_gpio = gpiochip_get_data(chip);
-	struct wm8350 *wm8350 = wm8350_gpio->wm8350;
-
-	return wm8350_set_bits(wm8350, WM8350_GPIO_CONFIGURATION_I_O,
-			       1 << offset);
-}
-
-static int wm8350_gpio_get(struct gpio_chip *chip, unsigned offset)
-{
-	struct wm8350_gpio_data *wm8350_gpio = gpiochip_get_data(chip);
-	struct wm8350 *wm8350 = wm8350_gpio->wm8350;
-	int ret;
-
-	ret = wm8350_reg_read(wm8350, WM8350_GPIO_LEVEL);
-	if (ret < 0)
-		return ret;
-
-	if (ret & (1 << offset))
-		return 1;
-	else
-		return 0;
-}
-
-static int wm8350_gpio_set(struct gpio_chip *chip, unsigned int offset,
-			   int value)
-{
-	struct wm8350_gpio_data *wm8350_gpio = gpiochip_get_data(chip);
-	struct wm8350 *wm8350 = wm8350_gpio->wm8350;
-
-	if (value)
-		return wm8350_set_bits(wm8350, WM8350_GPIO_LEVEL, 1 << offset);
-
-	return wm8350_clear_bits(wm8350, WM8350_GPIO_LEVEL, 1 << offset);
-}
-
-static int wm8350_gpio_direction_out(struct gpio_chip *chip,
-				     unsigned offset, int value)
-{
-	struct wm8350_gpio_data *wm8350_gpio = gpiochip_get_data(chip);
-	struct wm8350 *wm8350 = wm8350_gpio->wm8350;
-	int ret;
-
-	ret = wm8350_clear_bits(wm8350, WM8350_GPIO_CONFIGURATION_I_O,
-				1 << offset);
-	if (ret < 0)
-		return ret;
-
-	/* Don't have an atomic direction/value setup */
-	return wm8350_gpio_set(chip, offset, value);
-}
-
-static int wm8350_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
-{
-	struct wm8350_gpio_data *wm8350_gpio = gpiochip_get_data(chip);
-	struct wm8350 *wm8350 = wm8350_gpio->wm8350;
-
-	if (!wm8350->irq_base)
-		return -EINVAL;
-
-	return wm8350->irq_base + WM8350_IRQ_GPIO(offset);
-}
-
-static const struct gpio_chip template_chip = {
-	.label			= "wm8350",
-	.owner			= THIS_MODULE,
-	.direction_input	= wm8350_gpio_direction_in,
-	.get			= wm8350_gpio_get,
-	.direction_output	= wm8350_gpio_direction_out,
-	.set			= wm8350_gpio_set,
-	.to_irq			= wm8350_gpio_to_irq,
-	.can_sleep		= true,
-};
-
-static int wm8350_gpio_probe(struct platform_device *pdev)
-{
-	struct wm8350 *wm8350 = dev_get_drvdata(pdev->dev.parent);
-	struct wm8350_platform_data *pdata = dev_get_platdata(wm8350->dev);
-	struct wm8350_gpio_data *wm8350_gpio;
-
-	wm8350_gpio = devm_kzalloc(&pdev->dev, sizeof(*wm8350_gpio),
-				   GFP_KERNEL);
-	if (wm8350_gpio == NULL)
-		return -ENOMEM;
-
-	wm8350_gpio->wm8350 = wm8350;
-	wm8350_gpio->gpio_chip = template_chip;
-	wm8350_gpio->gpio_chip.ngpio = 13;
-	wm8350_gpio->gpio_chip.parent = &pdev->dev;
-	if (pdata && pdata->gpio_base)
-		wm8350_gpio->gpio_chip.base = pdata->gpio_base;
-	else
-		wm8350_gpio->gpio_chip.base = -1;
-
-	return devm_gpiochip_add_data(&pdev->dev, &wm8350_gpio->gpio_chip, wm8350_gpio);
-}
-
-static struct platform_driver wm8350_gpio_driver = {
-	.driver.name	= "wm8350-gpio",
-	.probe		= wm8350_gpio_probe,
-};
-
-static int __init wm8350_gpio_init(void)
-{
-	return platform_driver_register(&wm8350_gpio_driver);
-}
-subsys_initcall(wm8350_gpio_init);
-
-static void __exit wm8350_gpio_exit(void)
-{
-	platform_driver_unregister(&wm8350_gpio_driver);
-}
-module_exit(wm8350_gpio_exit);
-
-MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
-MODULE_DESCRIPTION("GPIO interface for WM8350 PMICs");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:wm8350-gpio");

@@ -2728,16 +2728,6 @@ config SENSORS_WM831X
 	  This driver can also be built as a module. If so, the module
 	  will be called wm831x-hwmon.
 
-config SENSORS_WM8350
-	tristate "Wolfson Microelectronics WM835x"
-	depends on MFD_WM8350
-	help
-	  If you say yes here you get support for the hardware
-	  monitoring features of the WM835x series of PMICs.
-
-	  This driver can also be built as a module. If so, the module
-	  will be called wm8350-hwmon.
-
 config SENSORS_ULTRA45
 	tristate "Sun Ultra45 PIC16F747"
 	depends on SPARC64

@@ -251,7 +251,6 @@ obj-$(CONFIG_SENSORS_W83627EHF)	+= w83627ehf.o
 obj-$(CONFIG_SENSORS_W83L785TS)	+= w83l785ts.o
 obj-$(CONFIG_SENSORS_W83L786NG)	+= w83l786ng.o
 obj-$(CONFIG_SENSORS_WM831X)	+= wm831x-hwmon.o
-obj-$(CONFIG_SENSORS_WM8350)	+= wm8350-hwmon.o
 obj-$(CONFIG_SENSORS_XGENE)	+= xgene-hwmon.o
 obj-$(CONFIG_SENSORS_YOGAFAN)	+= yogafan.o
 

@@ -1,92 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-/*
- * drivers/hwmon/wm8350-hwmon.c - Wolfson Microelectronics WM8350 PMIC
- *                                  hardware monitoring features.
- *
- * Copyright (C) 2009 Wolfson Microelectronics plc
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/err.h>
-#include <linux/platform_device.h>
-#include <linux/hwmon.h>
-#include <linux/hwmon-sysfs.h>
-
-#include <linux/mfd/wm8350/core.h>
-#include <linux/mfd/wm8350/comparator.h>
-
-static const char * const input_names[] = {
-	[WM8350_AUXADC_USB]  = "USB",
-	[WM8350_AUXADC_LINE] = "Line",
-	[WM8350_AUXADC_BATT] = "Battery",
-};
-
-static ssize_t show_voltage(struct device *dev,
-			    struct device_attribute *attr, char *buf)
-{
-	struct wm8350 *wm8350 = dev_get_drvdata(dev);
-	int channel = to_sensor_dev_attr(attr)->index;
-	int val;
-
-	val = wm8350_read_auxadc(wm8350, channel, 0, 0) * WM8350_AUX_COEFF;
-	val = DIV_ROUND_CLOSEST(val, 1000);
-
-	return sprintf(buf, "%d\n", val);
-}
-
-static ssize_t show_label(struct device *dev,
-			  struct device_attribute *attr, char *buf)
-{
-	int channel = to_sensor_dev_attr(attr)->index;
-
-	return sprintf(buf, "%s\n", input_names[channel]);
-}
-
-#define WM8350_NAMED_VOLTAGE(id, name) \
-	static SENSOR_DEVICE_ATTR(in##id##_input, S_IRUGO, show_voltage,\
-				  NULL, name);		\
-	static SENSOR_DEVICE_ATTR(in##id##_label, S_IRUGO, show_label,	\
-				  NULL, name)
-
-WM8350_NAMED_VOLTAGE(0, WM8350_AUXADC_USB);
-WM8350_NAMED_VOLTAGE(1, WM8350_AUXADC_BATT);
-WM8350_NAMED_VOLTAGE(2, WM8350_AUXADC_LINE);
-
-static struct attribute *wm8350_attrs[] = {
-	&sensor_dev_attr_in0_input.dev_attr.attr,
-	&sensor_dev_attr_in0_label.dev_attr.attr,
-	&sensor_dev_attr_in1_input.dev_attr.attr,
-	&sensor_dev_attr_in1_label.dev_attr.attr,
-	&sensor_dev_attr_in2_input.dev_attr.attr,
-	&sensor_dev_attr_in2_label.dev_attr.attr,
-
-	NULL,
-};
-
-ATTRIBUTE_GROUPS(wm8350);
-
-static int wm8350_hwmon_probe(struct platform_device *pdev)
-{
-	struct wm8350 *wm8350 = platform_get_drvdata(pdev);
-	struct device *hwmon_dev;
-
-	hwmon_dev = devm_hwmon_device_register_with_groups(&pdev->dev, "wm8350",
-							   wm8350,
-							   wm8350_groups);
-	return PTR_ERR_OR_ZERO(hwmon_dev);
-}
-
-static struct platform_driver wm8350_hwmon_driver = {
-	.probe = wm8350_hwmon_probe,
-	.driver = {
-		.name = "wm8350-hwmon",
-	},
-};
-
-module_platform_driver(wm8350_hwmon_driver);
-
-MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
-MODULE_DESCRIPTION("WM8350 Hardware Monitoring");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:wm8350-hwmon");

@@ -610,14 +610,6 @@ config LEDS_WM831X_STATUS
 	  This option enables support for the status LEDs of the WM831x
 	  series of PMICs.
 
-config LEDS_WM8350
-	tristate "LED Support for WM8350 AudioPlus PMIC"
-	depends on LEDS_CLASS
-	depends on MFD_WM8350
-	help
-	  This option enables support for LEDs driven by the Wolfson
-	  Microelectronics WM8350 AudioPlus PMIC.
-
 config LEDS_DA9052
 	tristate "Dialog DA9052/DA9053 LEDS"
 	depends on LEDS_CLASS

@@ -94,7 +94,6 @@ obj-$(CONFIG_LEDS_TPS6105X)		+= leds-tps6105x.o
 obj-$(CONFIG_LEDS_TURRIS_OMNIA)		+= leds-turris-omnia.o
 obj-$(CONFIG_LEDS_UPBOARD)		+= leds-upboard.o
 obj-$(CONFIG_LEDS_WM831X_STATUS)	+= leds-wm831x-status.o
-obj-$(CONFIG_LEDS_WM8350)		+= leds-wm8350.o
 obj-$(CONFIG_LEDS_WRAP)			+= leds-wrap.o
 
 # Kinetic ExpressWire Protocol

@@ -1,267 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-/*
- * LED driver for WM8350 driven LEDS.
- *
- * Copyright(C) 2007, 2008 Wolfson Microelectronics PLC.
- */
-
-#include <linux/kernel.h>
-#include <linux/platform_device.h>
-#include <linux/leds.h>
-#include <linux/err.h>
-#include <linux/mfd/wm8350/pmic.h>
-#include <linux/regulator/consumer.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-
-/* Microamps */
-static const int isink_cur[] = {
-	4,
-	5,
-	6,
-	7,
-	8,
-	10,
-	11,
-	14,
-	16,
-	19,
-	23,
-	27,
-	32,
-	39,
-	46,
-	54,
-	65,
-	77,
-	92,
-	109,
-	130,
-	154,
-	183,
-	218,
-	259,
-	308,
-	367,
-	436,
-	518,
-	616,
-	733,
-	872,
-	1037,
-	1233,
-	1466,
-	1744,
-	2073,
-	2466,
-	2933,
-	3487,
-	4147,
-	4932,
-	5865,
-	6975,
-	8294,
-	9864,
-	11730,
-	13949,
-	16589,
-	19728,
-	23460,
-	27899,
-	33178,
-	39455,
-	46920,
-	55798,
-	66355,
-	78910,
-	93840,
-	111596,
-	132710,
-	157820,
-	187681,
-	223191
-};
-
-#define to_wm8350_led(led_cdev) \
-	container_of(led_cdev, struct wm8350_led, cdev)
-
-static int wm8350_led_enable(struct wm8350_led *led)
-{
-	int ret = 0;
-
-	if (led->enabled)
-		return ret;
-
-	ret = regulator_enable(led->isink);
-	if (ret != 0) {
-		dev_err(led->cdev.dev, "Failed to enable ISINK: %d\n", ret);
-		return ret;
-	}
-
-	ret = regulator_enable(led->dcdc);
-	if (ret != 0) {
-		dev_err(led->cdev.dev, "Failed to enable DCDC: %d\n", ret);
-		regulator_disable(led->isink);
-		return ret;
-	}
-
-	led->enabled = 1;
-
-	return ret;
-}
-
-static int wm8350_led_disable(struct wm8350_led *led)
-{
-	int ret = 0;
-
-	if (!led->enabled)
-		return ret;
-
-	ret = regulator_disable(led->dcdc);
-	if (ret != 0) {
-		dev_err(led->cdev.dev, "Failed to disable DCDC: %d\n", ret);
-		return ret;
-	}
-
-	ret = regulator_disable(led->isink);
-	if (ret != 0) {
-		dev_err(led->cdev.dev, "Failed to disable ISINK: %d\n", ret);
-		ret = regulator_enable(led->dcdc);
-		if (ret != 0)
-			dev_err(led->cdev.dev, "Failed to reenable DCDC: %d\n",
-				ret);
-		return ret;
-	}
-
-	led->enabled = 0;
-
-	return ret;
-}
-
-static int wm8350_led_set(struct led_classdev *led_cdev,
-			   enum led_brightness value)
-{
-	struct wm8350_led *led = to_wm8350_led(led_cdev);
-	unsigned long flags;
-	int ret;
-	int uA;
-
-	led->value = value;
-
-	spin_lock_irqsave(&led->value_lock, flags);
-
-	if (led->value == LED_OFF) {
-		spin_unlock_irqrestore(&led->value_lock, flags);
-		return wm8350_led_disable(led);
-	}
-
-	/* This scales linearly into the index of valid current
-	 * settings which results in a linear scaling of perceived
-	 * brightness due to the non-linear current settings provided
-	 * by the hardware.
-	 */
-	uA = (led->max_uA_index * led->value) / LED_FULL;
-	spin_unlock_irqrestore(&led->value_lock, flags);
-	BUG_ON(uA >= ARRAY_SIZE(isink_cur));
-
-	ret = regulator_set_current_limit(led->isink, isink_cur[uA],
-					  isink_cur[uA]);
-	if (ret != 0) {
-		dev_err(led->cdev.dev, "Failed to set %duA: %d\n",
-			isink_cur[uA], ret);
-		return ret;
-	}
-
-	return wm8350_led_enable(led);
-}
-
-static void wm8350_led_shutdown(struct platform_device *pdev)
-{
-	struct wm8350_led *led = platform_get_drvdata(pdev);
-
-	led->value = LED_OFF;
-	wm8350_led_disable(led);
-}
-
-static int wm8350_led_probe(struct platform_device *pdev)
-{
-	struct regulator *isink, *dcdc;
-	struct wm8350_led *led;
-	struct wm8350_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
-	int i;
-
-	if (pdata == NULL) {
-		dev_err(&pdev->dev, "no platform data\n");
-		return -ENODEV;
-	}
-
-	if (pdata->max_uA < isink_cur[0]) {
-		dev_err(&pdev->dev, "Invalid maximum current %duA\n",
-			pdata->max_uA);
-		return -EINVAL;
-	}
-
-	isink = devm_regulator_get(&pdev->dev, "led_isink");
-	if (IS_ERR(isink)) {
-		dev_err(&pdev->dev, "%s: can't get ISINK\n", __func__);
-		return PTR_ERR(isink);
-	}
-
-	dcdc = devm_regulator_get(&pdev->dev, "led_vcc");
-	if (IS_ERR(dcdc)) {
-		dev_err(&pdev->dev, "%s: can't get DCDC\n", __func__);
-		return PTR_ERR(dcdc);
-	}
-
-	led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
-	if (led == NULL)
-		return -ENOMEM;
-
-	led->cdev.brightness_set_blocking = wm8350_led_set;
-	led->cdev.default_trigger = pdata->default_trigger;
-	led->cdev.name = pdata->name;
-	led->cdev.flags |= LED_CORE_SUSPENDRESUME;
-	led->enabled = regulator_is_enabled(isink);
-	led->isink = isink;
-	led->dcdc = dcdc;
-
-	for (i = 0; i < ARRAY_SIZE(isink_cur) - 1; i++)
-		if (isink_cur[i] >= pdata->max_uA)
-			break;
-	led->max_uA_index = i;
-	if (pdata->max_uA != isink_cur[i])
-		dev_warn(&pdev->dev,
-			 "Maximum current %duA is not directly supported,"
-			 " check platform data\n",
-			 pdata->max_uA);
-
-	spin_lock_init(&led->value_lock);
-	led->value = LED_OFF;
-	platform_set_drvdata(pdev, led);
-
-	return led_classdev_register(&pdev->dev, &led->cdev);
-}
-
-static void wm8350_led_remove(struct platform_device *pdev)
-{
-	struct wm8350_led *led = platform_get_drvdata(pdev);
-
-	led_classdev_unregister(&led->cdev);
-	wm8350_led_disable(led);
-}
-
-static struct platform_driver wm8350_led_driver = {
-	.driver = {
-		   .name = "wm8350-led",
-		   },
-	.probe = wm8350_led_probe,
-	.remove = wm8350_led_remove,
-	.shutdown = wm8350_led_shutdown,
-};
-
-module_platform_driver(wm8350_led_driver);
-
-MODULE_AUTHOR("Mark Brown");
-MODULE_DESCRIPTION("WM8350 LED driver");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:wm8350-led");

@@ -2027,21 +2027,6 @@ config MFD_WM831X_SPI
 	  for accessing the device, additional drivers must be enabled in
 	  order to use the functionality of the device.
 
-config MFD_WM8350
-	bool
-
-config MFD_WM8350_I2C
-	bool "Wolfson Microelectronics WM8350 with I2C"
-	select MFD_WM8350
-	select REGMAP_I2C
-	depends on I2C=y
-	help
-	  The WM8350 is an integrated audio and power management
-	  subsystem with watchdog and RTC functionality for embedded
-	  systems.  This option enables core support for the WM8350 with
-	  I2C as the control interface.  Additional options must be
-	  selected to enable support for the functionality of the chip.
-
 config MFD_WM8994
 	tristate "Wolfson Microelectronics WM8994"
 	select MFD_CORE

@@ -60,10 +60,6 @@ wm831x-objs			+= wm831x-auxadc.o
 obj-$(CONFIG_MFD_WM831X)	+= wm831x.o
 obj-$(CONFIG_MFD_WM831X_I2C)	+= wm831x-i2c.o
 obj-$(CONFIG_MFD_WM831X_SPI)	+= wm831x-spi.o
-wm8350-objs			:= wm8350-core.o wm8350-regmap.o wm8350-gpio.o
-wm8350-objs			+= wm8350-irq.o
-obj-$(CONFIG_MFD_WM8350)	+= wm8350.o
-obj-$(CONFIG_MFD_WM8350_I2C)	+= wm8350-i2c.o
 wm8994-objs			:= wm8994-core.o wm8994-irq.o wm8994-regmap.o
 obj-$(CONFIG_MFD_WM8994)	+= wm8994.o
 obj-$(CONFIG_MFD_WM97xx)	+= wm97xx-core.o

@@ -1,444 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * wm8350-core.c  --  Device access for Wolfson WM8350
- *
- * Copyright 2007, 2008 Wolfson Microelectronics PLC.
- *
- * Author: Liam Girdwood, Mark Brown
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/export.h>
-#include <linux/slab.h>
-#include <linux/bug.h>
-#include <linux/device.h>
-#include <linux/delay.h>
-#include <linux/interrupt.h>
-#include <linux/regmap.h>
-#include <linux/workqueue.h>
-
-#include <linux/mfd/wm8350/core.h>
-#include <linux/mfd/wm8350/audio.h>
-#include <linux/mfd/wm8350/comparator.h>
-#include <linux/mfd/wm8350/gpio.h>
-#include <linux/mfd/wm8350/pmic.h>
-#include <linux/mfd/wm8350/rtc.h>
-#include <linux/mfd/wm8350/supply.h>
-#include <linux/mfd/wm8350/wdt.h>
-
-#define WM8350_CLOCK_CONTROL_1		0x28
-#define WM8350_AIF_TEST			0x74
-
-/* debug */
-#define WM8350_BUS_DEBUG 0
-#if WM8350_BUS_DEBUG
-#define dump(regs, src) do { \
-	int i_; \
-	u16 *src_ = src; \
-	printk(KERN_DEBUG); \
-	for (i_ = 0; i_ < regs; i_++) \
-		printk(" 0x%4.4x", *src_++); \
-	printk("\n"); \
-} while (0);
-#else
-#define dump(bytes, src)
-#endif
-
-#define WM8350_LOCK_DEBUG 0
-#if WM8350_LOCK_DEBUG
-#define ldbg(format, arg...) printk(format, ## arg)
-#else
-#define ldbg(format, arg...)
-#endif
-
-/*
- * WM8350 Device IO
- */
-static DEFINE_MUTEX(reg_lock_mutex);
-
-/*
- * Safe read, modify, write methods
- */
-int wm8350_clear_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
-{
-	return regmap_update_bits(wm8350->regmap, reg, mask, 0);
-}
-EXPORT_SYMBOL_GPL(wm8350_clear_bits);
-
-int wm8350_set_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
-{
-	return regmap_update_bits(wm8350->regmap, reg, mask, mask);
-}
-EXPORT_SYMBOL_GPL(wm8350_set_bits);
-
-u16 wm8350_reg_read(struct wm8350 *wm8350, int reg)
-{
-	unsigned int data;
-	int err;
-
-	err = regmap_read(wm8350->regmap, reg, &data);
-	if (err)
-		dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
-
-	return data;
-}
-EXPORT_SYMBOL_GPL(wm8350_reg_read);
-
-int wm8350_reg_write(struct wm8350 *wm8350, int reg, u16 val)
-{
-	int ret;
-
-	ret = regmap_write(wm8350->regmap, reg, val);
-
-	if (ret)
-		dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
-	return ret;
-}
-EXPORT_SYMBOL_GPL(wm8350_reg_write);
-
-int wm8350_block_read(struct wm8350 *wm8350, int start_reg, int regs,
-		      u16 *dest)
-{
-	int err = 0;
-
-	err = regmap_bulk_read(wm8350->regmap, start_reg, dest, regs);
-	if (err)
-		dev_err(wm8350->dev, "block read starting from R%d failed\n",
-			start_reg);
-
-	return err;
-}
-EXPORT_SYMBOL_GPL(wm8350_block_read);
-
-int wm8350_block_write(struct wm8350 *wm8350, int start_reg, int regs,
-		       u16 *src)
-{
-	int ret = 0;
-
-	ret = regmap_bulk_write(wm8350->regmap, start_reg, src, regs);
-	if (ret)
-		dev_err(wm8350->dev, "block write starting at R%d failed\n",
-			start_reg);
-
-	return ret;
-}
-EXPORT_SYMBOL_GPL(wm8350_block_write);
-
-/**
- * wm8350_reg_lock()
- *
- * The WM8350 has a hardware lock which can be used to prevent writes to
- * some registers (generally those which can cause particularly serious
- * problems if misused).  This function enables that lock.
- *
- * @wm8350: pointer to local driver data structure
- */
-int wm8350_reg_lock(struct wm8350 *wm8350)
-{
-	int ret;
-
-	mutex_lock(&reg_lock_mutex);
-
-	ldbg(__func__);
-
-	ret = wm8350_reg_write(wm8350, WM8350_SECURITY, WM8350_LOCK_KEY);
-	if (ret)
-		dev_err(wm8350->dev, "lock failed\n");
-
-	wm8350->unlocked = false;
-
-	mutex_unlock(&reg_lock_mutex);
-
-	return ret;
-}
-EXPORT_SYMBOL_GPL(wm8350_reg_lock);
-
-/**
- * wm8350_reg_unlock()
- *
- * The WM8350 has a hardware lock which can be used to prevent writes to
- * some registers (generally those which can cause particularly serious
- * problems if misused).  This function disables that lock so updates
- * can be performed.  For maximum safety this should be done only when
- * required.
- *
- * @wm8350: pointer to local driver data structure
- */
-int wm8350_reg_unlock(struct wm8350 *wm8350)
-{
-	int ret;
-
-	mutex_lock(&reg_lock_mutex);
-
-	ldbg(__func__);
-
-	ret = wm8350_reg_write(wm8350, WM8350_SECURITY, WM8350_UNLOCK_KEY);
-	if (ret)
-		dev_err(wm8350->dev, "unlock failed\n");
-
-	wm8350->unlocked = true;
-
-	mutex_unlock(&reg_lock_mutex);
-
-	return ret;
-}
-EXPORT_SYMBOL_GPL(wm8350_reg_unlock);
-
-int wm8350_read_auxadc(struct wm8350 *wm8350, int channel, int scale, int vref)
-{
-	u16 reg, result = 0;
-
-	if (channel < WM8350_AUXADC_AUX1 || channel > WM8350_AUXADC_TEMP)
-		return -EINVAL;
-	if (channel >= WM8350_AUXADC_USB && channel <= WM8350_AUXADC_TEMP
-	    && (scale != 0 || vref != 0))
-		return -EINVAL;
-
-	mutex_lock(&wm8350->auxadc_mutex);
-
-	/* Turn on the ADC */
-	reg = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5);
-	wm8350_reg_write(wm8350, WM8350_POWER_MGMT_5, reg | WM8350_AUXADC_ENA);
-
-	if (scale || vref) {
-		reg = scale << 13;
-		reg |= vref << 12;
-		wm8350_reg_write(wm8350, WM8350_AUX1_READBACK + channel, reg);
-	}
-
-	reg = wm8350_reg_read(wm8350, WM8350_DIGITISER_CONTROL_1);
-	reg |= 1 << channel | WM8350_AUXADC_POLL;
-	wm8350_reg_write(wm8350, WM8350_DIGITISER_CONTROL_1, reg);
-
-	/* If a late IRQ left the completion signalled then consume
-	 * the completion. */
-	try_wait_for_completion(&wm8350->auxadc_done);
-
-	/* We ignore the result of the completion and just check for a
-	 * conversion result, allowing us to soldier on if the IRQ
-	 * infrastructure is not set up for the chip. */
-	wait_for_completion_timeout(&wm8350->auxadc_done, msecs_to_jiffies(5));
-
-	reg = wm8350_reg_read(wm8350, WM8350_DIGITISER_CONTROL_1);
-	if (reg & WM8350_AUXADC_POLL)
-		dev_err(wm8350->dev, "adc chn %d read timeout\n", channel);
-	else
-		result = wm8350_reg_read(wm8350,
-					 WM8350_AUX1_READBACK + channel);
-
-	/* Turn off the ADC */
-	reg = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5);
-	wm8350_reg_write(wm8350, WM8350_POWER_MGMT_5,
-			 reg & ~WM8350_AUXADC_ENA);
-
-	mutex_unlock(&wm8350->auxadc_mutex);
-
-	return result & WM8350_AUXADC_DATA1_MASK;
-}
-EXPORT_SYMBOL_GPL(wm8350_read_auxadc);
-
-static irqreturn_t wm8350_auxadc_irq(int irq, void *irq_data)
-{
-	struct wm8350 *wm8350 = irq_data;
-
-	complete(&wm8350->auxadc_done);
-
-	return IRQ_HANDLED;
-}
-
-/*
- * Register a client device.  This is non-fatal since there is no need to
- * fail the entire device init due to a single platform device failing.
- */
-static void wm8350_client_dev_register(struct wm8350 *wm8350,
-				       const char *name,
-				       struct platform_device **pdev)
-{
-	int ret;
-
-	*pdev = platform_device_alloc(name, -1);
-	if (*pdev == NULL) {
-		dev_err(wm8350->dev, "Failed to allocate %s\n", name);
-		return;
-	}
-
-	(*pdev)->dev.parent = wm8350->dev;
-	platform_set_drvdata(*pdev, wm8350);
-	ret = platform_device_add(*pdev);
-	if (ret != 0) {
-		dev_err(wm8350->dev, "Failed to register %s: %d\n", name, ret);
-		platform_device_put(*pdev);
-		*pdev = NULL;
-	}
-}
-
-int wm8350_device_init(struct wm8350 *wm8350, int irq,
-		       struct wm8350_platform_data *pdata)
-{
-	int ret;
-	unsigned int id1, id2, mask_rev;
-	unsigned int cust_id, mode, chip_rev;
-
-	dev_set_drvdata(wm8350->dev, wm8350);
-
-	/* get WM8350 revision and config mode */
-	ret = regmap_read(wm8350->regmap, WM8350_RESET_ID, &id1);
-	if (ret != 0) {
-		dev_err(wm8350->dev, "Failed to read ID: %d\n", ret);
-		goto err;
-	}
-
-	ret = regmap_read(wm8350->regmap, WM8350_ID, &id2);
-	if (ret != 0) {
-		dev_err(wm8350->dev, "Failed to read ID: %d\n", ret);
-		goto err;
-	}
-
-	ret = regmap_read(wm8350->regmap, WM8350_REVISION, &mask_rev);
-	if (ret != 0) {
-		dev_err(wm8350->dev, "Failed to read revision: %d\n", ret);
-		goto err;
-	}
-
-	if (id1 != 0x6143) {
-		dev_err(wm8350->dev,
-			"Device with ID %x is not a WM8350\n", id1);
-		ret = -ENODEV;
-		goto err;
-	}
-
-	mode = (id2 & WM8350_CONF_STS_MASK) >> 10;
-	cust_id = id2 & WM8350_CUST_ID_MASK;
-	chip_rev = (id2 & WM8350_CHIP_REV_MASK) >> 12;
-	dev_info(wm8350->dev,
-		 "CONF_STS %d, CUST_ID %d, MASK_REV %d, CHIP_REV %d\n",
-		 mode, cust_id, mask_rev, chip_rev);
-
-	if (cust_id != 0) {
-		dev_err(wm8350->dev, "Unsupported CUST_ID\n");
-		ret = -ENODEV;
-		goto err;
-	}
-
-	switch (mask_rev) {
-	case 0:
-		wm8350->pmic.max_dcdc = WM8350_DCDC_6;
-		wm8350->pmic.max_isink = WM8350_ISINK_B;
-
-		switch (chip_rev) {
-		case WM8350_REV_E:
-			dev_info(wm8350->dev, "WM8350 Rev E\n");
-			break;
-		case WM8350_REV_F:
-			dev_info(wm8350->dev, "WM8350 Rev F\n");
-			break;
-		case WM8350_REV_G:
-			dev_info(wm8350->dev, "WM8350 Rev G\n");
-			wm8350->power.rev_g_coeff = 1;
-			break;
-		case WM8350_REV_H:
-			dev_info(wm8350->dev, "WM8350 Rev H\n");
-			wm8350->power.rev_g_coeff = 1;
-			break;
-		default:
-			/* For safety we refuse to run on unknown hardware */
-			dev_err(wm8350->dev, "Unknown WM8350 CHIP_REV\n");
-			ret = -ENODEV;
-			goto err;
-		}
-		break;
-
-	case 1:
-		wm8350->pmic.max_dcdc = WM8350_DCDC_4;
-		wm8350->pmic.max_isink = WM8350_ISINK_A;
-
-		switch (chip_rev) {
-		case 0:
-			dev_info(wm8350->dev, "WM8351 Rev A\n");
-			wm8350->power.rev_g_coeff = 1;
-			break;
-
-		case 1:
-			dev_info(wm8350->dev, "WM8351 Rev B\n");
-			wm8350->power.rev_g_coeff = 1;
-			break;
-
-		default:
-			dev_err(wm8350->dev, "Unknown WM8351 CHIP_REV\n");
-			ret = -ENODEV;
-			goto err;
-		}
-		break;
-
-	case 2:
-		wm8350->pmic.max_dcdc = WM8350_DCDC_6;
-		wm8350->pmic.max_isink = WM8350_ISINK_B;
-
-		switch (chip_rev) {
-		case 0:
-			dev_info(wm8350->dev, "WM8352 Rev A\n");
-			wm8350->power.rev_g_coeff = 1;
-			break;
-
-		default:
-			dev_err(wm8350->dev, "Unknown WM8352 CHIP_REV\n");
-			ret = -ENODEV;
-			goto err;
-		}
-		break;
-
-	default:
-		dev_err(wm8350->dev, "Unknown MASK_REV\n");
-		ret = -ENODEV;
-		goto err;
-	}
-
-	mutex_init(&wm8350->auxadc_mutex);
-	init_completion(&wm8350->auxadc_done);
-
-	ret = wm8350_irq_init(wm8350, irq, pdata);
-	if (ret < 0)
-		goto err;
-
-	if (wm8350->irq_base) {
-		ret = request_threaded_irq(wm8350->irq_base +
-					   WM8350_IRQ_AUXADC_DATARDY,
-					   NULL, wm8350_auxadc_irq,
-					   IRQF_ONESHOT,
-					   "auxadc", wm8350);
-		if (ret < 0)
-			dev_warn(wm8350->dev,
-				 "Failed to request AUXADC IRQ: %d\n", ret);
-	}
-
-	if (pdata && pdata->init) {
-		ret = pdata->init(wm8350);
-		if (ret != 0) {
-			dev_err(wm8350->dev, "Platform init() failed: %d\n",
-				ret);
-			goto err_irq;
-		}
-	}
-
-	wm8350_reg_write(wm8350, WM8350_SYSTEM_INTERRUPTS_MASK, 0x0);
-
-	wm8350_client_dev_register(wm8350, "wm8350-codec",
-				   &(wm8350->codec.pdev));
-	wm8350_client_dev_register(wm8350, "wm8350-gpio",
-				   &(wm8350->gpio.pdev));
-	wm8350_client_dev_register(wm8350, "wm8350-hwmon",
-				   &(wm8350->hwmon.pdev));
-	wm8350_client_dev_register(wm8350, "wm8350-power",
-				   &(wm8350->power.pdev));
-	wm8350_client_dev_register(wm8350, "wm8350-rtc", &(wm8350->rtc.pdev));
-	wm8350_client_dev_register(wm8350, "wm8350-wdt", &(wm8350->wdt.pdev));
-
-	return 0;
-
-err_irq:
-	wm8350_irq_exit(wm8350);
-err:
-	return ret;
-}
-EXPORT_SYMBOL_GPL(wm8350_device_init);

@@ -1,217 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * wm8350-core.c  --  Device access for Wolfson WM8350
- *
- * Copyright 2007, 2008 Wolfson Microelectronics PLC.
- *
- * Author: Liam Girdwood
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/errno.h>
-
-#include <linux/mfd/wm8350/core.h>
-#include <linux/mfd/wm8350/gpio.h>
-#include <linux/mfd/wm8350/pmic.h>
-
-static int gpio_set_dir(struct wm8350 *wm8350, int gpio, int dir)
-{
-	int ret;
-
-	wm8350_reg_unlock(wm8350);
-	if (dir == WM8350_GPIO_DIR_OUT)
-		ret = wm8350_clear_bits(wm8350,
-					WM8350_GPIO_CONFIGURATION_I_O,
-					1 << gpio);
-	else
-		ret = wm8350_set_bits(wm8350,
-				      WM8350_GPIO_CONFIGURATION_I_O,
-				      1 << gpio);
-	wm8350_reg_lock(wm8350);
-	return ret;
-}
-
-static int wm8350_gpio_set_debounce(struct wm8350 *wm8350, int gpio, int db)
-{
-	if (db == WM8350_GPIO_DEBOUNCE_ON)
-		return wm8350_set_bits(wm8350, WM8350_GPIO_DEBOUNCE,
-				       1 << gpio);
-	else
-		return wm8350_clear_bits(wm8350,
-					 WM8350_GPIO_DEBOUNCE, 1 << gpio);
-}
-
-static int gpio_set_func(struct wm8350 *wm8350, int gpio, int func)
-{
-	u16 reg;
-
-	wm8350_reg_unlock(wm8350);
-	switch (gpio) {
-	case 0:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_1)
-		    & ~WM8350_GP0_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_1,
-				 reg | ((func & 0xf) << 0));
-		break;
-	case 1:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_1)
-		    & ~WM8350_GP1_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_1,
-				 reg | ((func & 0xf) << 4));
-		break;
-	case 2:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_1)
-		    & ~WM8350_GP2_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_1,
-				 reg | ((func & 0xf) << 8));
-		break;
-	case 3:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_1)
-		    & ~WM8350_GP3_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_1,
-				 reg | ((func & 0xf) << 12));
-		break;
-	case 4:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_2)
-		    & ~WM8350_GP4_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_2,
-				 reg | ((func & 0xf) << 0));
-		break;
-	case 5:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_2)
-		    & ~WM8350_GP5_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_2,
-				 reg | ((func & 0xf) << 4));
-		break;
-	case 6:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_2)
-		    & ~WM8350_GP6_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_2,
-				 reg | ((func & 0xf) << 8));
-		break;
-	case 7:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_2)
-		    & ~WM8350_GP7_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_2,
-				 reg | ((func & 0xf) << 12));
-		break;
-	case 8:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_3)
-		    & ~WM8350_GP8_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_3,
-				 reg | ((func & 0xf) << 0));
-		break;
-	case 9:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_3)
-		    & ~WM8350_GP9_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_3,
-				 reg | ((func & 0xf) << 4));
-		break;
-	case 10:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_3)
-		    & ~WM8350_GP10_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_3,
-				 reg | ((func & 0xf) << 8));
-		break;
-	case 11:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_3)
-		    & ~WM8350_GP11_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_3,
-				 reg | ((func & 0xf) << 12));
-		break;
-	case 12:
-		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_4)
-		    & ~WM8350_GP12_FN_MASK;
-		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_4,
-				 reg | ((func & 0xf) << 0));
-		break;
-	default:
-		wm8350_reg_lock(wm8350);
-		return -EINVAL;
-	}
-
-	wm8350_reg_lock(wm8350);
-	return 0;
-}
-
-static int gpio_set_pull_up(struct wm8350 *wm8350, int gpio, int up)
-{
-	if (up)
-		return wm8350_set_bits(wm8350,
-				       WM8350_GPIO_PIN_PULL_UP_CONTROL,
-				       1 << gpio);
-	else
-		return wm8350_clear_bits(wm8350,
-					 WM8350_GPIO_PIN_PULL_UP_CONTROL,
-					 1 << gpio);
-}
-
-static int gpio_set_pull_down(struct wm8350 *wm8350, int gpio, int down)
-{
-	if (down)
-		return wm8350_set_bits(wm8350,
-				       WM8350_GPIO_PULL_DOWN_CONTROL,
-				       1 << gpio);
-	else
-		return wm8350_clear_bits(wm8350,
-					 WM8350_GPIO_PULL_DOWN_CONTROL,
-					 1 << gpio);
-}
-
-static int gpio_set_polarity(struct wm8350 *wm8350, int gpio, int pol)
-{
-	if (pol == WM8350_GPIO_ACTIVE_HIGH)
-		return wm8350_set_bits(wm8350,
-				       WM8350_GPIO_PIN_POLARITY_TYPE,
-				       1 << gpio);
-	else
-		return wm8350_clear_bits(wm8350,
-					 WM8350_GPIO_PIN_POLARITY_TYPE,
-					 1 << gpio);
-}
-
-static int gpio_set_invert(struct wm8350 *wm8350, int gpio, int invert)
-{
-	if (invert == WM8350_GPIO_INVERT_ON)
-		return wm8350_set_bits(wm8350, WM8350_GPIO_INT_MODE, 1 << gpio);
-	else
-		return wm8350_clear_bits(wm8350,
-					 WM8350_GPIO_INT_MODE, 1 << gpio);
-}
-
-int wm8350_gpio_config(struct wm8350 *wm8350, int gpio, int dir, int func,
-		       int pol, int pull, int invert, int debounce)
-{
-	/* make sure we never pull up and down at the same time */
-	if (pull == WM8350_GPIO_PULL_NONE) {
-		if (gpio_set_pull_up(wm8350, gpio, 0))
-			goto err;
-		if (gpio_set_pull_down(wm8350, gpio, 0))
-			goto err;
-	} else if (pull == WM8350_GPIO_PULL_UP) {
-		if (gpio_set_pull_down(wm8350, gpio, 0))
-			goto err;
-		if (gpio_set_pull_up(wm8350, gpio, 1))
-			goto err;
-	} else if (pull == WM8350_GPIO_PULL_DOWN) {
-		if (gpio_set_pull_up(wm8350, gpio, 0))
-			goto err;
-		if (gpio_set_pull_down(wm8350, gpio, 1))
-			goto err;
-	}
-
-	if (gpio_set_invert(wm8350, gpio, invert))
-		goto err;
-	if (gpio_set_polarity(wm8350, gpio, pol))
-		goto err;
-	if (wm8350_gpio_set_debounce(wm8350, gpio, debounce))
-		goto err;
-	if (gpio_set_dir(wm8350, gpio, dir))
-		goto err;
-	return gpio_set_func(wm8350, gpio, func);
-
-err:
-	return -EIO;
-}
-EXPORT_SYMBOL_GPL(wm8350_gpio_config);

@@ -1,64 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * wm8350-i2c.c  --  Generic I2C driver for Wolfson WM8350 PMIC
- *
- * Copyright 2007, 2008 Wolfson Microelectronics PLC.
- *
- * Author: Liam Girdwood
- *         linux@wolfsonmicro.com
- */
-
-#include <linux/err.h>
-#include <linux/init.h>
-#include <linux/i2c.h>
-#include <linux/platform_device.h>
-#include <linux/mfd/wm8350/core.h>
-#include <linux/regmap.h>
-#include <linux/slab.h>
-
-static int wm8350_i2c_probe(struct i2c_client *i2c)
-{
-	struct wm8350 *wm8350;
-	struct wm8350_platform_data *pdata = dev_get_platdata(&i2c->dev);
-	int ret = 0;
-
-	wm8350 = devm_kzalloc(&i2c->dev, sizeof(struct wm8350), GFP_KERNEL);
-	if (wm8350 == NULL)
-		return -ENOMEM;
-
-	wm8350->regmap = devm_regmap_init_i2c(i2c, &wm8350_regmap);
-	if (IS_ERR(wm8350->regmap)) {
-		ret = PTR_ERR(wm8350->regmap);
-		dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
-			ret);
-		return ret;
-	}
-
-	i2c_set_clientdata(i2c, wm8350);
-	wm8350->dev = &i2c->dev;
-
-	return wm8350_device_init(wm8350, i2c->irq, pdata);
-}
-
-static const struct i2c_device_id wm8350_i2c_id[] = {
-	{ "wm8350" },
-	{ "wm8351" },
-	{ "wm8352" },
-	{ }
-};
-
-static struct i2c_driver wm8350_i2c_driver = {
-	.driver = {
-		   .name = "wm8350",
-		   .suppress_bind_attrs = true,
-	},
-	.probe = wm8350_i2c_probe,
-	.id_table = wm8350_i2c_id,
-};
-
-static int __init wm8350_i2c_init(void)
-{
-	return i2c_add_driver(&wm8350_i2c_driver);
-}
-/* init early so consumer devices can complete system boot */
-subsys_initcall(wm8350_i2c_init);

@@ -1,542 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * wm8350-irq.c  --  IRQ support for Wolfson WM8350
- *
- * Copyright 2007, 2008, 2009 Wolfson Microelectronics PLC.
- *
- * Author: Liam Girdwood, Mark Brown
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/bug.h>
-#include <linux/device.h>
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-
-#include <linux/mfd/wm8350/core.h>
-#include <linux/mfd/wm8350/audio.h>
-#include <linux/mfd/wm8350/comparator.h>
-#include <linux/mfd/wm8350/gpio.h>
-#include <linux/mfd/wm8350/pmic.h>
-#include <linux/mfd/wm8350/rtc.h>
-#include <linux/mfd/wm8350/supply.h>
-#include <linux/mfd/wm8350/wdt.h>
-
-#define WM8350_INT_OFFSET_1                     0
-#define WM8350_INT_OFFSET_2                     1
-#define WM8350_POWER_UP_INT_OFFSET              2
-#define WM8350_UNDER_VOLTAGE_INT_OFFSET         3
-#define WM8350_OVER_CURRENT_INT_OFFSET          4
-#define WM8350_GPIO_INT_OFFSET                  5
-#define WM8350_COMPARATOR_INT_OFFSET            6
-
-struct wm8350_irq_data {
-	int primary;
-	int reg;
-	int mask;
-	int primary_only;
-};
-
-static struct wm8350_irq_data wm8350_irqs[] = {
-	[WM8350_IRQ_OC_LS] = {
-		.primary = WM8350_OC_INT,
-		.reg = WM8350_OVER_CURRENT_INT_OFFSET,
-		.mask = WM8350_OC_LS_EINT,
-		.primary_only = 1,
-	},
-	[WM8350_IRQ_UV_DC1] = {
-		.primary = WM8350_UV_INT,
-		.reg = WM8350_UNDER_VOLTAGE_INT_OFFSET,
-		.mask = WM8350_UV_DC1_EINT,
-	},
-	[WM8350_IRQ_UV_DC2] = {
-		.primary = WM8350_UV_INT,
-		.reg = WM8350_UNDER_VOLTAGE_INT_OFFSET,
-		.mask = WM8350_UV_DC2_EINT,
-	},
-	[WM8350_IRQ_UV_DC3] = {
-		.primary = WM8350_UV_INT,
-		.reg = WM8350_UNDER_VOLTAGE_INT_OFFSET,
-		.mask = WM8350_UV_DC3_EINT,
-	},
-	[WM8350_IRQ_UV_DC4] = {
-		.primary = WM8350_UV_INT,
-		.reg = WM8350_UNDER_VOLTAGE_INT_OFFSET,
-		.mask = WM8350_UV_DC4_EINT,
-	},
-	[WM8350_IRQ_UV_DC5] = {
-		.primary = WM8350_UV_INT,
-		.reg = WM8350_UNDER_VOLTAGE_INT_OFFSET,
-		.mask = WM8350_UV_DC5_EINT,
-	},
-	[WM8350_IRQ_UV_DC6] = {
-		.primary = WM8350_UV_INT,
-		.reg = WM8350_UNDER_VOLTAGE_INT_OFFSET,
-		.mask = WM8350_UV_DC6_EINT,
-	},
-	[WM8350_IRQ_UV_LDO1] = {
-		.primary = WM8350_UV_INT,
-		.reg = WM8350_UNDER_VOLTAGE_INT_OFFSET,
-		.mask = WM8350_UV_LDO1_EINT,
-	},
-	[WM8350_IRQ_UV_LDO2] = {
-		.primary = WM8350_UV_INT,
-		.reg = WM8350_UNDER_VOLTAGE_INT_OFFSET,
-		.mask = WM8350_UV_LDO2_EINT,
-	},
-	[WM8350_IRQ_UV_LDO3] = {
-		.primary = WM8350_UV_INT,
-		.reg = WM8350_UNDER_VOLTAGE_INT_OFFSET,
-		.mask = WM8350_UV_LDO3_EINT,
-	},
-	[WM8350_IRQ_UV_LDO4] = {
-		.primary = WM8350_UV_INT,
-		.reg = WM8350_UNDER_VOLTAGE_INT_OFFSET,
-		.mask = WM8350_UV_LDO4_EINT,
-	},
-	[WM8350_IRQ_CHG_BAT_HOT] = {
-		.primary = WM8350_CHG_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_CHG_BAT_HOT_EINT,
-	},
-	[WM8350_IRQ_CHG_BAT_COLD] = {
-		.primary = WM8350_CHG_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_CHG_BAT_COLD_EINT,
-	},
-	[WM8350_IRQ_CHG_BAT_FAIL] = {
-		.primary = WM8350_CHG_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_CHG_BAT_FAIL_EINT,
-	},
-	[WM8350_IRQ_CHG_TO] = {
-		.primary = WM8350_CHG_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_CHG_TO_EINT,
-	},
-	[WM8350_IRQ_CHG_END] = {
-		.primary = WM8350_CHG_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_CHG_END_EINT,
-	},
-	[WM8350_IRQ_CHG_START] = {
-		.primary = WM8350_CHG_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_CHG_START_EINT,
-	},
-	[WM8350_IRQ_CHG_FAST_RDY] = {
-		.primary = WM8350_CHG_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_CHG_FAST_RDY_EINT,
-	},
-	[WM8350_IRQ_CHG_VBATT_LT_3P9] = {
-		.primary = WM8350_CHG_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_CHG_VBATT_LT_3P9_EINT,
-	},
-	[WM8350_IRQ_CHG_VBATT_LT_3P1] = {
-		.primary = WM8350_CHG_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_CHG_VBATT_LT_3P1_EINT,
-	},
-	[WM8350_IRQ_CHG_VBATT_LT_2P85] = {
-		.primary = WM8350_CHG_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_CHG_VBATT_LT_2P85_EINT,
-	},
-	[WM8350_IRQ_RTC_ALM] = {
-		.primary = WM8350_RTC_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_RTC_ALM_EINT,
-	},
-	[WM8350_IRQ_RTC_SEC] = {
-		.primary = WM8350_RTC_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_RTC_SEC_EINT,
-	},
-	[WM8350_IRQ_RTC_PER] = {
-		.primary = WM8350_RTC_INT,
-		.reg = WM8350_INT_OFFSET_1,
-		.mask = WM8350_RTC_PER_EINT,
-	},
-	[WM8350_IRQ_CS1] = {
-		.primary = WM8350_CS_INT,
-		.reg = WM8350_INT_OFFSET_2,
-		.mask = WM8350_CS1_EINT,
-	},
-	[WM8350_IRQ_CS2] = {
-		.primary = WM8350_CS_INT,
-		.reg = WM8350_INT_OFFSET_2,
-		.mask = WM8350_CS2_EINT,
-	},
-	[WM8350_IRQ_SYS_HYST_COMP_FAIL] = {
-		.primary = WM8350_SYS_INT,
-		.reg = WM8350_INT_OFFSET_2,
-		.mask = WM8350_SYS_HYST_COMP_FAIL_EINT,
-	},
-	[WM8350_IRQ_SYS_CHIP_GT115] = {
-		.primary = WM8350_SYS_INT,
-		.reg = WM8350_INT_OFFSET_2,
-		.mask = WM8350_SYS_CHIP_GT115_EINT,
-	},
-	[WM8350_IRQ_SYS_CHIP_GT140] = {
-		.primary = WM8350_SYS_INT,
-		.reg = WM8350_INT_OFFSET_2,
-		.mask = WM8350_SYS_CHIP_GT140_EINT,
-	},
-	[WM8350_IRQ_SYS_WDOG_TO] = {
-		.primary = WM8350_SYS_INT,
-		.reg = WM8350_INT_OFFSET_2,
-		.mask = WM8350_SYS_WDOG_TO_EINT,
-	},
-	[WM8350_IRQ_AUXADC_DATARDY] = {
-		.primary = WM8350_AUXADC_INT,
-		.reg = WM8350_INT_OFFSET_2,
-		.mask = WM8350_AUXADC_DATARDY_EINT,
-	},
-	[WM8350_IRQ_AUXADC_DCOMP4] = {
-		.primary = WM8350_AUXADC_INT,
-		.reg = WM8350_INT_OFFSET_2,
-		.mask = WM8350_AUXADC_DCOMP4_EINT,
-	},
-	[WM8350_IRQ_AUXADC_DCOMP3] = {
-		.primary = WM8350_AUXADC_INT,
-		.reg = WM8350_INT_OFFSET_2,
-		.mask = WM8350_AUXADC_DCOMP3_EINT,
-	},
-	[WM8350_IRQ_AUXADC_DCOMP2] = {
-		.primary = WM8350_AUXADC_INT,
-		.reg = WM8350_INT_OFFSET_2,
-		.mask = WM8350_AUXADC_DCOMP2_EINT,
-	},
-	[WM8350_IRQ_AUXADC_DCOMP1] = {
-		.primary = WM8350_AUXADC_INT,
-		.reg = WM8350_INT_OFFSET_2,
-		.mask = WM8350_AUXADC_DCOMP1_EINT,
-	},
-	[WM8350_IRQ_USB_LIMIT] = {
-		.primary = WM8350_USB_INT,
-		.reg = WM8350_INT_OFFSET_2,
-		.mask = WM8350_USB_LIMIT_EINT,
-		.primary_only = 1,
-	},
-	[WM8350_IRQ_WKUP_OFF_STATE] = {
-		.primary = WM8350_WKUP_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_WKUP_OFF_STATE_EINT,
-	},
-	[WM8350_IRQ_WKUP_HIB_STATE] = {
-		.primary = WM8350_WKUP_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_WKUP_HIB_STATE_EINT,
-	},
-	[WM8350_IRQ_WKUP_CONV_FAULT] = {
-		.primary = WM8350_WKUP_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_WKUP_CONV_FAULT_EINT,
-	},
-	[WM8350_IRQ_WKUP_WDOG_RST] = {
-		.primary = WM8350_WKUP_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_WKUP_WDOG_RST_EINT,
-	},
-	[WM8350_IRQ_WKUP_GP_PWR_ON] = {
-		.primary = WM8350_WKUP_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_WKUP_GP_PWR_ON_EINT,
-	},
-	[WM8350_IRQ_WKUP_ONKEY] = {
-		.primary = WM8350_WKUP_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_WKUP_ONKEY_EINT,
-	},
-	[WM8350_IRQ_WKUP_GP_WAKEUP] = {
-		.primary = WM8350_WKUP_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_WKUP_GP_WAKEUP_EINT,
-	},
-	[WM8350_IRQ_CODEC_JCK_DET_L] = {
-		.primary = WM8350_CODEC_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_CODEC_JCK_DET_L_EINT,
-	},
-	[WM8350_IRQ_CODEC_JCK_DET_R] = {
-		.primary = WM8350_CODEC_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_CODEC_JCK_DET_R_EINT,
-	},
-	[WM8350_IRQ_CODEC_MICSCD] = {
-		.primary = WM8350_CODEC_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_CODEC_MICSCD_EINT,
-	},
-	[WM8350_IRQ_CODEC_MICD] = {
-		.primary = WM8350_CODEC_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_CODEC_MICD_EINT,
-	},
-	[WM8350_IRQ_EXT_USB_FB] = {
-		.primary = WM8350_EXT_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_EXT_USB_FB_EINT,
-	},
-	[WM8350_IRQ_EXT_WALL_FB] = {
-		.primary = WM8350_EXT_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_EXT_WALL_FB_EINT,
-	},
-	[WM8350_IRQ_EXT_BAT_FB] = {
-		.primary = WM8350_EXT_INT,
-		.reg = WM8350_COMPARATOR_INT_OFFSET,
-		.mask = WM8350_EXT_BAT_FB_EINT,
-	},
-	[WM8350_IRQ_GPIO(0)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP0_EINT,
-	},
-	[WM8350_IRQ_GPIO(1)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP1_EINT,
-	},
-	[WM8350_IRQ_GPIO(2)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP2_EINT,
-	},
-	[WM8350_IRQ_GPIO(3)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP3_EINT,
-	},
-	[WM8350_IRQ_GPIO(4)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP4_EINT,
-	},
-	[WM8350_IRQ_GPIO(5)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP5_EINT,
-	},
-	[WM8350_IRQ_GPIO(6)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP6_EINT,
-	},
-	[WM8350_IRQ_GPIO(7)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP7_EINT,
-	},
-	[WM8350_IRQ_GPIO(8)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP8_EINT,
-	},
-	[WM8350_IRQ_GPIO(9)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP9_EINT,
-	},
-	[WM8350_IRQ_GPIO(10)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP10_EINT,
-	},
-	[WM8350_IRQ_GPIO(11)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP11_EINT,
-	},
-	[WM8350_IRQ_GPIO(12)] = {
-		.primary = WM8350_GP_INT,
-		.reg = WM8350_GPIO_INT_OFFSET,
-		.mask = WM8350_GP12_EINT,
-	},
-};
-
-static inline struct wm8350_irq_data *irq_to_wm8350_irq(struct wm8350 *wm8350,
-							int irq)
-{
-	return &wm8350_irqs[irq - wm8350->irq_base];
-}
-
-/*
- * This is a threaded IRQ handler so can access I2C/SPI.  Since all
- * interrupts are clear on read the IRQ line will be reasserted and
- * the physical IRQ will be handled again if another interrupt is
- * asserted while we run - in the normal course of events this is a
- * rare occurrence so we save I2C/SPI reads.  We're also assuming that
- * it's rare to get lots of interrupts firing simultaneously so try to
- * minimise I/O.
- */
-static irqreturn_t wm8350_irq(int irq, void *irq_data)
-{
-	struct wm8350 *wm8350 = irq_data;
-	u16 level_one;
-	u16 sub_reg[WM8350_NUM_IRQ_REGS];
-	int read_done[WM8350_NUM_IRQ_REGS];
-	struct wm8350_irq_data *data;
-	int i;
-
-	level_one = wm8350_reg_read(wm8350, WM8350_SYSTEM_INTERRUPTS)
-		& ~wm8350_reg_read(wm8350, WM8350_SYSTEM_INTERRUPTS_MASK);
-
-	if (!level_one)
-		return IRQ_NONE;
-
-	memset(&read_done, 0, sizeof(read_done));
-
-	for (i = 0; i < ARRAY_SIZE(wm8350_irqs); i++) {
-		data = &wm8350_irqs[i];
-
-		if (!(level_one & data->primary))
-			continue;
-
-		if (!read_done[data->reg]) {
-			sub_reg[data->reg] =
-				wm8350_reg_read(wm8350, WM8350_INT_STATUS_1 +
-						data->reg);
-			sub_reg[data->reg] &= ~wm8350->irq_masks[data->reg];
-			read_done[data->reg] = 1;
-		}
-
-		if (sub_reg[data->reg] & data->mask)
-			handle_nested_irq(wm8350->irq_base + i);
-	}
-
-	return IRQ_HANDLED;
-}
-
-static void wm8350_irq_lock(struct irq_data *data)
-{
-	struct wm8350 *wm8350 = irq_data_get_irq_chip_data(data);
-
-	mutex_lock(&wm8350->irq_lock);
-}
-
-static void wm8350_irq_sync_unlock(struct irq_data *data)
-{
-	struct wm8350 *wm8350 = irq_data_get_irq_chip_data(data);
-	int i;
-
-	for (i = 0; i < ARRAY_SIZE(wm8350->irq_masks); i++) {
-		/* If there's been a change in the mask write it back
-		 * to the hardware. */
-		WARN_ON(regmap_update_bits(wm8350->regmap,
-					   WM8350_INT_STATUS_1_MASK + i,
-					   0xffff, wm8350->irq_masks[i]));
-	}
-
-	mutex_unlock(&wm8350->irq_lock);
-}
-
-static void wm8350_irq_enable(struct irq_data *data)
-{
-	struct wm8350 *wm8350 = irq_data_get_irq_chip_data(data);
-	struct wm8350_irq_data *irq_data = irq_to_wm8350_irq(wm8350,
-							     data->irq);
-
-	wm8350->irq_masks[irq_data->reg] &= ~irq_data->mask;
-}
-
-static void wm8350_irq_disable(struct irq_data *data)
-{
-	struct wm8350 *wm8350 = irq_data_get_irq_chip_data(data);
-	struct wm8350_irq_data *irq_data = irq_to_wm8350_irq(wm8350,
-							     data->irq);
-
-	wm8350->irq_masks[irq_data->reg] |= irq_data->mask;
-}
-
-static struct irq_chip wm8350_irq_chip = {
-	.name			= "wm8350",
-	.irq_bus_lock		= wm8350_irq_lock,
-	.irq_bus_sync_unlock	= wm8350_irq_sync_unlock,
-	.irq_disable		= wm8350_irq_disable,
-	.irq_enable		= wm8350_irq_enable,
-};
-
-int wm8350_irq_init(struct wm8350 *wm8350, int irq,
-		    struct wm8350_platform_data *pdata)
-{
-	int ret, cur_irq, i;
-	int flags = IRQF_ONESHOT;
-	int irq_base = -1;
-
-	if (!irq) {
-		dev_warn(wm8350->dev, "No interrupt support, no core IRQ\n");
-		return 0;
-	}
-
-	/* Mask top level interrupts */
-	wm8350_reg_write(wm8350, WM8350_SYSTEM_INTERRUPTS_MASK, 0xFFFF);
-
-	/* Mask all individual interrupts by default and cache the
-	 * masks.  We read the masks back since there are unwritable
-	 * bits in the mask registers. */
-	for (i = 0; i < ARRAY_SIZE(wm8350->irq_masks); i++) {
-		wm8350_reg_write(wm8350, WM8350_INT_STATUS_1_MASK + i,
-				 0xFFFF);
-		wm8350->irq_masks[i] =
-			wm8350_reg_read(wm8350,
-					WM8350_INT_STATUS_1_MASK + i);
-	}
-
-	mutex_init(&wm8350->irq_lock);
-	wm8350->chip_irq = irq;
-
-	if (pdata && pdata->irq_base > 0)
-		irq_base = pdata->irq_base;
-
-	wm8350->irq_base =
-		irq_alloc_descs(irq_base, 0, ARRAY_SIZE(wm8350_irqs), 0);
-	if (wm8350->irq_base < 0) {
-		dev_warn(wm8350->dev, "Allocating irqs failed with %d\n",
-			wm8350->irq_base);
-		return 0;
-	}
-
-	if (pdata && pdata->irq_high) {
-		flags |= IRQF_TRIGGER_HIGH;
-
-		wm8350_set_bits(wm8350, WM8350_SYSTEM_CONTROL_1,
-				WM8350_IRQ_POL);
-	} else {
-		flags |= IRQF_TRIGGER_LOW;
-
-		wm8350_clear_bits(wm8350, WM8350_SYSTEM_CONTROL_1,
-				  WM8350_IRQ_POL);
-	}
-
-	/* Register with genirq */
-	for (cur_irq = wm8350->irq_base;
-	     cur_irq < ARRAY_SIZE(wm8350_irqs) + wm8350->irq_base;
-	     cur_irq++) {
-		irq_set_chip_data(cur_irq, wm8350);
-		irq_set_chip_and_handler(cur_irq, &wm8350_irq_chip,
-					 handle_edge_irq);
-		irq_set_nested_thread(cur_irq, 1);
-
-		irq_clear_status_flags(cur_irq, IRQ_NOREQUEST | IRQ_NOPROBE);
-	}
-
-	ret = request_threaded_irq(irq, NULL, wm8350_irq, flags,
-				   "wm8350", wm8350);
-	if (ret != 0)
-		dev_err(wm8350->dev, "Failed to request IRQ: %d\n", ret);
-
-	/* Allow interrupts to fire */
-	wm8350_reg_write(wm8350, WM8350_SYSTEM_INTERRUPTS_MASK, 0);
-
-	return ret;
-}
-
-int wm8350_irq_exit(struct wm8350 *wm8350)
-{
-	free_irq(wm8350->chip_irq, wm8350);
-	return 0;
-}

@@ -1,335 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * wm8350-regmap.c  --  Wolfson Microelectronics WM8350 register map
- *
- * This file splits out the tables describing the defaults and access
- * status of the WM8350 registers since they are rather large.
- *
- * Copyright 2007, 2008 Wolfson Microelectronics PLC.
- */
-
-#include <linux/mfd/wm8350/core.h>
-
-/*
- * Access masks.
- */
-
-static const struct wm8350_reg_access {
-	u16 readable;		/* Mask of readable bits */
-	u16 writable;		/* Mask of writable bits */
-	u16 vol;		/* Mask of volatile bits */
-} wm8350_reg_io_map[] = {
-	/*  read    write volatile */
-	{ 0xFFFF, 0xFFFF, 0x0000 }, /* R0   - Reset/ID */
-	{ 0x7CFF, 0x0C00, 0x0000 }, /* R1   - ID */
-	{ 0x007F, 0x0000, 0x0000 }, /* R2   - ROM Mask ID */
-	{ 0xBE3B, 0xBE3B, 0x8000 }, /* R3   - System Control 1 */
-	{ 0xFEF7, 0xFEF7, 0xF800 }, /* R4   - System Control 2 */
-	{ 0x80FF, 0x80FF, 0x8000 }, /* R5   - System Hibernate */
-	{ 0xFB0E, 0xFB0E, 0x0000 }, /* R6   - Interface Control */
-	{ 0x0000, 0x0000, 0x0000 }, /* R7 */
-	{ 0xE537, 0xE537, 0xFFFF }, /* R8   - Power mgmt (1) */
-	{ 0x0FF3, 0x0FF3, 0xFFFF }, /* R9   - Power mgmt (2) */
-	{ 0x008F, 0x008F, 0xFFFF }, /* R10  - Power mgmt (3) */
-	{ 0x6D3C, 0x6D3C, 0xFFFF }, /* R11  - Power mgmt (4) */
-	{ 0x1F8F, 0x1F8F, 0xFFFF }, /* R12  - Power mgmt (5) */
-	{ 0x8F3F, 0x8F3F, 0xFFFF }, /* R13  - Power mgmt (6) */
-	{ 0x0003, 0x0003, 0xFFFF }, /* R14  - Power mgmt (7) */
-	{ 0x0000, 0x0000, 0x0000 }, /* R15 */
-	{ 0x7F7F, 0x7F7F, 0xFFFF }, /* R16  - RTC Seconds/Minutes */
-	{ 0x073F, 0x073F, 0xFFFF }, /* R17  - RTC Hours/Day */
-	{ 0x1F3F, 0x1F3F, 0xFFFF }, /* R18  - RTC Date/Month */
-	{ 0x3FFF, 0x00FF, 0xFFFF }, /* R19  - RTC Year */
-	{ 0x7F7F, 0x7F7F, 0x0000 }, /* R20  - Alarm Seconds/Minutes */
-	{ 0x0F3F, 0x0F3F, 0x0000 }, /* R21  - Alarm Hours/Day */
-	{ 0x1F3F, 0x1F3F, 0x0000 }, /* R22  - Alarm Date/Month */
-	{ 0xEF7F, 0xEA7F, 0xFFFF }, /* R23  - RTC Time Control */
-	{ 0x3BFF, 0x0000, 0xFFFF }, /* R24  - System Interrupts */
-	{ 0xFEE7, 0x0000, 0xFFFF }, /* R25  - Interrupt Status 1 */
-	{ 0x35FF, 0x0000, 0xFFFF }, /* R26  - Interrupt Status 2 */
-	{ 0x0F3F, 0x0000, 0xFFFF }, /* R27  - Power Up Interrupt Status */
-	{ 0x0F3F, 0x0000, 0xFFFF }, /* R28  - Under Voltage Interrupt status */
-	{ 0x8000, 0x0000, 0xFFFF }, /* R29  - Over Current Interrupt status */
-	{ 0x1FFF, 0x0000, 0xFFFF }, /* R30  - GPIO Interrupt Status */
-	{ 0xEF7F, 0x0000, 0xFFFF }, /* R31  - Comparator Interrupt Status */
-	{ 0x3FFF, 0x3FFF, 0x0000 }, /* R32  - System Interrupts Mask */
-	{ 0xFEE7, 0xFEE7, 0x0000 }, /* R33  - Interrupt Status 1 Mask */
-	{ 0xF5FF, 0xF5FF, 0x0000 }, /* R34  - Interrupt Status 2 Mask */
-	{ 0x0F3F, 0x0F3F, 0x0000 }, /* R35  - Power Up Interrupt Status Mask */
-	{ 0x0F3F, 0x0F3F, 0x0000 }, /* R36  - Under Voltage Int status Mask */
-	{ 0x8000, 0x8000, 0x0000 }, /* R37  - Over Current Int status Mask */
-	{ 0x1FFF, 0x1FFF, 0x0000 }, /* R38  - GPIO Interrupt Status Mask */
-	{ 0xEF7F, 0xEF7F, 0x0000 }, /* R39  - Comparator IntStatus Mask */
-	{ 0xC9F7, 0xC9F7, 0xFFFF }, /* R40  - Clock Control 1 */
-	{ 0x8001, 0x8001, 0x0000 }, /* R41  - Clock Control 2 */
-	{ 0xFFF7, 0xFFF7, 0xFFFF }, /* R42  - FLL Control 1 */
-	{ 0xFBFF, 0xFBFF, 0x0000 }, /* R43  - FLL Control 2 */
-	{ 0xFFFF, 0xFFFF, 0x0000 }, /* R44  - FLL Control 3 */
-	{ 0x0033, 0x0033, 0x0000 }, /* R45  - FLL Control 4 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R46 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R47 */
-	{ 0x3033, 0x3033, 0x0000 }, /* R48  - DAC Control */
-	{ 0x0000, 0x0000, 0x0000 }, /* R49 */
-	{ 0x81FF, 0x81FF, 0xFFFF }, /* R50  - DAC Digital Volume L */
-	{ 0x81FF, 0x81FF, 0xFFFF }, /* R51  - DAC Digital Volume R */
-	{ 0x0000, 0x0000, 0x0000 }, /* R52 */
-	{ 0x0FFF, 0x0FFF, 0xFFFF }, /* R53  - DAC LR Rate */
-	{ 0x0017, 0x0017, 0x0000 }, /* R54  - DAC Clock Control */
-	{ 0x0000, 0x0000, 0x0000 }, /* R55 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R56 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R57 */
-	{ 0x4000, 0x4000, 0x0000 }, /* R58  - DAC Mute */
-	{ 0x7000, 0x7000, 0x0000 }, /* R59  - DAC Mute Volume */
-	{ 0x3C00, 0x3C00, 0x0000 }, /* R60  - DAC Side */
-	{ 0x0000, 0x0000, 0x0000 }, /* R61 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R62 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R63 */
-	{ 0x8303, 0x8303, 0xFFFF }, /* R64  - ADC Control */
-	{ 0x0000, 0x0000, 0x0000 }, /* R65 */
-	{ 0x81FF, 0x81FF, 0xFFFF }, /* R66  - ADC Digital Volume L */
-	{ 0x81FF, 0x81FF, 0xFFFF }, /* R67  - ADC Digital Volume R */
-	{ 0x0FFF, 0x0FFF, 0x0000 }, /* R68  - ADC Divider */
-	{ 0x0000, 0x0000, 0x0000 }, /* R69 */
-	{ 0x0FFF, 0x0FFF, 0xFFFF }, /* R70  - ADC LR Rate */
-	{ 0x0000, 0x0000, 0x0000 }, /* R71 */
-	{ 0x0707, 0x0707, 0xFFFF }, /* R72  - Input Control */
-	{ 0xC0C0, 0xC0C0, 0xFFFF }, /* R73  - IN3 Input Control */
-	{ 0xC09F, 0xC09F, 0xFFFF }, /* R74  - Mic Bias Control */
-	{ 0x0000, 0x0000, 0x0000 }, /* R75 */
-	{ 0x0F15, 0x0F15, 0xFFFF }, /* R76  - Output Control */
-	{ 0xC000, 0xC000, 0xFFFF }, /* R77  - Jack Detect */
-	{ 0x03FF, 0x03FF, 0x0000 }, /* R78  - Anti Pop Control */
-	{ 0x0000, 0x0000, 0x0000 }, /* R79 */
-	{ 0xE1FC, 0xE1FC, 0x8000 }, /* R80  - Left Input Volume */
-	{ 0xE1FC, 0xE1FC, 0x8000 }, /* R81  - Right Input Volume */
-	{ 0x0000, 0x0000, 0x0000 }, /* R82 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R83 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R84 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R85 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R86 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R87 */
-	{ 0x9807, 0x9807, 0xFFFF }, /* R88  - Left Mixer Control */
-	{ 0x980B, 0x980B, 0xFFFF }, /* R89  - Right Mixer Control */
-	{ 0x0000, 0x0000, 0x0000 }, /* R90 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R91 */
-	{ 0x8909, 0x8909, 0xFFFF }, /* R92  - OUT3 Mixer Control */
-	{ 0x9E07, 0x9E07, 0xFFFF }, /* R93  - OUT4 Mixer Control */
-	{ 0x0000, 0x0000, 0x0000 }, /* R94 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R95 */
-	{ 0x0EEE, 0x0EEE, 0x0000 }, /* R96  - Output Left Mixer Volume */
-	{ 0xE0EE, 0xE0EE, 0x0000 }, /* R97  - Output Right Mixer Volume */
-	{ 0x0E0F, 0x0E0F, 0x0000 }, /* R98  - Input Mixer Volume L */
-	{ 0xE0E1, 0xE0E1, 0x0000 }, /* R99  - Input Mixer Volume R */
-	{ 0x800E, 0x800E, 0x0000 }, /* R100 - Input Mixer Volume */
-	{ 0x0000, 0x0000, 0x0000 }, /* R101 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R102 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R103 */
-	{ 0xE1FC, 0xE1FC, 0xFFFF }, /* R104 - LOUT1 Volume */
-	{ 0xE1FC, 0xE1FC, 0xFFFF }, /* R105 - ROUT1 Volume */
-	{ 0xE1FC, 0xE1FC, 0xFFFF }, /* R106 - LOUT2 Volume */
-	{ 0xE7FC, 0xE7FC, 0xFFFF }, /* R107 - ROUT2 Volume */
-	{ 0x0000, 0x0000, 0x0000 }, /* R108 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R109 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R110 */
-	{ 0x80E0, 0x80E0, 0xFFFF }, /* R111 - BEEP Volume */
-	{ 0xBF00, 0xBF00, 0x0000 }, /* R112 - AI Formating */
-	{ 0x00F1, 0x00F1, 0x0000 }, /* R113 - ADC DAC COMP */
-	{ 0x00F8, 0x00F8, 0x0000 }, /* R114 - AI ADC Control */
-	{ 0x40FB, 0x40FB, 0x0000 }, /* R115 - AI DAC Control */
-	{ 0x7C30, 0x7C30, 0x0000 }, /* R116 - AIF Test */
-	{ 0x0000, 0x0000, 0x0000 }, /* R117 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R118 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R119 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R120 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R121 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R122 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R123 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R124 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R125 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R126 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R127 */
-	{ 0x1FFF, 0x1FFF, 0x0000 }, /* R128 - GPIO Debounce */
-	{ 0x1FFF, 0x1FFF, 0x0000 }, /* R129 - GPIO Pin pull up Control */
-	{ 0x1FFF, 0x1FFF, 0x0000 }, /* R130 - GPIO Pull down Control */
-	{ 0x1FFF, 0x1FFF, 0x0000 }, /* R131 - GPIO Interrupt Mode */
-	{ 0x0000, 0x0000, 0x0000 }, /* R132 */
-	{ 0x00C0, 0x00C0, 0x0000 }, /* R133 - GPIO Control */
-	{ 0x1FFF, 0x1FFF, 0x0000 }, /* R134 - GPIO Configuration (i/o) */
-	{ 0x1FFF, 0x1FFF, 0x0000 }, /* R135 - GPIO Pin Polarity / Type */
-	{ 0x0000, 0x0000, 0x0000 }, /* R136 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R137 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R138 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R139 */
-	{ 0xFFFF, 0xFFFF, 0x0000 }, /* R140 - GPIO Function Select 1 */
-	{ 0xFFFF, 0xFFFF, 0x0000 }, /* R141 - GPIO Function Select 2 */
-	{ 0xFFFF, 0xFFFF, 0x0000 }, /* R142 - GPIO Function Select 3 */
-	{ 0x000F, 0x000F, 0x0000 }, /* R143 - GPIO Function Select 4 */
-	{ 0xF0FF, 0xF0FF, 0xA000 }, /* R144 - Digitiser Control (1) */
-	{ 0x3707, 0x3707, 0x0000 }, /* R145 - Digitiser Control (2) */
-	{ 0x0000, 0x0000, 0x0000 }, /* R146 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R147 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R148 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R149 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R150 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R151 */
-	{ 0x7FFF, 0x7000, 0xFFFF }, /* R152 - AUX1 Readback */
-	{ 0x7FFF, 0x7000, 0xFFFF }, /* R153 - AUX2 Readback */
-	{ 0x7FFF, 0x7000, 0xFFFF }, /* R154 - AUX3 Readback */
-	{ 0x7FFF, 0x7000, 0xFFFF }, /* R155 - AUX4 Readback */
-	{ 0x0FFF, 0x0000, 0xFFFF }, /* R156 - USB Voltage Readback */
-	{ 0x0FFF, 0x0000, 0xFFFF }, /* R157 - LINE Voltage Readback */
-	{ 0x0FFF, 0x0000, 0xFFFF }, /* R158 - BATT Voltage Readback */
-	{ 0x0FFF, 0x0000, 0xFFFF }, /* R159 - Chip Temp Readback */
-	{ 0x0000, 0x0000, 0x0000 }, /* R160 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R161 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R162 */
-	{ 0x000F, 0x000F, 0x0000 }, /* R163 - Generic Comparator Control */
-	{ 0xFFFF, 0xFFFF, 0x0000 }, /* R164 - Generic comparator 1 */
-	{ 0xFFFF, 0xFFFF, 0x0000 }, /* R165 - Generic comparator 2 */
-	{ 0xFFFF, 0xFFFF, 0x0000 }, /* R166 - Generic comparator 3 */
-	{ 0xFFFF, 0xFFFF, 0x0000 }, /* R167 - Generic comparator 4 */
-	{ 0xBFFF, 0xBFFF, 0x8000 }, /* R168 - Battery Charger Control 1 */
-	{ 0xFFFF, 0x4FFF, 0xB000 }, /* R169 - Battery Charger Control 2 */
-	{ 0x007F, 0x007F, 0x0000 }, /* R170 - Battery Charger Control 3 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R171 */
-	{ 0x903F, 0x903F, 0xFFFF }, /* R172 - Current Sink Driver A */
-	{ 0xE333, 0xE333, 0xFFFF }, /* R173 - CSA Flash control */
-	{ 0x903F, 0x903F, 0xFFFF }, /* R174 - Current Sink Driver B */
-	{ 0xE333, 0xE333, 0xFFFF }, /* R175 - CSB Flash control */
-	{ 0x8F3F, 0x8F3F, 0xFFFF }, /* R176 - DCDC/LDO requested */
-	{ 0x332D, 0x332D, 0x0000 }, /* R177 - DCDC Active options */
-	{ 0x002D, 0x002D, 0x0000 }, /* R178 - DCDC Sleep options */
-	{ 0x5177, 0x5177, 0x8000 }, /* R179 - Power-check comparator */
-	{ 0x047F, 0x047F, 0x0000 }, /* R180 - DCDC1 Control */
-	{ 0xFFC0, 0xFFC0, 0x0000 }, /* R181 - DCDC1 Timeouts */
-	{ 0x737F, 0x737F, 0x0000 }, /* R182 - DCDC1 Low Power */
-	{ 0x535B, 0x535B, 0x0000 }, /* R183 - DCDC2 Control */
-	{ 0xFFC0, 0xFFC0, 0x0000 }, /* R184 - DCDC2 Timeouts */
-	{ 0x0000, 0x0000, 0x0000 }, /* R185 */
-	{ 0x047F, 0x047F, 0x0000 }, /* R186 - DCDC3 Control */
-	{ 0xFFC0, 0xFFC0, 0x0000 }, /* R187 - DCDC3 Timeouts */
-	{ 0x737F, 0x737F, 0x0000 }, /* R188 - DCDC3 Low Power */
-	{ 0x047F, 0x047F, 0x0000 }, /* R189 - DCDC4 Control */
-	{ 0xFFC0, 0xFFC0, 0x0000 }, /* R190 - DCDC4 Timeouts */
-	{ 0x737F, 0x737F, 0x0000 }, /* R191 - DCDC4 Low Power */
-	{ 0x535B, 0x535B, 0x0000 }, /* R192 - DCDC5 Control */
-	{ 0xFFC0, 0xFFC0, 0x0000 }, /* R193 - DCDC5 Timeouts */
-	{ 0x0000, 0x0000, 0x0000 }, /* R194 */
-	{ 0x047F, 0x047F, 0x0000 }, /* R195 - DCDC6 Control */
-	{ 0xFFC0, 0xFFC0, 0x0000 }, /* R196 - DCDC6 Timeouts */
-	{ 0x737F, 0x737F, 0x0000 }, /* R197 - DCDC6 Low Power */
-	{ 0x0000, 0x0000, 0x0000 }, /* R198 */
-	{ 0xFFD3, 0xFFD3, 0x0000 }, /* R199 - Limit Switch Control */
-	{ 0x441F, 0x441F, 0x0000 }, /* R200 - LDO1 Control */
-	{ 0xFFC0, 0xFFC0, 0x0000 }, /* R201 - LDO1 Timeouts */
-	{ 0x331F, 0x331F, 0x0000 }, /* R202 - LDO1 Low Power */
-	{ 0x441F, 0x441F, 0x0000 }, /* R203 - LDO2 Control */
-	{ 0xFFC0, 0xFFC0, 0x0000 }, /* R204 - LDO2 Timeouts */
-	{ 0x331F, 0x331F, 0x0000 }, /* R205 - LDO2 Low Power */
-	{ 0x441F, 0x441F, 0x0000 }, /* R206 - LDO3 Control */
-	{ 0xFFC0, 0xFFC0, 0x0000 }, /* R207 - LDO3 Timeouts */
-	{ 0x331F, 0x331F, 0x0000 }, /* R208 - LDO3 Low Power */
-	{ 0x441F, 0x441F, 0x0000 }, /* R209 - LDO4 Control */
-	{ 0xFFC0, 0xFFC0, 0x0000 }, /* R210 - LDO4 Timeouts */
-	{ 0x331F, 0x331F, 0x0000 }, /* R211 - LDO4 Low Power */
-	{ 0x0000, 0x0000, 0x0000 }, /* R212 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R213 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R214 */
-	{ 0x8F3F, 0x8F3F, 0x0000 }, /* R215 - VCC_FAULT Masks */
-	{ 0xFF3F, 0xE03F, 0x0000 }, /* R216 - Main Bandgap Control */
-	{ 0xEF2F, 0xE02F, 0x0000 }, /* R217 - OSC Control */
-	{ 0xF3FF, 0xB3FF, 0xc000 }, /* R218 - RTC Tick Control */
-	{ 0xFFFF, 0xFFFF, 0x0000 }, /* R219 - Security */
-	{ 0x09FF, 0x01FF, 0x0000 }, /* R220 - RAM BIST 1 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R221 */
-	{ 0xFFFF, 0xFFFF, 0xFFFF }, /* R222 */
-	{ 0xFFFF, 0xFFFF, 0xFFFF }, /* R223 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R224 */
-	{ 0x8F3F, 0x0000, 0xFFFF }, /* R225 - DCDC/LDO status */
-	{ 0x0000, 0x0000, 0xFFFF }, /* R226 - Charger status */
-	{ 0x34FE, 0x0000, 0xFFFF }, /* R227 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R228 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R229 */
-	{ 0xFFFF, 0x1FFF, 0xFFFF }, /* R230 - GPIO Pin Status */
-	{ 0xFFFF, 0x1FFF, 0xFFFF }, /* R231 */
-	{ 0xFFFF, 0x1FFF, 0xFFFF }, /* R232 */
-	{ 0xFFFF, 0x1FFF, 0xFFFF }, /* R233 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R234 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R235 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R236 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R237 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R238 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R239 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R240 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R241 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R242 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R243 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R244 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R245 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R246 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R247 */
-	{ 0xFFFF, 0x0010, 0xFFFF }, /* R248 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R249 */
-	{ 0xFFFF, 0x0010, 0xFFFF }, /* R250 */
-	{ 0xFFFF, 0x0010, 0xFFFF }, /* R251 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R252 */
-	{ 0xFFFF, 0x0010, 0xFFFF }, /* R253 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R254 */
-	{ 0x0000, 0x0000, 0x0000 }, /* R255 */
-};
-
-static bool wm8350_readable(struct device *dev, unsigned int reg)
-{
-	return wm8350_reg_io_map[reg].readable;
-}
-
-static bool wm8350_writeable(struct device *dev, unsigned int reg)
-{
-	struct wm8350 *wm8350 = dev_get_drvdata(dev);
-
-	if (!wm8350->unlocked) {
-		if ((reg >= WM8350_GPIO_FUNCTION_SELECT_1 &&
-		     reg <= WM8350_GPIO_FUNCTION_SELECT_4) ||
-		    (reg >= WM8350_BATTERY_CHARGER_CONTROL_1 &&
-		     reg <= WM8350_BATTERY_CHARGER_CONTROL_3))
-			return false;
-	}
-
-	return wm8350_reg_io_map[reg].writable;
-}
-
-static bool wm8350_volatile(struct device *dev, unsigned int reg)
-{
-	return wm8350_reg_io_map[reg].vol;
-}
-
-static bool wm8350_precious(struct device *dev, unsigned int reg)
-{
-	switch (reg) {
-	case WM8350_SYSTEM_INTERRUPTS:
-	case WM8350_INT_STATUS_1:
-	case WM8350_INT_STATUS_2:
-	case WM8350_POWER_UP_INT_STATUS:
-	case WM8350_UNDER_VOLTAGE_INT_STATUS:
-	case WM8350_OVER_CURRENT_INT_STATUS:
-	case WM8350_GPIO_INT_STATUS:
-	case WM8350_COMPARATOR_INT_STATUS:
-		return true;
-
-	default:
-		return false;
-	}
-}
-
-const struct regmap_config wm8350_regmap = {
-	.reg_bits = 8,
-	.val_bits = 16,
-
-	.cache_type = REGCACHE_MAPLE,
-
-	.max_register = WM8350_MAX_REGISTER,
-	.readable_reg = wm8350_readable,
-	.writeable_reg = wm8350_writeable,
-	.volatile_reg = wm8350_volatile,
-	.precious_reg = wm8350_precious,
-};

@@ -74,13 +74,6 @@ config WM831X_POWER
 	  Say Y here to enable support for the power management unit
 	  provided by Wolfson Microelectronics WM831x PMICs.
 
-config WM8350_POWER
-	tristate "WM8350 PMU support"
-	depends on MFD_WM8350
-	help
-	  Say Y here to enable support for the power management unit
-	  provided by the Wolfson Microelectronics WM8350 PMIC.
-
 config TEST_POWER
 	tristate "Test power driver"
 	help

@@ -16,7 +16,6 @@ obj-$(CONFIG_IP5XXX_POWER)	+= ip5xxx_power.o
 obj-$(CONFIG_MAX8925_POWER)	+= max8925_power.o
 obj-$(CONFIG_WM831X_BACKUP)	+= wm831x_backup.o
 obj-$(CONFIG_WM831X_POWER)	+= wm831x_power.o
-obj-$(CONFIG_WM8350_POWER)	+= wm8350_power.o
 obj-$(CONFIG_TEST_POWER)	+= test_power.o
 
 obj-$(CONFIG_BATTERY_88PM860X)	+= 88pm860x_battery.o

@@ -1,590 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-/*
- * Battery driver for wm8350 PMIC
- *
- * Copyright 2007, 2008 Wolfson Microelectronics PLC.
- *
- * Based on OLPC Battery Driver
- *
- * Copyright 2006  David Woodhouse <dwmw2@infradead.org>
- */
-
-#include <linux/module.h>
-#include <linux/err.h>
-#include <linux/platform_device.h>
-#include <linux/power_supply.h>
-#include <linux/mfd/wm8350/supply.h>
-#include <linux/mfd/wm8350/core.h>
-#include <linux/mfd/wm8350/comparator.h>
-
-static int wm8350_read_battery_uvolts(struct wm8350 *wm8350)
-{
-	return wm8350_read_auxadc(wm8350, WM8350_AUXADC_BATT, 0, 0)
-		* WM8350_AUX_COEFF;
-}
-
-static int wm8350_read_line_uvolts(struct wm8350 *wm8350)
-{
-	return wm8350_read_auxadc(wm8350, WM8350_AUXADC_LINE, 0, 0)
-		* WM8350_AUX_COEFF;
-}
-
-static int wm8350_read_usb_uvolts(struct wm8350 *wm8350)
-{
-	return wm8350_read_auxadc(wm8350, WM8350_AUXADC_USB, 0, 0)
-		* WM8350_AUX_COEFF;
-}
-
-#define WM8350_BATT_SUPPLY	1
-#define WM8350_USB_SUPPLY	2
-#define WM8350_LINE_SUPPLY	4
-
-static inline int wm8350_charge_time_min(struct wm8350 *wm8350, int min)
-{
-	if (!wm8350->power.rev_g_coeff)
-		return (((min - 30) / 15) & 0xf) << 8;
-	else
-		return (((min - 30) / 30) & 0xf) << 8;
-}
-
-static int wm8350_get_supplies(struct wm8350 *wm8350)
-{
-	u16 sm, ov, co, chrg;
-	int supplies = 0;
-
-	sm = wm8350_reg_read(wm8350, WM8350_STATE_MACHINE_STATUS);
-	ov = wm8350_reg_read(wm8350, WM8350_MISC_OVERRIDES);
-	co = wm8350_reg_read(wm8350, WM8350_COMPARATOR_OVERRIDES);
-	chrg = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2);
-
-	/* USB_SM */
-	sm = (sm & WM8350_USB_SM_MASK) >> WM8350_USB_SM_SHIFT;
-
-	/* CHG_ISEL */
-	chrg &= WM8350_CHG_ISEL_MASK;
-
-	/* If the USB state machine is active then we're using that with or
-	 * without battery, otherwise check for wall supply */
-	if (((sm == WM8350_USB_SM_100_SLV) ||
-	     (sm == WM8350_USB_SM_500_SLV) ||
-	     (sm == WM8350_USB_SM_STDBY_SLV))
-	    && !(ov & WM8350_USB_LIMIT_OVRDE))
-		supplies = WM8350_USB_SUPPLY;
-	else if (((sm == WM8350_USB_SM_100_SLV) ||
-		  (sm == WM8350_USB_SM_500_SLV) ||
-		  (sm == WM8350_USB_SM_STDBY_SLV))
-		 && (ov & WM8350_USB_LIMIT_OVRDE) && (chrg == 0))
-		supplies = WM8350_USB_SUPPLY | WM8350_BATT_SUPPLY;
-	else if (co & WM8350_WALL_FB_OVRDE)
-		supplies = WM8350_LINE_SUPPLY;
-	else
-		supplies = WM8350_BATT_SUPPLY;
-
-	return supplies;
-}
-
-static int wm8350_charger_config(struct wm8350 *wm8350,
-				 struct wm8350_charger_policy *policy)
-{
-	u16 reg, eoc_mA, fast_limit_mA;
-
-	if (!policy) {
-		dev_warn(wm8350->dev,
-			 "No charger policy, charger not configured.\n");
-		return -EINVAL;
-	}
-
-	/* make sure USB fast charge current is not > 500mA */
-	if (policy->fast_limit_USB_mA > 500) {
-		dev_err(wm8350->dev, "USB fast charge > 500mA\n");
-		return -EINVAL;
-	}
-
-	eoc_mA = WM8350_CHG_EOC_mA(policy->eoc_mA);
-
-	wm8350_reg_unlock(wm8350);
-
-	reg = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1)
-		& WM8350_CHG_ENA_R168;
-	wm8350_reg_write(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1,
-			 reg | eoc_mA | policy->trickle_start_mV |
-			 WM8350_CHG_TRICKLE_TEMP_CHOKE |
-			 WM8350_CHG_TRICKLE_USB_CHOKE |
-			 WM8350_CHG_FAST_USB_THROTTLE);
-
-	if (wm8350_get_supplies(wm8350) & WM8350_USB_SUPPLY) {
-		fast_limit_mA =
-			WM8350_CHG_FAST_LIMIT_mA(policy->fast_limit_USB_mA);
-		wm8350_reg_write(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2,
-			    policy->charge_mV | policy->trickle_charge_USB_mA |
-			    fast_limit_mA | wm8350_charge_time_min(wm8350,
-						policy->charge_timeout));
-
-	} else {
-		fast_limit_mA =
-			WM8350_CHG_FAST_LIMIT_mA(policy->fast_limit_mA);
-		wm8350_reg_write(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2,
-			    policy->charge_mV | policy->trickle_charge_mA |
-			    fast_limit_mA | wm8350_charge_time_min(wm8350,
-						policy->charge_timeout));
-	}
-
-	wm8350_reg_lock(wm8350);
-	return 0;
-}
-
-static int wm8350_batt_status(struct wm8350 *wm8350)
-{
-	u16 state;
-
-	state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2);
-	state &= WM8350_CHG_STS_MASK;
-
-	switch (state) {
-	case WM8350_CHG_STS_OFF:
-		return POWER_SUPPLY_STATUS_DISCHARGING;
-
-	case WM8350_CHG_STS_TRICKLE:
-	case WM8350_CHG_STS_FAST:
-		return POWER_SUPPLY_STATUS_CHARGING;
-
-	default:
-		return POWER_SUPPLY_STATUS_UNKNOWN;
-	}
-}
-
-static ssize_t charger_state_show(struct device *dev,
-				 struct device_attribute *attr, char *buf)
-{
-	struct wm8350 *wm8350 = dev_get_drvdata(dev);
-	char *charge;
-	int state;
-
-	state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2) &
-	    WM8350_CHG_STS_MASK;
-	switch (state) {
-	case WM8350_CHG_STS_OFF:
-		charge = "Charger Off";
-		break;
-	case WM8350_CHG_STS_TRICKLE:
-		charge = "Trickle Charging";
-		break;
-	case WM8350_CHG_STS_FAST:
-		charge = "Fast Charging";
-		break;
-	default:
-		return 0;
-	}
-
-	return sysfs_emit(buf, "%s\n", charge);
-}
-
-static DEVICE_ATTR_RO(charger_state);
-
-static irqreturn_t wm8350_charger_handler(int irq, void *data)
-{
-	struct wm8350 *wm8350 = data;
-	struct wm8350_power *power = &wm8350->power;
-	struct wm8350_charger_policy *policy = power->policy;
-
-	switch (irq - wm8350->irq_base) {
-	case WM8350_IRQ_CHG_BAT_FAIL:
-		dev_err(wm8350->dev, "battery failed\n");
-		break;
-	case WM8350_IRQ_CHG_TO:
-		dev_err(wm8350->dev, "charger timeout\n");
-		power_supply_changed(power->battery);
-		break;
-
-	case WM8350_IRQ_CHG_BAT_HOT:
-	case WM8350_IRQ_CHG_BAT_COLD:
-	case WM8350_IRQ_CHG_START:
-	case WM8350_IRQ_CHG_END:
-		power_supply_changed(power->battery);
-		break;
-
-	case WM8350_IRQ_CHG_FAST_RDY:
-		dev_dbg(wm8350->dev, "fast charger ready\n");
-		wm8350_charger_config(wm8350, policy);
-		wm8350_reg_unlock(wm8350);
-		wm8350_set_bits(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1,
-				WM8350_CHG_FAST);
-		wm8350_reg_lock(wm8350);
-		break;
-
-	case WM8350_IRQ_CHG_VBATT_LT_3P9:
-		dev_warn(wm8350->dev, "battery < 3.9V\n");
-		break;
-	case WM8350_IRQ_CHG_VBATT_LT_3P1:
-		dev_warn(wm8350->dev, "battery < 3.1V\n");
-		break;
-	case WM8350_IRQ_CHG_VBATT_LT_2P85:
-		dev_warn(wm8350->dev, "battery < 2.85V\n");
-		break;
-
-		/* Supply change.  We will overnotify but it should do
-		 * no harm. */
-	case WM8350_IRQ_EXT_USB_FB:
-	case WM8350_IRQ_EXT_WALL_FB:
-		wm8350_charger_config(wm8350, policy);
-		fallthrough;
-	case WM8350_IRQ_EXT_BAT_FB:
-		power_supply_changed(power->battery);
-		power_supply_changed(power->usb);
-		power_supply_changed(power->ac);
-		break;
-
-	default:
-		dev_err(wm8350->dev, "Unknown interrupt %d\n", irq);
-	}
-
-	return IRQ_HANDLED;
-}
-
-/*********************************************************************
- *		AC Power
- *********************************************************************/
-static int wm8350_ac_get_prop(struct power_supply *psy,
-			      enum power_supply_property psp,
-			      union power_supply_propval *val)
-{
-	struct wm8350 *wm8350 = dev_get_drvdata(psy->dev.parent);
-	int ret = 0;
-
-	switch (psp) {
-	case POWER_SUPPLY_PROP_ONLINE:
-		val->intval = !!(wm8350_get_supplies(wm8350) &
-				 WM8350_LINE_SUPPLY);
-		break;
-	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
-		val->intval = wm8350_read_line_uvolts(wm8350);
-		break;
-	default:
-		ret = -EINVAL;
-		break;
-	}
-	return ret;
-}
-
-static enum power_supply_property wm8350_ac_props[] = {
-	POWER_SUPPLY_PROP_ONLINE,
-	POWER_SUPPLY_PROP_VOLTAGE_NOW,
-};
-
-/*********************************************************************
- *		USB Power
- *********************************************************************/
-static int wm8350_usb_get_prop(struct power_supply *psy,
-			       enum power_supply_property psp,
-			       union power_supply_propval *val)
-{
-	struct wm8350 *wm8350 = dev_get_drvdata(psy->dev.parent);
-	int ret = 0;
-
-	switch (psp) {
-	case POWER_SUPPLY_PROP_ONLINE:
-		val->intval = !!(wm8350_get_supplies(wm8350) &
-				 WM8350_USB_SUPPLY);
-		break;
-	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
-		val->intval = wm8350_read_usb_uvolts(wm8350);
-		break;
-	default:
-		ret = -EINVAL;
-		break;
-	}
-	return ret;
-}
-
-static enum power_supply_property wm8350_usb_props[] = {
-	POWER_SUPPLY_PROP_ONLINE,
-	POWER_SUPPLY_PROP_VOLTAGE_NOW,
-};
-
-/*********************************************************************
- *		Battery properties
- *********************************************************************/
-
-static int wm8350_bat_check_health(struct wm8350 *wm8350)
-{
-	u16 reg;
-
-	if (wm8350_read_battery_uvolts(wm8350) < 2850000)
-		return POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
-
-	reg = wm8350_reg_read(wm8350, WM8350_CHARGER_OVERRIDES);
-	if (reg & WM8350_CHG_BATT_HOT_OVRDE)
-		return POWER_SUPPLY_HEALTH_OVERHEAT;
-
-	if (reg & WM8350_CHG_BATT_COLD_OVRDE)
-		return POWER_SUPPLY_HEALTH_COLD;
-
-	return POWER_SUPPLY_HEALTH_GOOD;
-}
-
-static int wm8350_bat_get_charge_type(struct wm8350 *wm8350)
-{
-	int state;
-
-	state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2) &
-	    WM8350_CHG_STS_MASK;
-	switch (state) {
-	case WM8350_CHG_STS_OFF:
-		return POWER_SUPPLY_CHARGE_TYPE_NONE;
-	case WM8350_CHG_STS_TRICKLE:
-		return POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
-	case WM8350_CHG_STS_FAST:
-		return POWER_SUPPLY_CHARGE_TYPE_FAST;
-	default:
-		return POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
-	}
-}
-
-static int wm8350_bat_get_property(struct power_supply *psy,
-				   enum power_supply_property psp,
-				   union power_supply_propval *val)
-{
-	struct wm8350 *wm8350 = dev_get_drvdata(psy->dev.parent);
-	int ret = 0;
-
-	switch (psp) {
-	case POWER_SUPPLY_PROP_STATUS:
-		val->intval = wm8350_batt_status(wm8350);
-		break;
-	case POWER_SUPPLY_PROP_ONLINE:
-		val->intval = !!(wm8350_get_supplies(wm8350) &
-				 WM8350_BATT_SUPPLY);
-		break;
-	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
-		val->intval = wm8350_read_battery_uvolts(wm8350);
-		break;
-	case POWER_SUPPLY_PROP_HEALTH:
-		val->intval = wm8350_bat_check_health(wm8350);
-		break;
-	case POWER_SUPPLY_PROP_CHARGE_TYPE:
-		val->intval = wm8350_bat_get_charge_type(wm8350);
-		break;
-	default:
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
-static enum power_supply_property wm8350_bat_props[] = {
-	POWER_SUPPLY_PROP_STATUS,
-	POWER_SUPPLY_PROP_ONLINE,
-	POWER_SUPPLY_PROP_VOLTAGE_NOW,
-	POWER_SUPPLY_PROP_HEALTH,
-	POWER_SUPPLY_PROP_CHARGE_TYPE,
-};
-
-static const struct power_supply_desc wm8350_ac_desc = {
-	.name		= "wm8350-ac",
-	.type		= POWER_SUPPLY_TYPE_MAINS,
-	.properties	= wm8350_ac_props,
-	.num_properties	= ARRAY_SIZE(wm8350_ac_props),
-	.get_property	= wm8350_ac_get_prop,
-};
-
-static const struct power_supply_desc wm8350_battery_desc = {
-	.name		= "wm8350-battery",
-	.properties	= wm8350_bat_props,
-	.num_properties	= ARRAY_SIZE(wm8350_bat_props),
-	.get_property	= wm8350_bat_get_property,
-	.use_for_apm	= 1,
-};
-
-static const struct power_supply_desc wm8350_usb_desc = {
-	.name		= "wm8350-usb",
-	.type		= POWER_SUPPLY_TYPE_USB,
-	.properties	= wm8350_usb_props,
-	.num_properties	= ARRAY_SIZE(wm8350_usb_props),
-	.get_property	= wm8350_usb_get_prop,
-};
-
-/*********************************************************************
- *		Initialisation
- *********************************************************************/
-
-static int wm8350_init_charger(struct wm8350 *wm8350)
-{
-	int ret;
-
-	/* register our interest in charger events */
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT,
-			    wm8350_charger_handler, 0, "Battery hot", wm8350);
-	if (ret)
-		goto err;
-
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD,
-			    wm8350_charger_handler, 0, "Battery cold", wm8350);
-	if (ret)
-		goto free_chg_bat_hot;
-
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL,
-			    wm8350_charger_handler, 0, "Battery fail", wm8350);
-	if (ret)
-		goto free_chg_bat_cold;
-
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_CHG_TO,
-			    wm8350_charger_handler, 0,
-			    "Charger timeout", wm8350);
-	if (ret)
-		goto free_chg_bat_fail;
-
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_CHG_END,
-			    wm8350_charger_handler, 0,
-			    "Charge end", wm8350);
-	if (ret)
-		goto free_chg_to;
-
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_CHG_START,
-			    wm8350_charger_handler, 0,
-			    "Charge start", wm8350);
-	if (ret)
-		goto free_chg_end;
-
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY,
-			    wm8350_charger_handler, 0,
-			    "Fast charge ready", wm8350);
-	if (ret)
-		goto free_chg_start;
-
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9,
-			    wm8350_charger_handler, 0,
-			    "Battery <3.9V", wm8350);
-	if (ret)
-		goto free_chg_fast_rdy;
-
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1,
-			    wm8350_charger_handler, 0,
-			    "Battery <3.1V", wm8350);
-	if (ret)
-		goto free_chg_vbatt_lt_3p9;
-
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85,
-			    wm8350_charger_handler, 0,
-			    "Battery <2.85V", wm8350);
-	if (ret)
-		goto free_chg_vbatt_lt_3p1;
-
-	/* and supply change events */
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_EXT_USB_FB,
-			    wm8350_charger_handler, 0, "USB", wm8350);
-	if (ret)
-		goto free_chg_vbatt_lt_2p85;
-
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_EXT_WALL_FB,
-			    wm8350_charger_handler, 0, "Wall", wm8350);
-	if (ret)
-		goto free_ext_usb_fb;
-
-	ret = wm8350_register_irq(wm8350, WM8350_IRQ_EXT_BAT_FB,
-			    wm8350_charger_handler, 0, "Battery", wm8350);
-	if (ret)
-		goto free_ext_wall_fb;
-
-	return 0;
-
-free_ext_wall_fb:
-	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_WALL_FB, wm8350);
-free_ext_usb_fb:
-	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_USB_FB, wm8350);
-free_chg_vbatt_lt_2p85:
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85, wm8350);
-free_chg_vbatt_lt_3p1:
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1, wm8350);
-free_chg_vbatt_lt_3p9:
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9, wm8350);
-free_chg_fast_rdy:
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY, wm8350);
-free_chg_start:
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_START, wm8350);
-free_chg_end:
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_END, wm8350);
-free_chg_to:
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_TO, wm8350);
-free_chg_bat_fail:
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL, wm8350);
-free_chg_bat_cold:
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD, wm8350);
-free_chg_bat_hot:
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT, wm8350);
-err:
-	return ret;
-}
-
-static void free_charger_irq(struct wm8350 *wm8350)
-{
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT, wm8350);
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD, wm8350);
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL, wm8350);
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_TO, wm8350);
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_END, wm8350);
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_START, wm8350);
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY, wm8350);
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9, wm8350);
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1, wm8350);
-	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85, wm8350);
-	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_USB_FB, wm8350);
-	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_WALL_FB, wm8350);
-	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_BAT_FB, wm8350);
-}
-
-static int wm8350_power_probe(struct platform_device *pdev)
-{
-	struct wm8350 *wm8350 = platform_get_drvdata(pdev);
-	struct wm8350_power *power = &wm8350->power;
-	struct wm8350_charger_policy *policy = power->policy;
-	int ret;
-
-	power->ac = devm_power_supply_register(&pdev->dev, &wm8350_ac_desc, NULL);
-	if (IS_ERR(power->ac))
-		return PTR_ERR(power->ac);
-
-	power->battery = devm_power_supply_register(&pdev->dev, &wm8350_battery_desc, NULL);
-	if (IS_ERR(power->battery))
-		return PTR_ERR(power->battery);
-
-	power->usb = devm_power_supply_register(&pdev->dev, &wm8350_usb_desc, NULL);
-	if (IS_ERR(power->usb))
-		return PTR_ERR(power->usb);
-
-	ret = device_create_file(&pdev->dev, &dev_attr_charger_state);
-	if (ret < 0)
-		dev_warn(wm8350->dev, "failed to add charge sysfs: %d\n", ret);
-	ret = 0;
-
-	wm8350_init_charger(wm8350);
-	if (wm8350_charger_config(wm8350, policy) == 0) {
-		wm8350_reg_unlock(wm8350);
-		wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CHG_ENA);
-		wm8350_reg_lock(wm8350);
-	}
-
-	return ret;
-}
-
-static void wm8350_power_remove(struct platform_device *pdev)
-{
-	struct wm8350 *wm8350 = platform_get_drvdata(pdev);
-
-	free_charger_irq(wm8350);
-	device_remove_file(&pdev->dev, &dev_attr_charger_state);
-}
-
-static struct platform_driver wm8350_power_driver = {
-	.probe = wm8350_power_probe,
-	.remove = wm8350_power_remove,
-	.driver = {
-		.name = "wm8350-power",
-	},
-};
-
-module_platform_driver(wm8350_power_driver);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Power supply driver for WM8350");
-MODULE_ALIAS("platform:wm8350-power");

@@ -1824,13 +1824,6 @@ config REGULATOR_WM831X
 	  Support the voltage and current regulators of the WM831x series
 	  of PMIC devices.
 
-config REGULATOR_WM8350
-	tristate "Wolfson Microelectronics WM8350 AudioPlus PMIC"
-	depends on MFD_WM8350
-	help
-	  This driver provides support for the voltage and current regulators
-	  of the WM8350 AudioPlus PMIC.
-
 config REGULATOR_WM8994
 	tristate "Wolfson Microelectronics WM8994 CODEC"
 	depends on MFD_WM8994

@@ -209,7 +209,6 @@ obj-$(CONFIG_REGULATOR_VQMMC_IPQ4019) += vqmmc-ipq4019-regulator.o
 obj-$(CONFIG_REGULATOR_WM831X) += wm831x-dcdc.o
 obj-$(CONFIG_REGULATOR_WM831X) += wm831x-isink.o
 obj-$(CONFIG_REGULATOR_WM831X) += wm831x-ldo.o
-obj-$(CONFIG_REGULATOR_WM8350) += wm8350-regulator.o
 obj-$(CONFIG_REGULATOR_WM8994) += wm8994-regulator.o
 
 ccflags-$(CONFIG_REGULATOR_DEBUG) += -DDEBUG

@@ -1,1330 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0+
-//
-// wm8350.c  --  Voltage and current regulation for the Wolfson WM8350 PMIC
-//
-// Copyright 2007, 2008 Wolfson Microelectronics PLC.
-//
-// Author: Liam Girdwood
-//         linux@wolfsonmicro.com
-
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/init.h>
-#include <linux/bitops.h>
-#include <linux/err.h>
-#include <linux/i2c.h>
-#include <linux/mfd/wm8350/core.h>
-#include <linux/mfd/wm8350/pmic.h>
-#include <linux/platform_device.h>
-#include <linux/regulator/driver.h>
-#include <linux/regulator/machine.h>
-
-/* Maximum value possible for VSEL */
-#define WM8350_DCDC_MAX_VSEL 0x66
-
-/* Microamps */
-static const unsigned int isink_cur[] = {
-	4,
-	5,
-	6,
-	7,
-	8,
-	10,
-	11,
-	14,
-	16,
-	19,
-	23,
-	27,
-	32,
-	39,
-	46,
-	54,
-	65,
-	77,
-	92,
-	109,
-	130,
-	154,
-	183,
-	218,
-	259,
-	308,
-	367,
-	436,
-	518,
-	616,
-	733,
-	872,
-	1037,
-	1233,
-	1466,
-	1744,
-	2073,
-	2466,
-	2933,
-	3487,
-	4147,
-	4932,
-	5865,
-	6975,
-	8294,
-	9864,
-	11730,
-	13949,
-	16589,
-	19728,
-	23460,
-	27899,
-	33178,
-	39455,
-	46920,
-	55798,
-	66355,
-	78910,
-	93840,
-	111596,
-	132710,
-	157820,
-	187681,
-	223191
-};
-
-/* turn on ISINK followed by DCDC */
-static int wm8350_isink_enable(struct regulator_dev *rdev)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int isink = rdev_get_id(rdev);
-
-	switch (isink) {
-	case WM8350_ISINK_A:
-		switch (wm8350->pmic.isink_A_dcdc) {
-		case WM8350_DCDC_2:
-		case WM8350_DCDC_5:
-			wm8350_set_bits(wm8350, WM8350_POWER_MGMT_7,
-					WM8350_CS1_ENA);
-			wm8350_set_bits(wm8350, WM8350_CSA_FLASH_CONTROL,
-					WM8350_CS1_DRIVE);
-			wm8350_set_bits(wm8350, WM8350_DCDC_LDO_REQUESTED,
-					1 << (wm8350->pmic.isink_A_dcdc -
-					      WM8350_DCDC_1));
-			break;
-		default:
-			return -EINVAL;
-		}
-		break;
-	case WM8350_ISINK_B:
-		switch (wm8350->pmic.isink_B_dcdc) {
-		case WM8350_DCDC_2:
-		case WM8350_DCDC_5:
-			wm8350_set_bits(wm8350, WM8350_POWER_MGMT_7,
-					WM8350_CS2_ENA);
-			wm8350_set_bits(wm8350, WM8350_CSB_FLASH_CONTROL,
-					WM8350_CS2_DRIVE);
-			wm8350_set_bits(wm8350, WM8350_DCDC_LDO_REQUESTED,
-					1 << (wm8350->pmic.isink_B_dcdc -
-					      WM8350_DCDC_1));
-			break;
-		default:
-			return -EINVAL;
-		}
-		break;
-	default:
-		return -EINVAL;
-	}
-	return 0;
-}
-
-static int wm8350_isink_disable(struct regulator_dev *rdev)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int isink = rdev_get_id(rdev);
-
-	switch (isink) {
-	case WM8350_ISINK_A:
-		switch (wm8350->pmic.isink_A_dcdc) {
-		case WM8350_DCDC_2:
-		case WM8350_DCDC_5:
-			wm8350_clear_bits(wm8350, WM8350_DCDC_LDO_REQUESTED,
-					  1 << (wm8350->pmic.isink_A_dcdc -
-						WM8350_DCDC_1));
-			wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_7,
-					  WM8350_CS1_ENA);
-			break;
-		default:
-			return -EINVAL;
-		}
-		break;
-	case WM8350_ISINK_B:
-		switch (wm8350->pmic.isink_B_dcdc) {
-		case WM8350_DCDC_2:
-		case WM8350_DCDC_5:
-			wm8350_clear_bits(wm8350, WM8350_DCDC_LDO_REQUESTED,
-					  1 << (wm8350->pmic.isink_B_dcdc -
-						WM8350_DCDC_1));
-			wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_7,
-					  WM8350_CS2_ENA);
-			break;
-		default:
-			return -EINVAL;
-		}
-		break;
-	default:
-		return -EINVAL;
-	}
-	return 0;
-}
-
-static int wm8350_isink_is_enabled(struct regulator_dev *rdev)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int isink = rdev_get_id(rdev);
-
-	switch (isink) {
-	case WM8350_ISINK_A:
-		return wm8350_reg_read(wm8350, WM8350_CURRENT_SINK_DRIVER_A) &
-		    0x8000;
-	case WM8350_ISINK_B:
-		return wm8350_reg_read(wm8350, WM8350_CURRENT_SINK_DRIVER_B) &
-		    0x8000;
-	}
-	return -EINVAL;
-}
-
-static int wm8350_isink_enable_time(struct regulator_dev *rdev)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int isink = rdev_get_id(rdev);
-	int reg;
-
-	switch (isink) {
-	case WM8350_ISINK_A:
-		reg = wm8350_reg_read(wm8350, WM8350_CSA_FLASH_CONTROL);
-		break;
-	case WM8350_ISINK_B:
-		reg = wm8350_reg_read(wm8350, WM8350_CSB_FLASH_CONTROL);
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	if (reg & WM8350_CS1_FLASH_MODE) {
-		switch (reg & WM8350_CS1_ON_RAMP_MASK) {
-		case 0:
-			return 0;
-		case 1:
-			return 1950;
-		case 2:
-			return 3910;
-		case 3:
-			return 7800;
-		}
-	} else {
-		switch (reg & WM8350_CS1_ON_RAMP_MASK) {
-		case 0:
-			return 0;
-		case 1:
-			return 250000;
-		case 2:
-			return 500000;
-		case 3:
-			return 1000000;
-		}
-	}
-
-	return -EINVAL;
-}
-
-
-int wm8350_isink_set_flash(struct wm8350 *wm8350, int isink, u16 mode,
-			   u16 trigger, u16 duration, u16 on_ramp, u16 off_ramp,
-			   u16 drive)
-{
-	switch (isink) {
-	case WM8350_ISINK_A:
-		wm8350_reg_write(wm8350, WM8350_CSA_FLASH_CONTROL,
-				 (mode ? WM8350_CS1_FLASH_MODE : 0) |
-				 (trigger ? WM8350_CS1_TRIGSRC : 0) |
-				 duration | on_ramp | off_ramp | drive);
-		break;
-	case WM8350_ISINK_B:
-		wm8350_reg_write(wm8350, WM8350_CSB_FLASH_CONTROL,
-				 (mode ? WM8350_CS2_FLASH_MODE : 0) |
-				 (trigger ? WM8350_CS2_TRIGSRC : 0) |
-				 duration | on_ramp | off_ramp | drive);
-		break;
-	default:
-		return -EINVAL;
-	}
-	return 0;
-}
-EXPORT_SYMBOL_GPL(wm8350_isink_set_flash);
-
-static int wm8350_dcdc_set_suspend_voltage(struct regulator_dev *rdev, int uV)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int sel, volt_reg, dcdc = rdev_get_id(rdev);
-	u16 val;
-
-	dev_dbg(wm8350->dev, "%s %d mV %d\n", __func__, dcdc, uV / 1000);
-
-	switch (dcdc) {
-	case WM8350_DCDC_1:
-		volt_reg = WM8350_DCDC1_LOW_POWER;
-		break;
-	case WM8350_DCDC_3:
-		volt_reg = WM8350_DCDC3_LOW_POWER;
-		break;
-	case WM8350_DCDC_4:
-		volt_reg = WM8350_DCDC4_LOW_POWER;
-		break;
-	case WM8350_DCDC_6:
-		volt_reg = WM8350_DCDC6_LOW_POWER;
-		break;
-	case WM8350_DCDC_2:
-	case WM8350_DCDC_5:
-	default:
-		return -EINVAL;
-	}
-
-	sel = regulator_map_voltage_linear(rdev, uV, uV);
-	if (sel < 0)
-		return sel;
-
-	/* all DCDCs have same mV bits */
-	val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_DC1_VSEL_MASK;
-	wm8350_reg_write(wm8350, volt_reg, val | sel);
-	return 0;
-}
-
-static int wm8350_dcdc_set_suspend_enable(struct regulator_dev *rdev)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int dcdc = rdev_get_id(rdev);
-	u16 val;
-
-	switch (dcdc) {
-	case WM8350_DCDC_1:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC1_LOW_POWER)
-			& ~WM8350_DCDC_HIB_MODE_MASK;
-		wm8350_reg_write(wm8350, WM8350_DCDC1_LOW_POWER,
-			val | wm8350->pmic.dcdc1_hib_mode);
-		break;
-	case WM8350_DCDC_3:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC3_LOW_POWER)
-			& ~WM8350_DCDC_HIB_MODE_MASK;
-		wm8350_reg_write(wm8350, WM8350_DCDC3_LOW_POWER,
-			val | wm8350->pmic.dcdc3_hib_mode);
-		break;
-	case WM8350_DCDC_4:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC4_LOW_POWER)
-			& ~WM8350_DCDC_HIB_MODE_MASK;
-		wm8350_reg_write(wm8350, WM8350_DCDC4_LOW_POWER,
-			val | wm8350->pmic.dcdc4_hib_mode);
-		break;
-	case WM8350_DCDC_6:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC6_LOW_POWER)
-			& ~WM8350_DCDC_HIB_MODE_MASK;
-		wm8350_reg_write(wm8350, WM8350_DCDC6_LOW_POWER,
-			val | wm8350->pmic.dcdc6_hib_mode);
-		break;
-	case WM8350_DCDC_2:
-	case WM8350_DCDC_5:
-	default:
-		return -EINVAL;
-	}
-
-	return 0;
-}
-
-static int wm8350_dcdc_set_suspend_disable(struct regulator_dev *rdev)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int dcdc = rdev_get_id(rdev);
-	u16 val;
-
-	switch (dcdc) {
-	case WM8350_DCDC_1:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC1_LOW_POWER);
-		wm8350->pmic.dcdc1_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
-		wm8350_reg_write(wm8350, WM8350_DCDC1_LOW_POWER,
-				 val | WM8350_DCDC_HIB_MODE_DIS);
-		break;
-	case WM8350_DCDC_3:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC3_LOW_POWER);
-		wm8350->pmic.dcdc3_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
-		wm8350_reg_write(wm8350, WM8350_DCDC3_LOW_POWER,
-				 val | WM8350_DCDC_HIB_MODE_DIS);
-		break;
-	case WM8350_DCDC_4:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC4_LOW_POWER);
-		wm8350->pmic.dcdc4_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
-		wm8350_reg_write(wm8350, WM8350_DCDC4_LOW_POWER,
-				 val | WM8350_DCDC_HIB_MODE_DIS);
-		break;
-	case WM8350_DCDC_6:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC6_LOW_POWER);
-		wm8350->pmic.dcdc6_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
-		wm8350_reg_write(wm8350, WM8350_DCDC6_LOW_POWER,
-				 val | WM8350_DCDC_HIB_MODE_DIS);
-		break;
-	case WM8350_DCDC_2:
-	case WM8350_DCDC_5:
-	default:
-		return -EINVAL;
-	}
-
-	return 0;
-}
-
-static int wm8350_dcdc25_set_suspend_enable(struct regulator_dev *rdev)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int dcdc = rdev_get_id(rdev);
-	u16 val;
-
-	switch (dcdc) {
-	case WM8350_DCDC_2:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC2_CONTROL)
-		    & ~WM8350_DC2_HIB_MODE_MASK;
-		wm8350_reg_write(wm8350, WM8350_DCDC2_CONTROL, val |
-		    (WM8350_DC2_HIB_MODE_ACTIVE << WM8350_DC2_HIB_MODE_SHIFT));
-		break;
-	case WM8350_DCDC_5:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC5_CONTROL)
-		    & ~WM8350_DC5_HIB_MODE_MASK;
-		wm8350_reg_write(wm8350, WM8350_DCDC5_CONTROL, val |
-		    (WM8350_DC5_HIB_MODE_ACTIVE << WM8350_DC5_HIB_MODE_SHIFT));
-		break;
-	default:
-		return -EINVAL;
-	}
-	return 0;
-}
-
-static int wm8350_dcdc25_set_suspend_disable(struct regulator_dev *rdev)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int dcdc = rdev_get_id(rdev);
-	u16 val;
-
-	switch (dcdc) {
-	case WM8350_DCDC_2:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC2_CONTROL)
-		    & ~WM8350_DC2_HIB_MODE_MASK;
-		wm8350_reg_write(wm8350, WM8350_DCDC2_CONTROL, val |
-		    (WM8350_DC2_HIB_MODE_DISABLE << WM8350_DC2_HIB_MODE_SHIFT));
-		break;
-	case WM8350_DCDC_5:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC5_CONTROL)
-		    & ~WM8350_DC5_HIB_MODE_MASK;
-		wm8350_reg_write(wm8350, WM8350_DCDC5_CONTROL, val |
-		    (WM8350_DC5_HIB_MODE_DISABLE << WM8350_DC5_HIB_MODE_SHIFT));
-		break;
-	default:
-		return -EINVAL;
-	}
-	return 0;
-}
-
-static int wm8350_dcdc_set_suspend_mode(struct regulator_dev *rdev,
-	unsigned int mode)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int dcdc = rdev_get_id(rdev);
-	u16 *hib_mode;
-
-	switch (dcdc) {
-	case WM8350_DCDC_1:
-		hib_mode = &wm8350->pmic.dcdc1_hib_mode;
-		break;
-	case WM8350_DCDC_3:
-		hib_mode = &wm8350->pmic.dcdc3_hib_mode;
-		break;
-	case WM8350_DCDC_4:
-		hib_mode = &wm8350->pmic.dcdc4_hib_mode;
-		break;
-	case WM8350_DCDC_6:
-		hib_mode = &wm8350->pmic.dcdc6_hib_mode;
-		break;
-	case WM8350_DCDC_2:
-	case WM8350_DCDC_5:
-	default:
-		return -EINVAL;
-	}
-
-	switch (mode) {
-	case REGULATOR_MODE_NORMAL:
-		*hib_mode = WM8350_DCDC_HIB_MODE_IMAGE;
-		break;
-	case REGULATOR_MODE_IDLE:
-		*hib_mode = WM8350_DCDC_HIB_MODE_STANDBY;
-		break;
-	case REGULATOR_MODE_STANDBY:
-		*hib_mode = WM8350_DCDC_HIB_MODE_LDO_IM;
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	return 0;
-}
-
-static const struct linear_range wm8350_ldo_ranges[] = {
-	REGULATOR_LINEAR_RANGE(900000, 0, 15, 50000),
-	REGULATOR_LINEAR_RANGE(1800000, 16, 31, 100000),
-};
-
-static int wm8350_ldo_set_suspend_voltage(struct regulator_dev *rdev, int uV)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int sel, volt_reg, ldo = rdev_get_id(rdev);
-	u16 val;
-
-	dev_dbg(wm8350->dev, "%s %d mV %d\n", __func__, ldo, uV / 1000);
-
-	switch (ldo) {
-	case WM8350_LDO_1:
-		volt_reg = WM8350_LDO1_LOW_POWER;
-		break;
-	case WM8350_LDO_2:
-		volt_reg = WM8350_LDO2_LOW_POWER;
-		break;
-	case WM8350_LDO_3:
-		volt_reg = WM8350_LDO3_LOW_POWER;
-		break;
-	case WM8350_LDO_4:
-		volt_reg = WM8350_LDO4_LOW_POWER;
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	sel = regulator_map_voltage_linear_range(rdev, uV, uV);
-	if (sel < 0)
-		return sel;
-
-	/* all LDOs have same mV bits */
-	val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_LDO1_VSEL_MASK;
-	wm8350_reg_write(wm8350, volt_reg, val | sel);
-	return 0;
-}
-
-static int wm8350_ldo_set_suspend_enable(struct regulator_dev *rdev)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int volt_reg, ldo = rdev_get_id(rdev);
-	u16 val;
-
-	switch (ldo) {
-	case WM8350_LDO_1:
-		volt_reg = WM8350_LDO1_LOW_POWER;
-		break;
-	case WM8350_LDO_2:
-		volt_reg = WM8350_LDO2_LOW_POWER;
-		break;
-	case WM8350_LDO_3:
-		volt_reg = WM8350_LDO3_LOW_POWER;
-		break;
-	case WM8350_LDO_4:
-		volt_reg = WM8350_LDO4_LOW_POWER;
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	/* all LDOs have same mV bits */
-	val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_LDO1_HIB_MODE_MASK;
-	wm8350_reg_write(wm8350, volt_reg, val);
-	return 0;
-}
-
-static int wm8350_ldo_set_suspend_disable(struct regulator_dev *rdev)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int volt_reg, ldo = rdev_get_id(rdev);
-	u16 val;
-
-	switch (ldo) {
-	case WM8350_LDO_1:
-		volt_reg = WM8350_LDO1_LOW_POWER;
-		break;
-	case WM8350_LDO_2:
-		volt_reg = WM8350_LDO2_LOW_POWER;
-		break;
-	case WM8350_LDO_3:
-		volt_reg = WM8350_LDO3_LOW_POWER;
-		break;
-	case WM8350_LDO_4:
-		volt_reg = WM8350_LDO4_LOW_POWER;
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	/* all LDOs have same mV bits */
-	val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_LDO1_HIB_MODE_MASK;
-	wm8350_reg_write(wm8350, volt_reg, val | WM8350_LDO1_HIB_MODE_DIS);
-	return 0;
-}
-
-int wm8350_dcdc_set_slot(struct wm8350 *wm8350, int dcdc, u16 start,
-			 u16 stop, u16 fault)
-{
-	int slot_reg;
-	u16 val;
-
-	dev_dbg(wm8350->dev, "%s %d start %d stop %d\n",
-		__func__, dcdc, start, stop);
-
-	/* slot valid ? */
-	if (start > 15 || stop > 15)
-		return -EINVAL;
-
-	switch (dcdc) {
-	case WM8350_DCDC_1:
-		slot_reg = WM8350_DCDC1_TIMEOUTS;
-		break;
-	case WM8350_DCDC_2:
-		slot_reg = WM8350_DCDC2_TIMEOUTS;
-		break;
-	case WM8350_DCDC_3:
-		slot_reg = WM8350_DCDC3_TIMEOUTS;
-		break;
-	case WM8350_DCDC_4:
-		slot_reg = WM8350_DCDC4_TIMEOUTS;
-		break;
-	case WM8350_DCDC_5:
-		slot_reg = WM8350_DCDC5_TIMEOUTS;
-		break;
-	case WM8350_DCDC_6:
-		slot_reg = WM8350_DCDC6_TIMEOUTS;
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	val = wm8350_reg_read(wm8350, slot_reg) &
-	    ~(WM8350_DC1_ENSLOT_MASK | WM8350_DC1_SDSLOT_MASK |
-	      WM8350_DC1_ERRACT_MASK);
-	wm8350_reg_write(wm8350, slot_reg,
-			 val | (start << WM8350_DC1_ENSLOT_SHIFT) |
-			 (stop << WM8350_DC1_SDSLOT_SHIFT) |
-			 (fault << WM8350_DC1_ERRACT_SHIFT));
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(wm8350_dcdc_set_slot);
-
-int wm8350_ldo_set_slot(struct wm8350 *wm8350, int ldo, u16 start, u16 stop)
-{
-	int slot_reg;
-	u16 val;
-
-	dev_dbg(wm8350->dev, "%s %d start %d stop %d\n",
-		__func__, ldo, start, stop);
-
-	/* slot valid ? */
-	if (start > 15 || stop > 15)
-		return -EINVAL;
-
-	switch (ldo) {
-	case WM8350_LDO_1:
-		slot_reg = WM8350_LDO1_TIMEOUTS;
-		break;
-	case WM8350_LDO_2:
-		slot_reg = WM8350_LDO2_TIMEOUTS;
-		break;
-	case WM8350_LDO_3:
-		slot_reg = WM8350_LDO3_TIMEOUTS;
-		break;
-	case WM8350_LDO_4:
-		slot_reg = WM8350_LDO4_TIMEOUTS;
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	val = wm8350_reg_read(wm8350, slot_reg) & ~WM8350_LDO1_SDSLOT_MASK;
-	wm8350_reg_write(wm8350, slot_reg, val | ((start << 10) | (stop << 6)));
-	return 0;
-}
-EXPORT_SYMBOL_GPL(wm8350_ldo_set_slot);
-
-int wm8350_dcdc25_set_mode(struct wm8350 *wm8350, int dcdc, u16 mode,
-			   u16 ilim, u16 ramp, u16 feedback)
-{
-	u16 val;
-
-	dev_dbg(wm8350->dev, "%s %d mode: %s %s\n", __func__, dcdc,
-		mode ? "normal" : "boost", ilim ? "low" : "normal");
-
-	switch (dcdc) {
-	case WM8350_DCDC_2:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC2_CONTROL)
-		    & ~(WM8350_DC2_MODE_MASK | WM8350_DC2_ILIM_MASK |
-			WM8350_DC2_RMP_MASK | WM8350_DC2_FBSRC_MASK);
-		wm8350_reg_write(wm8350, WM8350_DCDC2_CONTROL, val |
-				 (mode << WM8350_DC2_MODE_SHIFT) |
-				 (ilim << WM8350_DC2_ILIM_SHIFT) |
-				 (ramp << WM8350_DC2_RMP_SHIFT) |
-				 (feedback << WM8350_DC2_FBSRC_SHIFT));
-		break;
-	case WM8350_DCDC_5:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC5_CONTROL)
-		    & ~(WM8350_DC5_MODE_MASK | WM8350_DC5_ILIM_MASK |
-			WM8350_DC5_RMP_MASK | WM8350_DC5_FBSRC_MASK);
-		wm8350_reg_write(wm8350, WM8350_DCDC5_CONTROL, val |
-				 (mode << WM8350_DC5_MODE_SHIFT) |
-				 (ilim << WM8350_DC5_ILIM_SHIFT) |
-				 (ramp << WM8350_DC5_RMP_SHIFT) |
-				 (feedback << WM8350_DC5_FBSRC_SHIFT));
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(wm8350_dcdc25_set_mode);
-
-static int force_continuous_enable(struct wm8350 *wm8350, int dcdc, int enable)
-{
-	int reg = 0, ret;
-
-	switch (dcdc) {
-	case WM8350_DCDC_1:
-		reg = WM8350_DCDC1_FORCE_PWM;
-		break;
-	case WM8350_DCDC_3:
-		reg = WM8350_DCDC3_FORCE_PWM;
-		break;
-	case WM8350_DCDC_4:
-		reg = WM8350_DCDC4_FORCE_PWM;
-		break;
-	case WM8350_DCDC_6:
-		reg = WM8350_DCDC6_FORCE_PWM;
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	if (enable)
-		ret = wm8350_set_bits(wm8350, reg,
-			WM8350_DCDC1_FORCE_PWM_ENA);
-	else
-		ret = wm8350_clear_bits(wm8350, reg,
-			WM8350_DCDC1_FORCE_PWM_ENA);
-	return ret;
-}
-
-static int wm8350_dcdc_set_mode(struct regulator_dev *rdev, unsigned int mode)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int dcdc = rdev_get_id(rdev);
-	u16 val;
-
-	if (dcdc < WM8350_DCDC_1 || dcdc > WM8350_DCDC_6)
-		return -EINVAL;
-
-	if (dcdc == WM8350_DCDC_2 || dcdc == WM8350_DCDC_5)
-		return -EINVAL;
-
-	val = 1 << (dcdc - WM8350_DCDC_1);
-
-	switch (mode) {
-	case REGULATOR_MODE_FAST:
-		/* force continuous mode */
-		wm8350_set_bits(wm8350, WM8350_DCDC_ACTIVE_OPTIONS, val);
-		wm8350_clear_bits(wm8350, WM8350_DCDC_SLEEP_OPTIONS, val);
-		force_continuous_enable(wm8350, dcdc, 1);
-		break;
-	case REGULATOR_MODE_NORMAL:
-		/* active / pulse skipping */
-		wm8350_set_bits(wm8350, WM8350_DCDC_ACTIVE_OPTIONS, val);
-		wm8350_clear_bits(wm8350, WM8350_DCDC_SLEEP_OPTIONS, val);
-		force_continuous_enable(wm8350, dcdc, 0);
-		break;
-	case REGULATOR_MODE_IDLE:
-		/* standby mode */
-		force_continuous_enable(wm8350, dcdc, 0);
-		wm8350_clear_bits(wm8350, WM8350_DCDC_SLEEP_OPTIONS, val);
-		wm8350_clear_bits(wm8350, WM8350_DCDC_ACTIVE_OPTIONS, val);
-		break;
-	case REGULATOR_MODE_STANDBY:
-		/* LDO mode */
-		force_continuous_enable(wm8350, dcdc, 0);
-		wm8350_set_bits(wm8350, WM8350_DCDC_SLEEP_OPTIONS, val);
-		break;
-	}
-
-	return 0;
-}
-
-static unsigned int wm8350_dcdc_get_mode(struct regulator_dev *rdev)
-{
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-	int dcdc = rdev_get_id(rdev);
-	u16 mask, sleep, active, force;
-	int mode = REGULATOR_MODE_NORMAL;
-	int reg;
-
-	switch (dcdc) {
-	case WM8350_DCDC_1:
-		reg = WM8350_DCDC1_FORCE_PWM;
-		break;
-	case WM8350_DCDC_3:
-		reg = WM8350_DCDC3_FORCE_PWM;
-		break;
-	case WM8350_DCDC_4:
-		reg = WM8350_DCDC4_FORCE_PWM;
-		break;
-	case WM8350_DCDC_6:
-		reg = WM8350_DCDC6_FORCE_PWM;
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	mask = 1 << (dcdc - WM8350_DCDC_1);
-	active = wm8350_reg_read(wm8350, WM8350_DCDC_ACTIVE_OPTIONS) & mask;
-	force = wm8350_reg_read(wm8350, reg) & WM8350_DCDC1_FORCE_PWM_ENA;
-	sleep = wm8350_reg_read(wm8350, WM8350_DCDC_SLEEP_OPTIONS) & mask;
-
-	dev_dbg(wm8350->dev, "mask %x active %x sleep %x force %x",
-		mask, active, sleep, force);
-
-	if (active && !sleep) {
-		if (force)
-			mode = REGULATOR_MODE_FAST;
-		else
-			mode = REGULATOR_MODE_NORMAL;
-	} else if (!active && !sleep)
-		mode = REGULATOR_MODE_IDLE;
-	else if (sleep)
-		mode = REGULATOR_MODE_STANDBY;
-
-	return mode;
-}
-
-static unsigned int wm8350_ldo_get_mode(struct regulator_dev *rdev)
-{
-	return REGULATOR_MODE_NORMAL;
-}
-
-struct wm8350_dcdc_efficiency {
-	int uA_load_min;
-	int uA_load_max;
-	unsigned int mode;
-};
-
-static const struct wm8350_dcdc_efficiency dcdc1_6_efficiency[] = {
-	{0, 10000, REGULATOR_MODE_STANDBY},       /* 0 - 10mA - LDO */
-	{10000, 100000, REGULATOR_MODE_IDLE},     /* 10mA - 100mA - Standby */
-	{100000, 1000000, REGULATOR_MODE_NORMAL}, /* > 100mA - Active */
-	{-1, -1, REGULATOR_MODE_NORMAL},
-};
-
-static const struct wm8350_dcdc_efficiency dcdc3_4_efficiency[] = {
-	{0, 10000, REGULATOR_MODE_STANDBY},      /* 0 - 10mA - LDO */
-	{10000, 100000, REGULATOR_MODE_IDLE},    /* 10mA - 100mA - Standby */
-	{100000, 800000, REGULATOR_MODE_NORMAL}, /* > 100mA - Active */
-	{-1, -1, REGULATOR_MODE_NORMAL},
-};
-
-static unsigned int get_mode(int uA, const struct wm8350_dcdc_efficiency *eff)
-{
-	int i = 0;
-
-	while (eff[i].uA_load_min != -1) {
-		if (uA >= eff[i].uA_load_min && uA <= eff[i].uA_load_max)
-			return eff[i].mode;
-		i++;
-	}
-	return REGULATOR_MODE_NORMAL;
-}
-
-/* Query the regulator for it's most efficient mode @ uV,uA
- * WM8350 regulator efficiency is pretty similar over
- * different input and output uV.
- */
-static unsigned int wm8350_dcdc_get_optimum_mode(struct regulator_dev *rdev,
-						 int input_uV, int output_uV,
-						 int output_uA)
-{
-	int dcdc = rdev_get_id(rdev), mode;
-
-	switch (dcdc) {
-	case WM8350_DCDC_1:
-	case WM8350_DCDC_6:
-		mode = get_mode(output_uA, dcdc1_6_efficiency);
-		break;
-	case WM8350_DCDC_3:
-	case WM8350_DCDC_4:
-		mode = get_mode(output_uA, dcdc3_4_efficiency);
-		break;
-	default:
-		mode = REGULATOR_MODE_NORMAL;
-		break;
-	}
-	return mode;
-}
-
-static const struct regulator_ops wm8350_dcdc_ops = {
-	.set_voltage_sel = regulator_set_voltage_sel_regmap,
-	.get_voltage_sel = regulator_get_voltage_sel_regmap,
-	.list_voltage = regulator_list_voltage_linear,
-	.map_voltage = regulator_map_voltage_linear,
-	.enable = regulator_enable_regmap,
-	.disable = regulator_disable_regmap,
-	.is_enabled = regulator_is_enabled_regmap,
-	.get_mode = wm8350_dcdc_get_mode,
-	.set_mode = wm8350_dcdc_set_mode,
-	.get_optimum_mode = wm8350_dcdc_get_optimum_mode,
-	.set_suspend_voltage = wm8350_dcdc_set_suspend_voltage,
-	.set_suspend_enable = wm8350_dcdc_set_suspend_enable,
-	.set_suspend_disable = wm8350_dcdc_set_suspend_disable,
-	.set_suspend_mode = wm8350_dcdc_set_suspend_mode,
-};
-
-static const struct regulator_ops wm8350_dcdc2_5_ops = {
-	.enable = regulator_enable_regmap,
-	.disable = regulator_disable_regmap,
-	.is_enabled = regulator_is_enabled_regmap,
-	.set_suspend_enable = wm8350_dcdc25_set_suspend_enable,
-	.set_suspend_disable = wm8350_dcdc25_set_suspend_disable,
-};
-
-static const struct regulator_ops wm8350_ldo_ops = {
-	.map_voltage = regulator_map_voltage_linear_range,
-	.set_voltage_sel = regulator_set_voltage_sel_regmap,
-	.get_voltage_sel = regulator_get_voltage_sel_regmap,
-	.list_voltage = regulator_list_voltage_linear_range,
-	.enable = regulator_enable_regmap,
-	.disable = regulator_disable_regmap,
-	.is_enabled = regulator_is_enabled_regmap,
-	.get_mode = wm8350_ldo_get_mode,
-	.set_suspend_voltage = wm8350_ldo_set_suspend_voltage,
-	.set_suspend_enable = wm8350_ldo_set_suspend_enable,
-	.set_suspend_disable = wm8350_ldo_set_suspend_disable,
-};
-
-static const struct regulator_ops wm8350_isink_ops = {
-	.set_current_limit = regulator_set_current_limit_regmap,
-	.get_current_limit = regulator_get_current_limit_regmap,
-	.enable = wm8350_isink_enable,
-	.disable = wm8350_isink_disable,
-	.is_enabled = wm8350_isink_is_enabled,
-	.enable_time = wm8350_isink_enable_time,
-};
-
-static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
-	{
-		.name = "DCDC1",
-		.id = WM8350_DCDC_1,
-		.ops = &wm8350_dcdc_ops,
-		.irq = WM8350_IRQ_UV_DC1,
-		.type = REGULATOR_VOLTAGE,
-		.n_voltages = WM8350_DCDC_MAX_VSEL + 1,
-		.min_uV = 850000,
-		.uV_step = 25000,
-		.vsel_reg = WM8350_DCDC1_CONTROL,
-		.vsel_mask = WM8350_DC1_VSEL_MASK,
-		.enable_reg = WM8350_DCDC_LDO_REQUESTED,
-		.enable_mask = WM8350_DC1_ENA,
-		.owner = THIS_MODULE,
-	},
-	{
-		.name = "DCDC2",
-		.id = WM8350_DCDC_2,
-		.ops = &wm8350_dcdc2_5_ops,
-		.irq = WM8350_IRQ_UV_DC2,
-		.type = REGULATOR_VOLTAGE,
-		.enable_reg = WM8350_DCDC_LDO_REQUESTED,
-		.enable_mask = WM8350_DC2_ENA,
-		.owner = THIS_MODULE,
-	},
-	{
-		.name = "DCDC3",
-		.id = WM8350_DCDC_3,
-		.ops = &wm8350_dcdc_ops,
-		.irq = WM8350_IRQ_UV_DC3,
-		.type = REGULATOR_VOLTAGE,
-		.n_voltages = WM8350_DCDC_MAX_VSEL + 1,
-		.min_uV = 850000,
-		.uV_step = 25000,
-		.vsel_reg = WM8350_DCDC3_CONTROL,
-		.vsel_mask = WM8350_DC3_VSEL_MASK,
-		.enable_reg = WM8350_DCDC_LDO_REQUESTED,
-		.enable_mask = WM8350_DC3_ENA,
-		.owner = THIS_MODULE,
-	},
-	{
-		.name = "DCDC4",
-		.id = WM8350_DCDC_4,
-		.ops = &wm8350_dcdc_ops,
-		.irq = WM8350_IRQ_UV_DC4,
-		.type = REGULATOR_VOLTAGE,
-		.n_voltages = WM8350_DCDC_MAX_VSEL + 1,
-		.min_uV = 850000,
-		.uV_step = 25000,
-		.vsel_reg = WM8350_DCDC4_CONTROL,
-		.vsel_mask = WM8350_DC4_VSEL_MASK,
-		.enable_reg = WM8350_DCDC_LDO_REQUESTED,
-		.enable_mask = WM8350_DC4_ENA,
-		.owner = THIS_MODULE,
-	},
-	{
-		.name = "DCDC5",
-		.id = WM8350_DCDC_5,
-		.ops = &wm8350_dcdc2_5_ops,
-		.irq = WM8350_IRQ_UV_DC5,
-		.type = REGULATOR_VOLTAGE,
-		.enable_reg = WM8350_DCDC_LDO_REQUESTED,
-		.enable_mask = WM8350_DC5_ENA,
-		.owner = THIS_MODULE,
-	 },
-	{
-		.name = "DCDC6",
-		.id = WM8350_DCDC_6,
-		.ops = &wm8350_dcdc_ops,
-		.irq = WM8350_IRQ_UV_DC6,
-		.type = REGULATOR_VOLTAGE,
-		.n_voltages = WM8350_DCDC_MAX_VSEL + 1,
-		.min_uV = 850000,
-		.uV_step = 25000,
-		.vsel_reg = WM8350_DCDC6_CONTROL,
-		.vsel_mask = WM8350_DC6_VSEL_MASK,
-		.enable_reg = WM8350_DCDC_LDO_REQUESTED,
-		.enable_mask = WM8350_DC6_ENA,
-		.owner = THIS_MODULE,
-	},
-	{
-		.name = "LDO1",
-		.id = WM8350_LDO_1,
-		.ops = &wm8350_ldo_ops,
-		.irq = WM8350_IRQ_UV_LDO1,
-		.type = REGULATOR_VOLTAGE,
-		.n_voltages = WM8350_LDO1_VSEL_MASK + 1,
-		.linear_ranges = wm8350_ldo_ranges,
-		.n_linear_ranges = ARRAY_SIZE(wm8350_ldo_ranges),
-		.vsel_reg = WM8350_LDO1_CONTROL,
-		.vsel_mask = WM8350_LDO1_VSEL_MASK,
-		.enable_reg = WM8350_DCDC_LDO_REQUESTED,
-		.enable_mask = WM8350_LDO1_ENA,
-		.owner = THIS_MODULE,
-	},
-	{
-		.name = "LDO2",
-		.id = WM8350_LDO_2,
-		.ops = &wm8350_ldo_ops,
-		.irq = WM8350_IRQ_UV_LDO2,
-		.type = REGULATOR_VOLTAGE,
-		.n_voltages = WM8350_LDO2_VSEL_MASK + 1,
-		.linear_ranges = wm8350_ldo_ranges,
-		.n_linear_ranges = ARRAY_SIZE(wm8350_ldo_ranges),
-		.vsel_reg = WM8350_LDO2_CONTROL,
-		.vsel_mask = WM8350_LDO2_VSEL_MASK,
-		.enable_reg = WM8350_DCDC_LDO_REQUESTED,
-		.enable_mask = WM8350_LDO2_ENA,
-		.owner = THIS_MODULE,
-	},
-	{
-		.name = "LDO3",
-		.id = WM8350_LDO_3,
-		.ops = &wm8350_ldo_ops,
-		.irq = WM8350_IRQ_UV_LDO3,
-		.type = REGULATOR_VOLTAGE,
-		.n_voltages = WM8350_LDO3_VSEL_MASK + 1,
-		.linear_ranges = wm8350_ldo_ranges,
-		.n_linear_ranges = ARRAY_SIZE(wm8350_ldo_ranges),
-		.vsel_reg = WM8350_LDO3_CONTROL,
-		.vsel_mask = WM8350_LDO3_VSEL_MASK,
-		.enable_reg = WM8350_DCDC_LDO_REQUESTED,
-		.enable_mask = WM8350_LDO3_ENA,
-		.owner = THIS_MODULE,
-	},
-	{
-		.name = "LDO4",
-		.id = WM8350_LDO_4,
-		.ops = &wm8350_ldo_ops,
-		.irq = WM8350_IRQ_UV_LDO4,
-		.type = REGULATOR_VOLTAGE,
-		.n_voltages = WM8350_LDO4_VSEL_MASK + 1,
-		.linear_ranges = wm8350_ldo_ranges,
-		.n_linear_ranges = ARRAY_SIZE(wm8350_ldo_ranges),
-		.vsel_reg = WM8350_LDO4_CONTROL,
-		.vsel_mask = WM8350_LDO4_VSEL_MASK,
-		.enable_reg = WM8350_DCDC_LDO_REQUESTED,
-		.enable_mask = WM8350_LDO4_ENA,
-		.owner = THIS_MODULE,
-	},
-	{
-		.name = "ISINKA",
-		.id = WM8350_ISINK_A,
-		.ops = &wm8350_isink_ops,
-		.irq = WM8350_IRQ_CS1,
-		.type = REGULATOR_CURRENT,
-		.owner = THIS_MODULE,
-		.curr_table = isink_cur,
-		.n_current_limits = ARRAY_SIZE(isink_cur),
-		.csel_reg = WM8350_CURRENT_SINK_DRIVER_A,
-		.csel_mask = WM8350_CS1_ISEL_MASK,
-	 },
-	{
-		.name = "ISINKB",
-		.id = WM8350_ISINK_B,
-		.ops = &wm8350_isink_ops,
-		.irq = WM8350_IRQ_CS2,
-		.type = REGULATOR_CURRENT,
-		.owner = THIS_MODULE,
-		.curr_table = isink_cur,
-		.n_current_limits = ARRAY_SIZE(isink_cur),
-		.csel_reg = WM8350_CURRENT_SINK_DRIVER_B,
-		.csel_mask = WM8350_CS2_ISEL_MASK,
-	 },
-};
-
-static irqreturn_t pmic_uv_handler(int irq, void *data)
-{
-	struct regulator_dev *rdev = (struct regulator_dev *)data;
-
-	if (irq == WM8350_IRQ_CS1 || irq == WM8350_IRQ_CS2)
-		regulator_notifier_call_chain(rdev,
-					      REGULATOR_EVENT_REGULATION_OUT,
-					      NULL);
-	else
-		regulator_notifier_call_chain(rdev,
-					      REGULATOR_EVENT_UNDER_VOLTAGE,
-					      NULL);
-
-	return IRQ_HANDLED;
-}
-
-static int wm8350_regulator_probe(struct platform_device *pdev)
-{
-	struct wm8350 *wm8350 = dev_get_drvdata(&pdev->dev);
-	struct regulator_config config = { };
-	struct regulator_dev *rdev;
-	int ret;
-	u16 val;
-
-	if (pdev->id < WM8350_DCDC_1 || pdev->id > WM8350_ISINK_B)
-		return -ENODEV;
-
-	/* do any regulator specific init */
-	switch (pdev->id) {
-	case WM8350_DCDC_1:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC1_LOW_POWER);
-		wm8350->pmic.dcdc1_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
-		break;
-	case WM8350_DCDC_3:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC3_LOW_POWER);
-		wm8350->pmic.dcdc3_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
-		break;
-	case WM8350_DCDC_4:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC4_LOW_POWER);
-		wm8350->pmic.dcdc4_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
-		break;
-	case WM8350_DCDC_6:
-		val = wm8350_reg_read(wm8350, WM8350_DCDC6_LOW_POWER);
-		wm8350->pmic.dcdc6_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
-		break;
-	}
-
-	config.dev = &pdev->dev;
-	config.init_data = dev_get_platdata(&pdev->dev);
-	config.driver_data = dev_get_drvdata(&pdev->dev);
-	config.regmap = wm8350->regmap;
-
-	/* register regulator */
-	rdev = devm_regulator_register(&pdev->dev, &wm8350_reg[pdev->id],
-				       &config);
-	if (IS_ERR(rdev)) {
-		dev_err(&pdev->dev, "failed to register %s\n",
-			wm8350_reg[pdev->id].name);
-		return PTR_ERR(rdev);
-	}
-
-	/* register regulator IRQ */
-	ret = wm8350_register_irq(wm8350, wm8350_reg[pdev->id].irq,
-				  pmic_uv_handler, 0, "UV", rdev);
-	if (ret < 0) {
-		dev_err(&pdev->dev, "failed to register regulator %s IRQ\n",
-			wm8350_reg[pdev->id].name);
-		return ret;
-	}
-
-	return 0;
-}
-
-static void wm8350_regulator_remove(struct platform_device *pdev)
-{
-	struct regulator_dev *rdev = platform_get_drvdata(pdev);
-	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-
-	wm8350_free_irq(wm8350, wm8350_reg[pdev->id].irq, rdev);
-}
-
-int wm8350_register_regulator(struct wm8350 *wm8350, int reg,
-			      struct regulator_init_data *initdata)
-{
-	struct platform_device *pdev;
-	int ret;
-	if (reg < 0 || reg >= NUM_WM8350_REGULATORS)
-		return -EINVAL;
-
-	if (wm8350->pmic.pdev[reg])
-		return -EBUSY;
-
-	if (reg >= WM8350_DCDC_1 && reg <= WM8350_DCDC_6 &&
-	    reg > wm8350->pmic.max_dcdc)
-		return -ENODEV;
-	if (reg >= WM8350_ISINK_A && reg <= WM8350_ISINK_B &&
-	    reg > wm8350->pmic.max_isink)
-		return -ENODEV;
-
-	pdev = platform_device_alloc("wm8350-regulator", reg);
-	if (!pdev)
-		return -ENOMEM;
-
-	wm8350->pmic.pdev[reg] = pdev;
-
-	initdata->driver_data = wm8350;
-
-	pdev->dev.platform_data = initdata;
-	pdev->dev.parent = wm8350->dev;
-	platform_set_drvdata(pdev, wm8350);
-
-	ret = platform_device_add(pdev);
-
-	if (ret != 0) {
-		dev_err(wm8350->dev, "Failed to register regulator %d: %d\n",
-			reg, ret);
-		platform_device_put(pdev);
-		wm8350->pmic.pdev[reg] = NULL;
-	}
-
-	return ret;
-}
-EXPORT_SYMBOL_GPL(wm8350_register_regulator);
-
-/**
- * wm8350_register_led - Register a WM8350 LED output
- *
- * @wm8350: The WM8350 device to configure.
- * @lednum: LED device index to create.
- * @dcdc: The DCDC to use for the LED.
- * @isink: The ISINK to use for the LED.
- * @pdata: Configuration for the LED.
- *
- * The WM8350 supports the use of an ISINK together with a DCDC to
- * provide a power-efficient LED driver.  This function registers the
- * regulators and instantiates the platform device for a LED.  The
- * operating modes for the LED regulators must be configured using
- * wm8350_isink_set_flash(), wm8350_dcdc25_set_mode() and
- * wm8350_dcdc_set_slot() prior to calling this function.
- */
-int wm8350_register_led(struct wm8350 *wm8350, int lednum, int dcdc, int isink,
-			struct wm8350_led_platform_data *pdata)
-{
-	struct wm8350_led *led;
-	struct platform_device *pdev;
-	int ret;
-
-	if (lednum >= ARRAY_SIZE(wm8350->pmic.led) || lednum < 0) {
-		dev_err(wm8350->dev, "Invalid LED index %d\n", lednum);
-		return -ENODEV;
-	}
-
-	led = &wm8350->pmic.led[lednum];
-
-	if (led->pdev) {
-		dev_err(wm8350->dev, "LED %d already allocated\n", lednum);
-		return -EINVAL;
-	}
-
-	pdev = platform_device_alloc("wm8350-led", lednum);
-	if (pdev == NULL) {
-		dev_err(wm8350->dev, "Failed to allocate LED %d\n", lednum);
-		return -ENOMEM;
-	}
-
-	led->isink_consumer.dev_name = dev_name(&pdev->dev);
-	led->isink_consumer.supply = "led_isink";
-	led->isink_init.num_consumer_supplies = 1;
-	led->isink_init.consumer_supplies = &led->isink_consumer;
-	led->isink_init.constraints.min_uA = 0;
-	led->isink_init.constraints.max_uA = pdata->max_uA;
-	led->isink_init.constraints.valid_ops_mask
-		= REGULATOR_CHANGE_CURRENT | REGULATOR_CHANGE_STATUS;
-	led->isink_init.constraints.valid_modes_mask = REGULATOR_MODE_NORMAL;
-	ret = wm8350_register_regulator(wm8350, isink, &led->isink_init);
-	if (ret != 0) {
-		platform_device_put(pdev);
-		return ret;
-	}
-
-	led->dcdc_consumer.dev_name = dev_name(&pdev->dev);
-	led->dcdc_consumer.supply = "led_vcc";
-	led->dcdc_init.num_consumer_supplies = 1;
-	led->dcdc_init.consumer_supplies = &led->dcdc_consumer;
-	led->dcdc_init.constraints.valid_modes_mask = REGULATOR_MODE_NORMAL;
-	led->dcdc_init.constraints.valid_ops_mask =  REGULATOR_CHANGE_STATUS;
-	ret = wm8350_register_regulator(wm8350, dcdc, &led->dcdc_init);
-	if (ret != 0) {
-		platform_device_put(pdev);
-		return ret;
-	}
-
-	switch (isink) {
-	case WM8350_ISINK_A:
-		wm8350->pmic.isink_A_dcdc = dcdc;
-		break;
-	case WM8350_ISINK_B:
-		wm8350->pmic.isink_B_dcdc = dcdc;
-		break;
-	}
-
-	pdev->dev.platform_data = pdata;
-	pdev->dev.parent = wm8350->dev;
-	ret = platform_device_add(pdev);
-	if (ret != 0) {
-		dev_err(wm8350->dev, "Failed to register LED %d: %d\n",
-			lednum, ret);
-		platform_device_put(pdev);
-		return ret;
-	}
-
-	led->pdev = pdev;
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(wm8350_register_led);
-
-static struct platform_driver wm8350_regulator_driver = {
-	.probe = wm8350_regulator_probe,
-	.remove = wm8350_regulator_remove,
-	.driver = {
-		.name = "wm8350-regulator",
-		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
-	},
-};
-
-static int __init wm8350_regulator_init(void)
-{
-	return platform_driver_register(&wm8350_regulator_driver);
-}
-subsys_initcall(wm8350_regulator_init);
-
-static void __exit wm8350_regulator_exit(void)
-{
-	platform_driver_unregister(&wm8350_regulator_driver);
-}
-module_exit(wm8350_regulator_exit);
-
-/* Module information */
-MODULE_AUTHOR("Liam Girdwood");
-MODULE_DESCRIPTION("WM8350 voltage and current regulator driver");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:wm8350-regulator");