Merge tag 'gpio-v5.4-updates-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/brgl/linux into devel

gpio: updates for v5.4

- use a helper variable for &pdev->dev in gpio-em
- tweak the ifdefs in GPIO headers
- fix function links in HTML docs
- remove an unneeded error message from ixp4xx
- use the optional clk_get in gpio-mxc instead of checking the return value
- a couple improvements in pca953x
- allow to build gpio-lpc32xx on non-lpc32xx targets

7 files changed, 132 insertions, 115 deletions

diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 8137f3e3a108..e193c76948c4 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -311,6 +311,13 @@ config GPIO_LPC18XX
           Select this option to enable GPIO driver for
           NXP LPC18XX/43XX devices.
 
+config GPIO_LPC32XX
+        tristate "NXP LPC32XX GPIO support"
+        depends on OF_GPIO && (ARCH_LPC32XX || COMPILE_TEST)
+        help
+          Select this option to enable GPIO driver for
+          NXP LPC32XX devices.
+
 config GPIO_LYNXPOINT
         tristate "Intel Lynxpoint GPIO support"
         depends on ACPI && X86
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 65d74084c9b2..f3e051fb50e6 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -73,7 +73,7 @@ obj-$(CONFIG_GPIO_LP3943)		+= gpio-lp3943.o
 obj-$(CONFIG_GPIO_LP873X)               += gpio-lp873x.o
 obj-$(CONFIG_GPIO_LP87565)              += gpio-lp87565.o
 obj-$(CONFIG_GPIO_LPC18XX)              += gpio-lpc18xx.o
-obj-$(CONFIG_ARCH_LPC32XX)              += gpio-lpc32xx.o
+obj-$(CONFIG_GPIO_LPC32XX)              += gpio-lpc32xx.o
 obj-$(CONFIG_GPIO_LYNXPOINT)            += gpio-lynxpoint.o
 obj-$(CONFIG_GPIO_MADERA)               += gpio-madera.o
 obj-$(CONFIG_GPIO_MAX3191X)             += gpio-max3191x.o
diff --git a/drivers/gpio/gpio-em.c b/drivers/gpio/gpio-em.c
index a87951293aaa..620f25b7efb4 100644
--- a/drivers/gpio/gpio-em.c
+++ b/drivers/gpio/gpio-em.c
@@ -272,11 +272,12 @@ static int em_gio_probe(struct platform_device *pdev)
         struct resource *io[2], *irq[2];
         struct gpio_chip *gpio_chip;
         struct irq_chip *irq_chip;
-        const char *name = dev_name(&pdev->dev);
+        struct device *dev = &pdev->dev;
+        const char *name = dev_name(dev);
         unsigned int ngpios;
         int ret;
 
-        p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
+        p = devm_kzalloc(dev, sizeof(*p), GFP_KERNEL);
         if (!p)
                 return -ENOMEM;
 
@@ -290,27 +291,27 @@ static int em_gio_probe(struct platform_device *pdev)
         irq[1] = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
 
         if (!io[0] || !io[1] || !irq[0] || !irq[1]) {
-                dev_err(&pdev->dev, "missing IRQ or IOMEM\n");
+                dev_err(dev, "missing IRQ or IOMEM\n");
                 return -EINVAL;
         }
 
-        p->base0 = devm_ioremap_nocache(&pdev->dev, io[0]->start,
+        p->base0 = devm_ioremap_nocache(dev, io[0]->start,
                                         resource_size(io[0]));
         if (!p->base0)
                 return -ENOMEM;
 
-        p->base1 = devm_ioremap_nocache(&pdev->dev, io[1]->start,
+        p->base1 = devm_ioremap_nocache(dev, io[1]->start,
                                    resource_size(io[1]));
         if (!p->base1)
                 return -ENOMEM;
 
-        if (of_property_read_u32(pdev->dev.of_node, "ngpios", &ngpios)) {
-                dev_err(&pdev->dev, "Missing ngpios OF property\n");
+        if (of_property_read_u32(dev->of_node, "ngpios", &ngpios)) {
+                dev_err(dev, "Missing ngpios OF property\n");
                 return -EINVAL;
         }
 
         gpio_chip = &p->gpio_chip;
-        gpio_chip->of_node = pdev->dev.of_node;
+        gpio_chip->of_node = dev->of_node;
         gpio_chip->direction_input = em_gio_direction_input;
         gpio_chip->get = em_gio_get;
         gpio_chip->direction_output = em_gio_direction_output;
@@ -319,7 +320,7 @@ static int em_gio_probe(struct platform_device *pdev)
         gpio_chip->request = em_gio_request;
         gpio_chip->free = em_gio_free;
         gpio_chip->label = name;
-        gpio_chip->parent = &pdev->dev;
+        gpio_chip->parent = dev;
         gpio_chip->owner = THIS_MODULE;
         gpio_chip->base = -1;
         gpio_chip->ngpio = ngpios;
@@ -333,33 +334,33 @@ static int em_gio_probe(struct platform_device *pdev)
         irq_chip->irq_release_resources = em_gio_irq_relres;
         irq_chip->flags = IRQCHIP_SKIP_SET_WAKE | IRQCHIP_MASK_ON_SUSPEND;
 
-        p->irq_domain = irq_domain_add_simple(pdev->dev.of_node, ngpios, 0,
+        p->irq_domain = irq_domain_add_simple(dev->of_node, ngpios, 0,
                                               &em_gio_irq_domain_ops, p);
         if (!p->irq_domain) {
-                dev_err(&pdev->dev, "cannot initialize irq domain\n");
+                dev_err(dev, "cannot initialize irq domain\n");
                 return -ENXIO;
         }
 
-        ret = devm_add_action_or_reset(&pdev->dev, em_gio_irq_domain_remove,
+        ret = devm_add_action_or_reset(dev, em_gio_irq_domain_remove,
                                        p->irq_domain);
         if (ret)
                 return ret;
 
-        if (devm_request_irq(&pdev->dev, irq[0]->start,
+        if (devm_request_irq(dev, irq[0]->start,
                              em_gio_irq_handler, 0, name, p)) {
-                dev_err(&pdev->dev, "failed to request low IRQ\n");
+                dev_err(dev, "failed to request low IRQ\n");
                 return -ENOENT;
         }
 
-        if (devm_request_irq(&pdev->dev, irq[1]->start,
+        if (devm_request_irq(dev, irq[1]->start,
                              em_gio_irq_handler, 0, name, p)) {
-                dev_err(&pdev->dev, "failed to request high IRQ\n");
+                dev_err(dev, "failed to request high IRQ\n");
                 return -ENOENT;
         }
 
-        ret = devm_gpiochip_add_data(&pdev->dev, gpio_chip, p);
+        ret = devm_gpiochip_add_data(dev, gpio_chip, p);
         if (ret) {
-                dev_err(&pdev->dev, "failed to add GPIO controller\n");
+                dev_err(dev, "failed to add GPIO controller\n");
                 return ret;
         }
 
diff --git a/drivers/gpio/gpio-ixp4xx.c b/drivers/gpio/gpio-ixp4xx.c
index 1a57e74fdb91..b3b050604e0b 100644
--- a/drivers/gpio/gpio-ixp4xx.c
+++ b/drivers/gpio/gpio-ixp4xx.c
@@ -204,10 +204,8 @@ static int ixp4xx_gpio_probe(struct platform_device *pdev)
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         g->base = devm_ioremap_resource(dev, res);
-        if (IS_ERR(g->base)) {
-                dev_err(dev, "ioremap error\n");
+        if (IS_ERR(g->base))
                 return PTR_ERR(g->base);
-        }
 
         /*
          * When we convert to device tree we will simply look up the
diff --git a/drivers/gpio/gpio-lpc32xx.c b/drivers/gpio/gpio-lpc32xx.c
index 24885b3db3d5..4e626c4235c2 100644
--- a/drivers/gpio/gpio-lpc32xx.c
+++ b/drivers/gpio/gpio-lpc32xx.c
@@ -16,36 +16,33 @@
 #include <linux/platform_device.h>
 #include <linux/module.h>
 
-#include <mach/hardware.h>
-#include <mach/platform.h>
-
-#define LPC32XX_GPIO_P3_INP_STATE               _GPREG(0x000)
-#define LPC32XX_GPIO_P3_OUTP_SET                _GPREG(0x004)
-#define LPC32XX_GPIO_P3_OUTP_CLR                _GPREG(0x008)
-#define LPC32XX_GPIO_P3_OUTP_STATE              _GPREG(0x00C)
-#define LPC32XX_GPIO_P2_DIR_SET                 _GPREG(0x010)
-#define LPC32XX_GPIO_P2_DIR_CLR                 _GPREG(0x014)
-#define LPC32XX_GPIO_P2_DIR_STATE               _GPREG(0x018)
-#define LPC32XX_GPIO_P2_INP_STATE               _GPREG(0x01C)
-#define LPC32XX_GPIO_P2_OUTP_SET                _GPREG(0x020)
-#define LPC32XX_GPIO_P2_OUTP_CLR                _GPREG(0x024)
-#define LPC32XX_GPIO_P2_MUX_SET                 _GPREG(0x028)
-#define LPC32XX_GPIO_P2_MUX_CLR                 _GPREG(0x02C)
-#define LPC32XX_GPIO_P2_MUX_STATE               _GPREG(0x030)
-#define LPC32XX_GPIO_P0_INP_STATE               _GPREG(0x040)
-#define LPC32XX_GPIO_P0_OUTP_SET                _GPREG(0x044)
-#define LPC32XX_GPIO_P0_OUTP_CLR                _GPREG(0x048)
-#define LPC32XX_GPIO_P0_OUTP_STATE              _GPREG(0x04C)
-#define LPC32XX_GPIO_P0_DIR_SET                 _GPREG(0x050)
-#define LPC32XX_GPIO_P0_DIR_CLR                 _GPREG(0x054)
-#define LPC32XX_GPIO_P0_DIR_STATE               _GPREG(0x058)
-#define LPC32XX_GPIO_P1_INP_STATE               _GPREG(0x060)
-#define LPC32XX_GPIO_P1_OUTP_SET                _GPREG(0x064)
-#define LPC32XX_GPIO_P1_OUTP_CLR                _GPREG(0x068)
-#define LPC32XX_GPIO_P1_OUTP_STATE              _GPREG(0x06C)
-#define LPC32XX_GPIO_P1_DIR_SET                 _GPREG(0x070)
-#define LPC32XX_GPIO_P1_DIR_CLR                 _GPREG(0x074)
-#define LPC32XX_GPIO_P1_DIR_STATE               _GPREG(0x078)
+#define LPC32XX_GPIO_P3_INP_STATE               (0x000)
+#define LPC32XX_GPIO_P3_OUTP_SET                (0x004)
+#define LPC32XX_GPIO_P3_OUTP_CLR                (0x008)
+#define LPC32XX_GPIO_P3_OUTP_STATE              (0x00C)
+#define LPC32XX_GPIO_P2_DIR_SET                 (0x010)
+#define LPC32XX_GPIO_P2_DIR_CLR                 (0x014)
+#define LPC32XX_GPIO_P2_DIR_STATE               (0x018)
+#define LPC32XX_GPIO_P2_INP_STATE               (0x01C)
+#define LPC32XX_GPIO_P2_OUTP_SET                (0x020)
+#define LPC32XX_GPIO_P2_OUTP_CLR                (0x024)
+#define LPC32XX_GPIO_P2_MUX_SET                 (0x028)
+#define LPC32XX_GPIO_P2_MUX_CLR                 (0x02C)
+#define LPC32XX_GPIO_P2_MUX_STATE               (0x030)
+#define LPC32XX_GPIO_P0_INP_STATE               (0x040)
+#define LPC32XX_GPIO_P0_OUTP_SET                (0x044)
+#define LPC32XX_GPIO_P0_OUTP_CLR                (0x048)
+#define LPC32XX_GPIO_P0_OUTP_STATE              (0x04C)
+#define LPC32XX_GPIO_P0_DIR_SET                 (0x050)
+#define LPC32XX_GPIO_P0_DIR_CLR                 (0x054)
+#define LPC32XX_GPIO_P0_DIR_STATE               (0x058)
+#define LPC32XX_GPIO_P1_INP_STATE               (0x060)
+#define LPC32XX_GPIO_P1_OUTP_SET                (0x064)
+#define LPC32XX_GPIO_P1_OUTP_CLR                (0x068)
+#define LPC32XX_GPIO_P1_OUTP_STATE              (0x06C)
+#define LPC32XX_GPIO_P1_DIR_SET                 (0x070)
+#define LPC32XX_GPIO_P1_DIR_CLR                 (0x074)
+#define LPC32XX_GPIO_P1_DIR_STATE               (0x078)
 
 #define GPIO012_PIN_TO_BIT(x)                   (1 << (x))
 #define GPIO3_PIN_TO_BIT(x)                     (1 << ((x) + 25))
@@ -72,12 +69,12 @@
 #define LPC32XX_GPO_P3_GRP      (LPC32XX_GPI_P3_GRP + LPC32XX_GPI_P3_MAX)
 
 struct gpio_regs {
-        void __iomem *inp_state;
-        void __iomem *outp_state;
-        void __iomem *outp_set;
-        void __iomem *outp_clr;
-        void __iomem *dir_set;
-        void __iomem *dir_clr;
+        unsigned long inp_state;
+        unsigned long outp_state;
+        unsigned long outp_set;
+        unsigned long outp_clr;
+        unsigned long dir_set;
+        unsigned long dir_clr;
 };
 
 /*
@@ -165,16 +162,27 @@ static struct gpio_regs gpio_grp_regs_p3 = {
 struct lpc32xx_gpio_chip {
         struct gpio_chip        chip;
         struct gpio_regs        *gpio_grp;
+        void __iomem            *reg_base;
 };
 
+static inline u32 gpreg_read(struct lpc32xx_gpio_chip *group, unsigned long offset)
+{
+        return __raw_readl(group->reg_base + offset);
+}
+
+static inline void gpreg_write(struct lpc32xx_gpio_chip *group, u32 val, unsigned long offset)
+{
+        __raw_writel(val, group->reg_base + offset);
+}
+
 static void __set_gpio_dir_p012(struct lpc32xx_gpio_chip *group,
         unsigned pin, int input)
 {
         if (input)
-                __raw_writel(GPIO012_PIN_TO_BIT(pin),
+                gpreg_write(group, GPIO012_PIN_TO_BIT(pin),
                         group->gpio_grp->dir_clr);
         else
-                __raw_writel(GPIO012_PIN_TO_BIT(pin),
+                gpreg_write(group, GPIO012_PIN_TO_BIT(pin),
                         group->gpio_grp->dir_set);
 }
 
@@ -184,19 +192,19 @@ static void __set_gpio_dir_p3(struct lpc32xx_gpio_chip *group,
         u32 u = GPIO3_PIN_TO_BIT(pin);
 
         if (input)
-                __raw_writel(u, group->gpio_grp->dir_clr);
+                gpreg_write(group, u, group->gpio_grp->dir_clr);
         else
-                __raw_writel(u, group->gpio_grp->dir_set);
+                gpreg_write(group, u, group->gpio_grp->dir_set);
 }
 
 static void __set_gpio_level_p012(struct lpc32xx_gpio_chip *group,
         unsigned pin, int high)
 {
         if (high)
-                __raw_writel(GPIO012_PIN_TO_BIT(pin),
+                gpreg_write(group, GPIO012_PIN_TO_BIT(pin),
                         group->gpio_grp->outp_set);
         else
-                __raw_writel(GPIO012_PIN_TO_BIT(pin),
+                gpreg_write(group, GPIO012_PIN_TO_BIT(pin),
                         group->gpio_grp->outp_clr);
 }
 
@@ -206,31 +214,31 @@ static void __set_gpio_level_p3(struct lpc32xx_gpio_chip *group,
         u32 u = GPIO3_PIN_TO_BIT(pin);
 
         if (high)
-                __raw_writel(u, group->gpio_grp->outp_set);
+                gpreg_write(group, u, group->gpio_grp->outp_set);
         else
-                __raw_writel(u, group->gpio_grp->outp_clr);
+                gpreg_write(group, u, group->gpio_grp->outp_clr);
 }
 
 static void __set_gpo_level_p3(struct lpc32xx_gpio_chip *group,
         unsigned pin, int high)
 {
         if (high)
-                __raw_writel(GPO3_PIN_TO_BIT(pin), group->gpio_grp->outp_set);
+                gpreg_write(group, GPO3_PIN_TO_BIT(pin), group->gpio_grp->outp_set);
         else
-                __raw_writel(GPO3_PIN_TO_BIT(pin), group->gpio_grp->outp_clr);
+                gpreg_write(group, GPO3_PIN_TO_BIT(pin), group->gpio_grp->outp_clr);
 }
 
 static int __get_gpio_state_p012(struct lpc32xx_gpio_chip *group,
         unsigned pin)
 {
-        return GPIO012_PIN_IN_SEL(__raw_readl(group->gpio_grp->inp_state),
+        return GPIO012_PIN_IN_SEL(gpreg_read(group, group->gpio_grp->inp_state),
                 pin);
 }
 
 static int __get_gpio_state_p3(struct lpc32xx_gpio_chip *group,
         unsigned pin)
 {
-        int state = __raw_readl(group->gpio_grp->inp_state);
+        int state = gpreg_read(group, group->gpio_grp->inp_state);
 
         /*
          * P3 GPIO pin input mapping is not contiguous, GPIOP3-0..4 is mapped
@@ -242,13 +250,13 @@ static int __get_gpio_state_p3(struct lpc32xx_gpio_chip *group,
 static int __get_gpi_state_p3(struct lpc32xx_gpio_chip *group,
         unsigned pin)
 {
-        return GPI3_PIN_IN_SEL(__raw_readl(group->gpio_grp->inp_state), pin);
+        return GPI3_PIN_IN_SEL(gpreg_read(group, group->gpio_grp->inp_state), pin);
 }
 
 static int __get_gpo_state_p3(struct lpc32xx_gpio_chip *group,
         unsigned pin)
 {
-        return GPO3_PIN_IN_SEL(__raw_readl(group->gpio_grp->outp_state), pin);
+        return GPO3_PIN_IN_SEL(gpreg_read(group, group->gpio_grp->outp_state), pin);
 }
 
 /*
@@ -497,12 +505,18 @@ static int lpc32xx_of_xlate(struct gpio_chip *gc,
 static int lpc32xx_gpio_probe(struct platform_device *pdev)
 {
         int i;
+        void __iomem *reg_base;
+
+        reg_base = devm_platform_ioremap_resource(pdev, 0);
+        if (IS_ERR(reg_base))
+                return PTR_ERR(reg_base);
 
         for (i = 0; i < ARRAY_SIZE(lpc32xx_gpiochip); i++) {
                 if (pdev->dev.of_node) {
                         lpc32xx_gpiochip[i].chip.of_xlate = lpc32xx_of_xlate;
                         lpc32xx_gpiochip[i].chip.of_gpio_n_cells = 3;
                         lpc32xx_gpiochip[i].chip.of_node = pdev->dev.of_node;
+                        lpc32xx_gpiochip[i].reg_base = reg_base;
                 }
                 devm_gpiochip_add_data(&pdev->dev, &lpc32xx_gpiochip[i].chip,
                                   &lpc32xx_gpiochip[i]);
@@ -527,3 +541,7 @@ static struct platform_driver lpc32xx_gpio_driver = {
 };
 
 module_platform_driver(lpc32xx_gpio_driver);
+
+MODULE_AUTHOR("Kevin Wells <kevin.wells@nxp.com>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("GPIO driver for LPC32xx SoC");
diff --git a/drivers/gpio/gpio-mxc.c b/drivers/gpio/gpio-mxc.c
index b2813580c582..7907a8755866 100644
--- a/drivers/gpio/gpio-mxc.c
+++ b/drivers/gpio/gpio-mxc.c
@@ -435,12 +435,9 @@ static int mxc_gpio_probe(struct platform_device *pdev)
                 return port->irq;
 
         /* the controller clock is optional */
-        port->clk = devm_clk_get(&pdev->dev, NULL);
-        if (IS_ERR(port->clk)) {
-                if (PTR_ERR(port->clk) == -EPROBE_DEFER)
-                        return -EPROBE_DEFER;
-                port->clk = NULL;
-        }
+        port->clk = devm_clk_get_optional(&pdev->dev, NULL);
+        if (IS_ERR(port->clk))
+                return PTR_ERR(port->clk);
 
         err = clk_prepare_enable(port->clk);
         if (err) {
diff --git a/drivers/gpio/gpio-pca953x.c b/drivers/gpio/gpio-pca953x.c
index 378b206d2dc9..64d02ca60f53 100644
--- a/drivers/gpio/gpio-pca953x.c
+++ b/drivers/gpio/gpio-pca953x.c
@@ -9,6 +9,7 @@
  */
 
 #include <linux/acpi.h>
+#include <linux/bits.h>
 #include <linux/gpio/driver.h>
 #include <linux/gpio/consumer.h>
 #include <linux/i2c.h>
@@ -28,9 +29,9 @@
 #define PCA953X_INVERT          0x02
 #define PCA953X_DIRECTION       0x03
 
-#define REG_ADDR_MASK           0x3f
-#define REG_ADDR_EXT            0x40
-#define REG_ADDR_AI             0x80
+#define REG_ADDR_MASK           GENMASK(5, 0)
+#define REG_ADDR_EXT            BIT(6)
+#define REG_ADDR_AI             BIT(7)
 
 #define PCA957X_IN              0x00
 #define PCA957X_INVRT           0x01
@@ -55,17 +56,17 @@
 #define PCAL6524_OUT_INDCONF    0x2c
 #define PCAL6524_DEBOUNCE       0x2d
 
-#define PCA_GPIO_MASK           0x00FF
+#define PCA_GPIO_MASK           GENMASK(7, 0)
 
-#define PCAL_GPIO_MASK          0x1f
-#define PCAL_PINCTRL_MASK       0x60
+#define PCAL_GPIO_MASK          GENMASK(4, 0)
+#define PCAL_PINCTRL_MASK       GENMASK(6, 5)
 
-#define PCA_INT                 0x0100
-#define PCA_PCAL                0x0200
+#define PCA_INT                 BIT(8)
+#define PCA_PCAL                BIT(9)
 #define PCA_LATCH_INT           (PCA_PCAL | PCA_INT)
-#define PCA953X_TYPE            0x1000
-#define PCA957X_TYPE            0x2000
-#define PCA_TYPE_MASK           0xF000
+#define PCA953X_TYPE            BIT(12)
+#define PCA957X_TYPE            BIT(13)
+#define PCA_TYPE_MASK           GENMASK(15, 12)
 
 #define PCA_CHIP_TYPE(x)        ((x) & PCA_TYPE_MASK)
 
@@ -565,7 +566,7 @@ static void pca953x_irq_mask(struct irq_data *d)
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
         struct pca953x_chip *chip = gpiochip_get_data(gc);
 
-        chip->irq_mask[d->hwirq / BANK_SZ] &= ~(1 << (d->hwirq % BANK_SZ));
+        chip->irq_mask[d->hwirq / BANK_SZ] &= ~BIT(d->hwirq % BANK_SZ);
 }
 
 static void pca953x_irq_unmask(struct irq_data *d)
@@ -573,7 +574,7 @@ static void pca953x_irq_unmask(struct irq_data *d)
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
         struct pca953x_chip *chip = gpiochip_get_data(gc);
 
-        chip->irq_mask[d->hwirq / BANK_SZ] |= 1 << (d->hwirq % BANK_SZ);
+        chip->irq_mask[d->hwirq / BANK_SZ] |= BIT(d->hwirq % BANK_SZ);
 }
 
 static int pca953x_irq_set_wake(struct irq_data *d, unsigned int on)
@@ -641,7 +642,7 @@ static int pca953x_irq_set_type(struct irq_data *d, unsigned int type)
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
         struct pca953x_chip *chip = gpiochip_get_data(gc);
         int bank_nb = d->hwirq / BANK_SZ;
-        u8 mask = 1 << (d->hwirq % BANK_SZ);
+        u8 mask = BIT(d->hwirq % BANK_SZ);
 
         if (!(type & IRQ_TYPE_EDGE_BOTH)) {
                 dev_err(&chip->client->dev, "irq %d: unsupported type %d\n",
@@ -666,7 +667,7 @@ static void pca953x_irq_shutdown(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
         struct pca953x_chip *chip = gpiochip_get_data(gc);
-        u8 mask = 1 << (d->hwirq % BANK_SZ);
+        u8 mask = BIT(d->hwirq % BANK_SZ);
 
         chip->irq_trig_raise[d->hwirq / BANK_SZ] &= ~mask;
         chip->irq_trig_fall[d->hwirq / BANK_SZ] &= ~mask;
@@ -849,12 +850,12 @@ static int device_pca95xx_init(struct pca953x_chip *chip, u32 invert)
 
         ret = regcache_sync_region(chip->regmap, chip->regs->output,
                                    chip->regs->output + NBANK(chip));
-        if (ret != 0)
+        if (ret)
                 goto out;
 
         ret = regcache_sync_region(chip->regmap, chip->regs->direction,
                                    chip->regs->direction + NBANK(chip));
-        if (ret != 0)
+        if (ret)
                 goto out;
 
         /* set platform specific polarity inversion */
@@ -949,19 +950,15 @@ static int pca953x_probe(struct i2c_client *client,
         if (i2c_id) {
                 chip->driver_data = i2c_id->driver_data;
         } else {
-                const struct acpi_device_id *acpi_id;
-                struct device *dev = &client->dev;
-
-                chip->driver_data = (uintptr_t)of_device_get_match_data(dev);
-                if (!chip->driver_data) {
-                        acpi_id = acpi_match_device(pca953x_acpi_ids, dev);
-                        if (!acpi_id) {
-                                ret = -ENODEV;
-                                goto err_exit;
-                        }
-
-                        chip->driver_data = acpi_id->driver_data;
+                const void *match;
+
+                match = device_get_match_data(&client->dev);
+                if (!match) {
+                        ret = -ENODEV;
+                        goto err_exit;
                 }
+
+                chip->driver_data = (uintptr_t)match;
         }
 
         i2c_set_clientdata(client, chip);
@@ -1041,8 +1038,7 @@ static int pca953x_remove(struct i2c_client *client)
                 ret = pdata->teardown(client, chip->gpio_chip.base,
                                 chip->gpio_chip.ngpio, pdata->context);
                 if (ret < 0)
-                        dev_err(&client->dev, "%s failed, %d\n",
-                                        "teardown", ret);
+                        dev_err(&client->dev, "teardown failed, %d\n", ret);
         } else {
                 ret = 0;
         }
@@ -1064,14 +1060,14 @@ static int pca953x_regcache_sync(struct device *dev)
          */
         ret = regcache_sync_region(chip->regmap, chip->regs->direction,
                                    chip->regs->direction + NBANK(chip));
-        if (ret != 0) {
+        if (ret) {
                 dev_err(dev, "Failed to sync GPIO dir registers: %d\n", ret);
                 return ret;
         }
 
         ret = regcache_sync_region(chip->regmap, chip->regs->output,
                                    chip->regs->output + NBANK(chip));
-        if (ret != 0) {
+        if (ret) {
                 dev_err(dev, "Failed to sync GPIO out registers: %d\n", ret);
                 return ret;
         }
@@ -1080,7 +1076,7 @@ static int pca953x_regcache_sync(struct device *dev)
         if (chip->driver_data & PCA_PCAL) {
                 ret = regcache_sync_region(chip->regmap, PCAL953X_IN_LATCH,
                                            PCAL953X_IN_LATCH + NBANK(chip));
-                if (ret != 0) {
+                if (ret) {
                         dev_err(dev, "Failed to sync INT latch registers: %d\n",
                                 ret);
                         return ret;
@@ -1088,7 +1084,7 @@ static int pca953x_regcache_sync(struct device *dev)
 
                 ret = regcache_sync_region(chip->regmap, PCAL953X_INT_MASK,
                                            PCAL953X_INT_MASK + NBANK(chip));
-                if (ret != 0) {
+                if (ret) {
                         dev_err(dev, "Failed to sync INT mask registers: %d\n",
                                 ret);
                         return ret;
@@ -1120,7 +1116,7 @@ static int pca953x_resume(struct device *dev)
 
         if (!atomic_read(&chip->wakeup_path)) {
                 ret = regulator_enable(chip->regulator);
-                if (ret != 0) {
+                if (ret) {
                         dev_err(dev, "Failed to enable regulator: %d\n", ret);
                         return 0;
                 }
@@ -1133,7 +1129,7 @@ static int pca953x_resume(struct device *dev)
                 return ret;
 
         ret = regcache_sync(chip->regmap);
-        if (ret != 0) {
+        if (ret) {
                 dev_err(dev, "Failed to restore register map: %d\n", ret);
                 return ret;
         }