From nobody Fri Apr 17 23:52:39 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B6B20CCA485 for ; Wed, 20 Jul 2022 13:46:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239653AbiGTNqV (ORCPT ); Wed, 20 Jul 2022 09:46:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38778 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S238734AbiGTNqN (ORCPT ); Wed, 20 Jul 2022 09:46:13 -0400 Received: from mail-qk1-x731.google.com (mail-qk1-x731.google.com [IPv6:2607:f8b0:4864:20::731]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 150DF3ED6E for ; Wed, 20 Jul 2022 06:46:12 -0700 (PDT) Received: by mail-qk1-x731.google.com with SMTP id g1so12853756qki.7 for ; Wed, 20 Jul 2022 06:46:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=rJqWp+udTO0Z1cqQdPtymTtYII3QhZ3OpR+pl1jwWrE=; b=bbkc1RXc6gPBCpZhVQ6mD/NVoSvR8+fFUv6HFpiDG8dO7L4hclWPKP3n84Im5t+6CM oQ5FvRG94yRKWdutX8kds0Jg4FvU9DrrHW4Ldv8xO1C9tnMTdBjyriUvcs4hx3KazRe2 B0YLgXyWG649Iw2STVv3IWDcl7YaBaJPCki6VTjscc8HC3GseTCiqlN8DjbIKaaiD3or zCB+c2d/u9aNJ7OGokjhukxpScTenaIKzAO7KTlznXcOD+dabR6pu14J1/bHDD9+87CP sUVy0tHiumqnjCvJj83pp1XDacskS+LPuDhy7f9THGyZUY/b/sQRu+CQ/cLgLt7/pfwV VaIQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=rJqWp+udTO0Z1cqQdPtymTtYII3QhZ3OpR+pl1jwWrE=; b=6rebbwa6JF9dhb52Mw24fGvGVyo1hByuQ6pGhly7rkSR7dNLeCztkgXSZp0CKMgyOG XVctJQGzSuPC4Ef2LM7yglzsB8wa2qxQeVPT17wrq0Qom7NjCsxn8qTwISfgPjlwDJTE Bzfh721bvKscq/1953bfOu84c+5/rMURiJw1qpWDRWLfPYbI+UtjJyLMAR3rBgkbd406 MoJSgT2Ppt5HqnNkVlN8lBaDnDY8agypWo5ZqoP7mnfZCwciPSYXS20O8uL2UYVcZ4z1 uTSizONcd7etczncCvmBdk/x2Gei5JCAo06rC/9F5o3vYmGoqCysuuwbX+dd+igkIc6c JVHg== X-Gm-Message-State: AJIora+CpllqmWmIAv72OjoLdw1l0rnxnXH8xdhDRavPdUywRNjPdyAJ UHl+TA1WA6AB9C42dsXcRfahxM/0aIU9Cw== X-Google-Smtp-Source: AGRyM1tFtjEsMsxt0GIZyXaf6U4f8oBGFTzUmzn8GD1h3YpTJRUzBrhh9kEjPgKuw3aqBSzoJ+f6JQ== X-Received: by 2002:a05:620a:1ed:b0:6b5:51ef:a01b with SMTP id x13-20020a05620a01ed00b006b551efa01bmr24654360qkn.672.1658324771184; Wed, 20 Jul 2022 06:46:11 -0700 (PDT) Received: from fedora.attlocal.net (69-109-179-158.lightspeed.dybhfl.sbcglobal.net. [69.109.179.158]) by smtp.gmail.com with ESMTPSA id bl13-20020a05620a1a8d00b006b5f8f32a8fsm5289853qkb.114.2022.07.20.06.46.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 20 Jul 2022 06:46:10 -0700 (PDT) From: William Breathitt Gray To: linus.walleij@linaro.org, brgl@bgdev.pl Cc: linux-gpio@vger.kernel.org, linux-kernel@vger.kernel.org, William Breathitt Gray , Paul Demetrotion Subject: [RESEND PATCH v4 1/6] gpio: ws16c48: Implement and utilize register structures Date: Wed, 20 Jul 2022 09:45:57 -0400 Message-Id: <1e78f806244495a6996c803af9452745bf6da1dd.1658324498.git.william.gray@linaro.org> X-Mailer: git-send-email 2.36.1 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Reduce magic numbers and improve code readability by implementing and utilizing named register data structures. Reviewed-by: Linus Walleij Cc: Paul Demetrotion Signed-off-by: William Breathitt Gray --- Changes in v4: - Remove superfluous include drivers/gpio/gpio-ws16c48.c | 120 +++++++++++++++++++++++++----------- 1 file changed, 84 insertions(+), 36 deletions(-) diff --git a/drivers/gpio/gpio-ws16c48.c b/drivers/gpio/gpio-ws16c48.c index 5078631d8014..b098f2dc196b 100644 --- a/drivers/gpio/gpio-ws16c48.c +++ b/drivers/gpio/gpio-ws16c48.c @@ -4,7 +4,6 @@ * Copyright (C) 2016 William Breathitt Gray */ #include -#include #include #include #include @@ -17,8 +16,9 @@ #include #include #include +#include =20 -#define WS16C48_EXTENT 16 +#define WS16C48_EXTENT 10 #define MAX_NUM_WS16C48 max_num_isa_dev(WS16C48_EXTENT) =20 static unsigned int base[MAX_NUM_WS16C48]; @@ -30,6 +30,20 @@ static unsigned int irq[MAX_NUM_WS16C48]; module_param_hw_array(irq, uint, irq, NULL, 0); MODULE_PARM_DESC(irq, "WinSystems WS16C48 interrupt line numbers"); =20 +/** + * struct ws16c48_reg - device register structure + * @port: Port 0 through 5 I/O + * @int_pending: Interrupt Pending + * @page_lock: Register page (Bits 7-6) and I/O port lock (Bits 5-0) + * @pol_enab_int_id: Interrupt polarity, enable, and ID + */ +struct ws16c48_reg { + u8 port[6]; + u8 int_pending; + u8 page_lock; + u8 pol_enab_int_id[3]; +}; + /** * struct ws16c48_gpio - GPIO device private data structure * @chip: instance of the gpio_chip @@ -38,7 +52,7 @@ MODULE_PARM_DESC(irq, "WinSystems WS16C48 interrupt line = numbers"); * @lock: synchronization lock to prevent I/O race conditions * @irq_mask: I/O bits affected by interrupts * @flow_mask: IRQ flow type mask for the respective I/O bits - * @base: base port address of the GPIO device + * @reg: I/O address offset for the device registers */ struct ws16c48_gpio { struct gpio_chip chip; @@ -47,7 +61,7 @@ struct ws16c48_gpio { raw_spinlock_t lock; unsigned long irq_mask; unsigned long flow_mask; - void __iomem *base; + struct ws16c48_reg __iomem *reg; }; =20 static int ws16c48_gpio_get_direction(struct gpio_chip *chip, unsigned off= set) @@ -73,7 +87,7 @@ static int ws16c48_gpio_direction_input(struct gpio_chip = *chip, unsigned offset) =20 ws16c48gpio->io_state[port] |=3D mask; ws16c48gpio->out_state[port] &=3D ~mask; - iowrite8(ws16c48gpio->out_state[port], ws16c48gpio->base + port); + iowrite8(ws16c48gpio->out_state[port], ws16c48gpio->reg->port + port); =20 raw_spin_unlock_irqrestore(&ws16c48gpio->lock, flags); =20 @@ -95,7 +109,7 @@ static int ws16c48_gpio_direction_output(struct gpio_chi= p *chip, ws16c48gpio->out_state[port] |=3D mask; else ws16c48gpio->out_state[port] &=3D ~mask; - iowrite8(ws16c48gpio->out_state[port], ws16c48gpio->base + port); + iowrite8(ws16c48gpio->out_state[port], ws16c48gpio->reg->port + port); =20 raw_spin_unlock_irqrestore(&ws16c48gpio->lock, flags); =20 @@ -118,7 +132,7 @@ static int ws16c48_gpio_get(struct gpio_chip *chip, uns= igned offset) return -EINVAL; } =20 - port_state =3D ioread8(ws16c48gpio->base + port); + port_state =3D ioread8(ws16c48gpio->reg->port + port); =20 raw_spin_unlock_irqrestore(&ws16c48gpio->lock, flags); =20 @@ -131,14 +145,16 @@ static int ws16c48_gpio_get_multiple(struct gpio_chip= *chip, struct ws16c48_gpio *const ws16c48gpio =3D gpiochip_get_data(chip); unsigned long offset; unsigned long gpio_mask; - void __iomem *port_addr; + size_t index; + u8 __iomem *port_addr; unsigned long port_state; =20 /* clear bits array to a clean slate */ bitmap_zero(bits, chip->ngpio); =20 for_each_set_clump8(offset, gpio_mask, mask, chip->ngpio) { - port_addr =3D ws16c48gpio->base + offset / 8; + index =3D offset / 8; + port_addr =3D ws16c48gpio->reg->port + index; port_state =3D ioread8(port_addr) & gpio_mask; =20 bitmap_set_value8(bits, port_state, offset); @@ -166,7 +182,7 @@ static void ws16c48_gpio_set(struct gpio_chip *chip, un= signed offset, int value) ws16c48gpio->out_state[port] |=3D mask; else ws16c48gpio->out_state[port] &=3D ~mask; - iowrite8(ws16c48gpio->out_state[port], ws16c48gpio->base + port); + iowrite8(ws16c48gpio->out_state[port], ws16c48gpio->reg->port + port); =20 raw_spin_unlock_irqrestore(&ws16c48gpio->lock, flags); } @@ -178,13 +194,13 @@ static void ws16c48_gpio_set_multiple(struct gpio_chi= p *chip, unsigned long offset; unsigned long gpio_mask; size_t index; - void __iomem *port_addr; + u8 __iomem *port_addr; unsigned long bitmask; unsigned long flags; =20 for_each_set_clump8(offset, gpio_mask, mask, chip->ngpio) { index =3D offset / 8; - port_addr =3D ws16c48gpio->base + index; + port_addr =3D ws16c48gpio->reg->port + index; =20 /* mask out GPIO configured for input */ gpio_mask &=3D ~ws16c48gpio->io_state[index]; @@ -219,10 +235,15 @@ static void ws16c48_irq_ack(struct irq_data *data) =20 port_state =3D ws16c48gpio->irq_mask >> (8*port); =20 - iowrite8(0x80, ws16c48gpio->base + 7); - iowrite8(port_state & ~mask, ws16c48gpio->base + 8 + port); - iowrite8(port_state | mask, ws16c48gpio->base + 8 + port); - iowrite8(0xC0, ws16c48gpio->base + 7); + /* Select Register Page 2; Unlock all I/O ports */ + iowrite8(0x80, &ws16c48gpio->reg->page_lock); + + /* Clear pending interrupt */ + iowrite8(port_state & ~mask, ws16c48gpio->reg->pol_enab_int_id + port); + iowrite8(port_state | mask, ws16c48gpio->reg->pol_enab_int_id + port); + + /* Select Register Page 3; Unlock all I/O ports */ + iowrite8(0xC0, &ws16c48gpio->reg->page_lock); =20 raw_spin_unlock_irqrestore(&ws16c48gpio->lock, flags); } @@ -235,6 +256,7 @@ static void ws16c48_irq_mask(struct irq_data *data) const unsigned long mask =3D BIT(offset); const unsigned port =3D offset / 8; unsigned long flags; + unsigned long port_state; =20 /* only the first 3 ports support interrupts */ if (port > 2) @@ -243,10 +265,16 @@ static void ws16c48_irq_mask(struct irq_data *data) raw_spin_lock_irqsave(&ws16c48gpio->lock, flags); =20 ws16c48gpio->irq_mask &=3D ~mask; + port_state =3D ws16c48gpio->irq_mask >> (8 * port); + + /* Select Register Page 2; Unlock all I/O ports */ + iowrite8(0x80, &ws16c48gpio->reg->page_lock); =20 - iowrite8(0x80, ws16c48gpio->base + 7); - iowrite8(ws16c48gpio->irq_mask >> (8*port), ws16c48gpio->base + 8 + port); - iowrite8(0xC0, ws16c48gpio->base + 7); + /* Disable interrupt */ + iowrite8(port_state, ws16c48gpio->reg->pol_enab_int_id + port); + + /* Select Register Page 3; Unlock all I/O ports */ + iowrite8(0xC0, &ws16c48gpio->reg->page_lock); =20 raw_spin_unlock_irqrestore(&ws16c48gpio->lock, flags); } @@ -259,6 +287,7 @@ static void ws16c48_irq_unmask(struct irq_data *data) const unsigned long mask =3D BIT(offset); const unsigned port =3D offset / 8; unsigned long flags; + unsigned long port_state; =20 /* only the first 3 ports support interrupts */ if (port > 2) @@ -267,10 +296,16 @@ static void ws16c48_irq_unmask(struct irq_data *data) raw_spin_lock_irqsave(&ws16c48gpio->lock, flags); =20 ws16c48gpio->irq_mask |=3D mask; + port_state =3D ws16c48gpio->irq_mask >> (8 * port); + + /* Select Register Page 2; Unlock all I/O ports */ + iowrite8(0x80, &ws16c48gpio->reg->page_lock); =20 - iowrite8(0x80, ws16c48gpio->base + 7); - iowrite8(ws16c48gpio->irq_mask >> (8*port), ws16c48gpio->base + 8 + port); - iowrite8(0xC0, ws16c48gpio->base + 7); + /* Enable interrupt */ + iowrite8(port_state, ws16c48gpio->reg->pol_enab_int_id + port); + + /* Select Register Page 3; Unlock all I/O ports */ + iowrite8(0xC0, &ws16c48gpio->reg->page_lock); =20 raw_spin_unlock_irqrestore(&ws16c48gpio->lock, flags); } @@ -283,6 +318,7 @@ static int ws16c48_irq_set_type(struct irq_data *data, = unsigned flow_type) const unsigned long mask =3D BIT(offset); const unsigned port =3D offset / 8; unsigned long flags; + unsigned long port_state; =20 /* only the first 3 ports support interrupts */ if (port > 2) @@ -304,9 +340,16 @@ static int ws16c48_irq_set_type(struct irq_data *data,= unsigned flow_type) return -EINVAL; } =20 - iowrite8(0x40, ws16c48gpio->base + 7); - iowrite8(ws16c48gpio->flow_mask >> (8*port), ws16c48gpio->base + 8 + port= ); - iowrite8(0xC0, ws16c48gpio->base + 7); + port_state =3D ws16c48gpio->flow_mask >> (8 * port); + + /* Select Register Page 1; Unlock all I/O ports */ + iowrite8(0x40, &ws16c48gpio->reg->page_lock); + + /* Set interrupt polarity */ + iowrite8(port_state, ws16c48gpio->reg->pol_enab_int_id + port); + + /* Select Register Page 3; Unlock all I/O ports */ + iowrite8(0xC0, &ws16c48gpio->reg->page_lock); =20 raw_spin_unlock_irqrestore(&ws16c48gpio->lock, flags); =20 @@ -325,25 +368,26 @@ static irqreturn_t ws16c48_irq_handler(int irq, void = *dev_id) { struct ws16c48_gpio *const ws16c48gpio =3D dev_id; struct gpio_chip *const chip =3D &ws16c48gpio->chip; + struct ws16c48_reg __iomem *const reg =3D ws16c48gpio->reg; unsigned long int_pending; unsigned long port; unsigned long int_id; unsigned long gpio; =20 - int_pending =3D ioread8(ws16c48gpio->base + 6) & 0x7; + int_pending =3D ioread8(®->int_pending) & 0x7; if (!int_pending) return IRQ_NONE; =20 /* loop until all pending interrupts are handled */ do { for_each_set_bit(port, &int_pending, 3) { - int_id =3D ioread8(ws16c48gpio->base + 8 + port); + int_id =3D ioread8(reg->pol_enab_int_id + port); for_each_set_bit(gpio, &int_id, 8) generic_handle_domain_irq(chip->irq.domain, gpio + 8*port); } =20 - int_pending =3D ioread8(ws16c48gpio->base + 6) & 0x7; + int_pending =3D ioread8(®->int_pending) & 0x7; } while (int_pending); =20 return IRQ_HANDLED; @@ -369,12 +413,16 @@ static int ws16c48_irq_init_hw(struct gpio_chip *gc) { struct ws16c48_gpio *const ws16c48gpio =3D gpiochip_get_data(gc); =20 - /* Disable IRQ by default */ - iowrite8(0x80, ws16c48gpio->base + 7); - iowrite8(0, ws16c48gpio->base + 8); - iowrite8(0, ws16c48gpio->base + 9); - iowrite8(0, ws16c48gpio->base + 10); - iowrite8(0xC0, ws16c48gpio->base + 7); + /* Select Register Page 2; Unlock all I/O ports */ + iowrite8(0x80, &ws16c48gpio->reg->page_lock); + + /* Disable interrupts for all lines */ + iowrite8(0, &ws16c48gpio->reg->pol_enab_int_id[0]); + iowrite8(0, &ws16c48gpio->reg->pol_enab_int_id[1]); + iowrite8(0, &ws16c48gpio->reg->pol_enab_int_id[2]); + + /* Select Register Page 3; Unlock all I/O ports */ + iowrite8(0xC0, &ws16c48gpio->reg->page_lock); =20 return 0; } @@ -396,8 +444,8 @@ static int ws16c48_probe(struct device *dev, unsigned i= nt id) return -EBUSY; } =20 - ws16c48gpio->base =3D devm_ioport_map(dev, base[id], WS16C48_EXTENT); - if (!ws16c48gpio->base) + ws16c48gpio->reg =3D devm_ioport_map(dev, base[id], WS16C48_EXTENT); + if (!ws16c48gpio->reg) return -ENOMEM; =20 ws16c48gpio->chip.label =3D name; --=20 2.36.1 From nobody Fri Apr 17 23:52:39 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id F3597C433EF for ; Wed, 20 Jul 2022 13:46:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S238989AbiGTNq0 (ORCPT ); Wed, 20 Jul 2022 09:46:26 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38810 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239036AbiGTNqP (ORCPT ); Wed, 20 Jul 2022 09:46:15 -0400 Received: from mail-qk1-x735.google.com (mail-qk1-x735.google.com [IPv6:2607:f8b0:4864:20::735]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 26293564C2 for ; Wed, 20 Jul 2022 06:46:13 -0700 (PDT) Received: by mail-qk1-x735.google.com with SMTP id o1so13639328qkg.9 for ; Wed, 20 Jul 2022 06:46:13 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=vlq7M6D1RgY2JkdmVKHZ7KjiNHRg1IRrY27s7K5hCY8=; b=aLvTOabHg3I4O45W/B22dM5QNdw7yK9FFTg8gxNzE1Z73RZeekYfDopSWikaqmeP4U qNDZqPDMeLOtS48YDyB9tSHSYxJCywnwBNzsehRzTymI4P2Ij2D+DJe70p6my7hMRFk1 uNCP7YES0ZUc97Xb3EOYIhYrs2j/pymiHfK5B3Js/m1eWxPPuQ4WNWNzPzf7OoDObqEL TZRHN6mbBdPOTlkDjvZqWVwFUHDttrK1HT6MjdSwFLhh3Dm7KPG6tMR0cSH47C30ksHx Fu9F02doCcOUikOLrWrZ/WROoLpJkrCNhq4VYBQeI0FAIDdQLejC57ZZRGFTwv9L7ZOh LhxQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=vlq7M6D1RgY2JkdmVKHZ7KjiNHRg1IRrY27s7K5hCY8=; b=xnJ7E9UNFGV+rGF9SlUGjznJZLLkCyEkDc5uoS3KJ3ZFJr65ZXhQdjRGSxpzG+nK/o 57wdax8t+el3rJ1lf+0GG9ps9TZ+TCi6YMyItkjUeFfTqJmfzrRYcXsOgA9cnQzGBKNR kJ8+2/VN6mKB4QbBJVxrJItaOqAVM9GUbnuFFFSFjEz5WnHdRVfrZpyBXTOeclBtjP7D S6n5meNNekK0S+UlGITmm4ugKc23MBMl5JwPCMWGXxxAA3WMF0fGhK43vBQP8vc1mSss XVV4CgPEPdF6un6oGCq7hmhKiea8g7W6btP6fUwDutNiPC2BOHX4hxi9Zi37u8nUF00u rtdQ== X-Gm-Message-State: AJIora+yKLgZL3CQ3AXkmukQNTYBHlq7890hfJcPdkNnHJ/e3X3zP3kV 5YVM6x0+DCqrPs9h0hXQsYK/r+QmCVuNwQ== X-Google-Smtp-Source: AGRyM1urUwvhh+4elSRnmsBL8N9rv/WFY8C2Vs9O3bozqPvlj6Fhp5JBBr+RckufX5jPcTerRMKSmw== X-Received: by 2002:a05:620a:31a4:b0:6b5:fe46:c84a with SMTP id bi36-20020a05620a31a400b006b5fe46c84amr5725569qkb.433.1658324771945; Wed, 20 Jul 2022 06:46:11 -0700 (PDT) Received: from fedora.attlocal.net (69-109-179-158.lightspeed.dybhfl.sbcglobal.net. [69.109.179.158]) by smtp.gmail.com with ESMTPSA id bl13-20020a05620a1a8d00b006b5f8f32a8fsm5289853qkb.114.2022.07.20.06.46.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 20 Jul 2022 06:46:11 -0700 (PDT) From: William Breathitt Gray To: linus.walleij@linaro.org, brgl@bgdev.pl Cc: linux-gpio@vger.kernel.org, linux-kernel@vger.kernel.org, William Breathitt Gray , Fred Eckert , John Hentges , Jay Dolan Subject: [RESEND PATCH v4 2/6] gpio: 104-idio-16: Implement and utilize register structures Date: Wed, 20 Jul 2022 09:45:58 -0400 Message-Id: <6f937754757cefe06ab7ee4adeace9379e29cf63.1658324498.git.william.gray@linaro.org> X-Mailer: git-send-email 2.36.1 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Reduce magic numbers and improve code readability by implementing and utilizing named register data structures. Tested-by: Fred Eckert Reviewed-by: Linus Walleij Cc: John Hentges Cc: Jay Dolan Signed-off-by: William Breathitt Gray --- Changes in v4: - Replace superfluous include with drivers/gpio/gpio-104-idio-16.c | 60 +++++++++++++++++++++++---------- 1 file changed, 42 insertions(+), 18 deletions(-) diff --git a/drivers/gpio/gpio-104-idio-16.c b/drivers/gpio/gpio-104-idio-1= 6.c index 45f7ad8573e1..65a5f581d981 100644 --- a/drivers/gpio/gpio-104-idio-16.c +++ b/drivers/gpio/gpio-104-idio-16.c @@ -6,7 +6,7 @@ * This driver supports the following ACCES devices: 104-IDIO-16, * 104-IDIO-16E, 104-IDO-16, 104-IDIO-8, 104-IDIO-8E, and 104-IDO-8. */ -#include +#include #include #include #include @@ -19,6 +19,7 @@ #include #include #include +#include =20 #define IDIO_16_EXTENT 8 #define MAX_NUM_IDIO_16 max_num_isa_dev(IDIO_16_EXTENT) @@ -32,19 +33,42 @@ static unsigned int irq[MAX_NUM_IDIO_16]; module_param_hw_array(irq, uint, irq, NULL, 0); MODULE_PARM_DESC(irq, "ACCES 104-IDIO-16 interrupt line numbers"); =20 +/** + * struct idio_16_reg - device registers structure + * @out0_7: Read: N/A + * Write: FET Drive Outputs 0-7 + * @in0_7: Read: Isolated Inputs 0-7 + * Write: Clear Interrupt + * @irq_ctl: Read: Enable IRQ + * Write: Disable IRQ + * @unused: N/A + * @out8_15: Read: N/A + * Write: FET Drive Outputs 8-15 + * @in8_15: Read: Isolated Inputs 8-15 + * Write: N/A + */ +struct idio_16_reg { + u8 out0_7; + u8 in0_7; + u8 irq_ctl; + u8 unused; + u8 out8_15; + u8 in8_15; +}; + /** * struct idio_16_gpio - GPIO device private data structure * @chip: instance of the gpio_chip * @lock: synchronization lock to prevent I/O race conditions * @irq_mask: I/O bits affected by interrupts - * @base: base port address of the GPIO device + * @reg: I/O address offset for the device registers * @out_state: output bits state */ struct idio_16_gpio { struct gpio_chip chip; raw_spinlock_t lock; unsigned long irq_mask; - void __iomem *base; + struct idio_16_reg __iomem *reg; unsigned int out_state; }; =20 @@ -79,9 +103,9 @@ static int idio_16_gpio_get(struct gpio_chip *chip, unsi= gned int offset) return -EINVAL; =20 if (offset < 24) - return !!(ioread8(idio16gpio->base + 1) & mask); + return !!(ioread8(&idio16gpio->reg->in0_7) & mask); =20 - return !!(ioread8(idio16gpio->base + 5) & (mask>>8)); + return !!(ioread8(&idio16gpio->reg->in8_15) & (mask>>8)); } =20 static int idio_16_gpio_get_multiple(struct gpio_chip *chip, @@ -91,9 +115,9 @@ static int idio_16_gpio_get_multiple(struct gpio_chip *c= hip, =20 *bits =3D 0; if (*mask & GENMASK(23, 16)) - *bits |=3D (unsigned long)ioread8(idio16gpio->base + 1) << 16; + *bits |=3D (unsigned long)ioread8(&idio16gpio->reg->in0_7) << 16; if (*mask & GENMASK(31, 24)) - *bits |=3D (unsigned long)ioread8(idio16gpio->base + 5) << 24; + *bits |=3D (unsigned long)ioread8(&idio16gpio->reg->in8_15) << 24; =20 return 0; } @@ -116,9 +140,9 @@ static void idio_16_gpio_set(struct gpio_chip *chip, un= signed int offset, idio16gpio->out_state &=3D ~mask; =20 if (offset > 7) - iowrite8(idio16gpio->out_state >> 8, idio16gpio->base + 4); + iowrite8(idio16gpio->out_state >> 8, &idio16gpio->reg->out8_15); else - iowrite8(idio16gpio->out_state, idio16gpio->base); + iowrite8(idio16gpio->out_state, &idio16gpio->reg->out0_7); =20 raw_spin_unlock_irqrestore(&idio16gpio->lock, flags); } @@ -135,9 +159,9 @@ static void idio_16_gpio_set_multiple(struct gpio_chip = *chip, idio16gpio->out_state |=3D *mask & *bits; =20 if (*mask & 0xFF) - iowrite8(idio16gpio->out_state, idio16gpio->base); + iowrite8(idio16gpio->out_state, &idio16gpio->reg->out0_7); if ((*mask >> 8) & 0xFF) - iowrite8(idio16gpio->out_state >> 8, idio16gpio->base + 4); + iowrite8(idio16gpio->out_state >> 8, &idio16gpio->reg->out8_15); =20 raw_spin_unlock_irqrestore(&idio16gpio->lock, flags); } @@ -158,7 +182,7 @@ static void idio_16_irq_mask(struct irq_data *data) if (!idio16gpio->irq_mask) { raw_spin_lock_irqsave(&idio16gpio->lock, flags); =20 - iowrite8(0, idio16gpio->base + 2); + iowrite8(0, &idio16gpio->reg->irq_ctl); =20 raw_spin_unlock_irqrestore(&idio16gpio->lock, flags); } @@ -177,7 +201,7 @@ static void idio_16_irq_unmask(struct irq_data *data) if (!prev_irq_mask) { raw_spin_lock_irqsave(&idio16gpio->lock, flags); =20 - ioread8(idio16gpio->base + 2); + ioread8(&idio16gpio->reg->irq_ctl); =20 raw_spin_unlock_irqrestore(&idio16gpio->lock, flags); } @@ -212,7 +236,7 @@ static irqreturn_t idio_16_irq_handler(int irq, void *d= ev_id) =20 raw_spin_lock(&idio16gpio->lock); =20 - iowrite8(0, idio16gpio->base + 1); + iowrite8(0, &idio16gpio->reg->in0_7); =20 raw_spin_unlock(&idio16gpio->lock); =20 @@ -232,8 +256,8 @@ static int idio_16_irq_init_hw(struct gpio_chip *gc) struct idio_16_gpio *const idio16gpio =3D gpiochip_get_data(gc); =20 /* Disable IRQ by default */ - iowrite8(0, idio16gpio->base + 2); - iowrite8(0, idio16gpio->base + 1); + iowrite8(0, &idio16gpio->reg->irq_ctl); + iowrite8(0, &idio16gpio->reg->in0_7); =20 return 0; } @@ -255,8 +279,8 @@ static int idio_16_probe(struct device *dev, unsigned i= nt id) return -EBUSY; } =20 - idio16gpio->base =3D devm_ioport_map(dev, base[id], IDIO_16_EXTENT); - if (!idio16gpio->base) + idio16gpio->reg =3D devm_ioport_map(dev, base[id], IDIO_16_EXTENT); + if (!idio16gpio->reg) return -ENOMEM; =20 idio16gpio->chip.label =3D name; --=20 2.36.1 From nobody Fri Apr 17 23:52:39 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 77A13C43334 for ; Wed, 20 Jul 2022 13:46:31 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239483AbiGTNq3 (ORCPT ); Wed, 20 Jul 2022 09:46:29 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38860 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S238585AbiGTNqS (ORCPT ); Wed, 20 Jul 2022 09:46:18 -0400 Received: from mail-qk1-x733.google.com (mail-qk1-x733.google.com [IPv6:2607:f8b0:4864:20::733]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8CD7357259 for ; Wed, 20 Jul 2022 06:46:14 -0700 (PDT) Received: by mail-qk1-x733.google.com with SMTP id g1so12853877qki.7 for ; Wed, 20 Jul 2022 06:46:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=4KtnYjVrkGGetCA5EGg8VtLpPVBjo70FhcQsFbEKhB8=; b=kEZM8unKk2r3n0oG3pJqZJ7j1tzFvEUfytKnkpHST259/0+Vj01kIizsT7jjEqjH2f fQGPyJpRAQS/0kxcHsnSwRAmXag8sF8bNSB9ZFCZuHtixGWTTcIw3V1WuzcKaZpLv91L 2rYXbXFwEENovyG8yFVTITBY6v+8m5yHYtuQK4GI/ILvgO4tZNPpJqHwCiMaZCZEhgDU m+W8e4xTSqi88+vGLlC8/h6TrGE/uNp1rzXV18IPWkPAzw7SwW04UDZviuTZ3sq6O+aB Ycv3FcWww/GRjT5yejYZp/MSj7rfh//25Wc23Du4hgPsCgKXtQqQ7HRjCOsiJg0uUXRq jVFw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=4KtnYjVrkGGetCA5EGg8VtLpPVBjo70FhcQsFbEKhB8=; b=aJmIvooMFyd3aoLLtGSz05gvXrUYykge4wC5BFaGoG8IZGS5FxD6H0mVqGIvE3RKYy 75mDLzKwGqtlVe3ApEQNlaK8d7WuOX+wwAzvAaFQHHkniidhkusOpf8UDwgTqvdIwnj3 kt41TRppuXf+rNHhRr3WBCvMShaPuL6+Yx0MDIE1UXYy+Ige258nNiFFff1nPxNLev9D HuI/EiX6sSlq07xFh3Y+IgjwCBekYdy068aeDs6OEvGWwqHP3syALcinIHLFy9lR7wvf 8/CzK5o1Yb40e6d2UclG6cmiMyS7QqXCMmkov8hVpVMxdJTfVLQf1nLPRlm6vEBv9pwv pufA== X-Gm-Message-State: AJIora/zePZBCqkOr4kfrJbeCbjyUnHedqiFoFQp0LVIFZITee6Y3+qW /2mqmpjWWbHJMIlh8WDc3Um2cg== X-Google-Smtp-Source: AGRyM1uODid3TSsBVvhz9mffRFHxz/vzgNioj4PZBmBHD1H58AQqh7+pKBf/vkSR7Po9krBaBiCGGg== X-Received: by 2002:a05:620a:2a0e:b0:6b3:583a:1031 with SMTP id o14-20020a05620a2a0e00b006b3583a1031mr24368629qkp.710.1658324773328; Wed, 20 Jul 2022 06:46:13 -0700 (PDT) Received: from fedora.attlocal.net (69-109-179-158.lightspeed.dybhfl.sbcglobal.net. [69.109.179.158]) by smtp.gmail.com with ESMTPSA id bl13-20020a05620a1a8d00b006b5f8f32a8fsm5289853qkb.114.2022.07.20.06.46.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 20 Jul 2022 06:46:13 -0700 (PDT) From: William Breathitt Gray To: linus.walleij@linaro.org, brgl@bgdev.pl Cc: linux-gpio@vger.kernel.org, linux-kernel@vger.kernel.org, William Breathitt Gray , Fred Eckert , John Hentges , Jay Dolan , Andy Shevchenko Subject: [RESEND PATCH v4 3/6] gpio: i8255: Introduce the Intel 8255 interface library module Date: Wed, 20 Jul 2022 09:45:59 -0400 Message-Id: X-Mailer: git-send-email 2.36.1 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Exposes consumer library functions providing support for interfaces compatible with the venerable Intel 8255 Programmable Peripheral Interface (PPI). The Intel 8255 PPI first appeared in the early 1970s, initially for the Intel 8080 and later appearing in the original IBM-PC. The popularity of the original Intel 8255 chip led to many subsequent variants and clones of the interface in various chips and integrated circuits. Although still popular, interfaces compatible with the Intel 8255 PPI are nowdays typically found embedded in larger VLSI processing chips and FPGA components rather than as discrete ICs. A CONFIG_GPIO_I8255 Kconfig option is introduced by this patch. Modules wanting access to these i8255 library functions should select this Kconfig option, and import the I8255 symbol namespace. Tested-by: Fred Eckert Reviewed-by: Linus Walleij Cc: John Hentges Cc: Jay Dolan Cc: Andy Shevchenko Signed-off-by: William Breathitt Gray --- Changes in v4: - Add note to CONFIG_GPIO_I8255 Kconfig that if built as a module the name will be 'gpio-i8255' - Remove 'const' from '__iomem' pointers - Replace ambiguous 'group' terminology with more understandable 'bank' - Use more natural '>=3D 4' expression to represent upper nibble - Refactor i8255_set_port() to take more common pattern of mask and bits MAINTAINERS | 6 + drivers/gpio/Kconfig | 12 ++ drivers/gpio/Makefile | 1 + drivers/gpio/gpio-i8255.c | 287 ++++++++++++++++++++++++++++++++++++++ drivers/gpio/gpio-i8255.h | 46 ++++++ 5 files changed, 352 insertions(+) create mode 100644 drivers/gpio/gpio-i8255.c create mode 100644 drivers/gpio/gpio-i8255.h diff --git a/MAINTAINERS b/MAINTAINERS index 3405cb36cf02..960abc07304e 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -9902,6 +9902,12 @@ L: linux-fbdev@vger.kernel.org S: Maintained F: drivers/video/fbdev/i810/ =20 +INTEL 8255 GPIO DRIVER +M: William Breathitt Gray +L: linux-gpio@vger.kernel.org +S: Maintained +F: drivers/gpio/gpio-i8255.c + INTEL ASoC DRIVERS M: Cezary Rojewski M: Pierre-Louis Bossart diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index cf6a2c745f3f..df484b72000d 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -824,6 +824,18 @@ endmenu menu "Port-mapped I/O GPIO drivers" depends on X86 # Unconditional I/O space access =20 +config GPIO_I8255 + tristate + help + Enables support for the i8255 interface library functions. The i8255 + interface library provides functions to facilitate communication with + interfaces compatible with the venerable Intel 8255 Programmable + Peripheral Interface (PPI). The Intel 8255 PPI chip was first released + in the early 1970s but compatible interfaces are nowadays typically + found embedded in larger VLSI processing chips and FPGA components. + + If built as a module its name will be gpio-i8255. + config GPIO_104_DIO_48E tristate "ACCES 104-DIO-48E GPIO support" depends on PC104 diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile index 9d4805b2b60b..a0985d30f51b 100644 --- a/drivers/gpio/Makefile +++ b/drivers/gpio/Makefile @@ -67,6 +67,7 @@ obj-$(CONFIG_GPIO_GW_PLD) +=3D gpio-gw-pld.o obj-$(CONFIG_GPIO_HISI) +=3D gpio-hisi.o obj-$(CONFIG_GPIO_HLWD) +=3D gpio-hlwd.o obj-$(CONFIG_HTC_EGPIO) +=3D gpio-htc-egpio.o +obj-$(CONFIG_GPIO_I8255) +=3D gpio-i8255.o obj-$(CONFIG_GPIO_ICH) +=3D gpio-ich.o obj-$(CONFIG_GPIO_IDT3243X) +=3D gpio-idt3243x.o obj-$(CONFIG_GPIO_IOP) +=3D gpio-iop.o diff --git a/drivers/gpio/gpio-i8255.c b/drivers/gpio/gpio-i8255.c new file mode 100644 index 000000000000..9b97db418df1 --- /dev/null +++ b/drivers/gpio/gpio-i8255.c @@ -0,0 +1,287 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Intel 8255 Programmable Peripheral Interface + * Copyright (C) 2022 William Breathitt Gray + */ +#include +#include +#include +#include +#include +#include +#include + +#include "gpio-i8255.h" + +#define I8255_CONTROL_PORTC_LOWER_DIRECTION BIT(0) +#define I8255_CONTROL_PORTB_DIRECTION BIT(1) +#define I8255_CONTROL_PORTC_UPPER_DIRECTION BIT(3) +#define I8255_CONTROL_PORTA_DIRECTION BIT(4) +#define I8255_CONTROL_MODE_SET BIT(7) +#define I8255_PORTA 0 +#define I8255_PORTB 1 +#define I8255_PORTC 2 + +static int i8255_get_port(struct i8255 __iomem *const ppi, + const unsigned long io_port, const unsigned long mask) +{ + const unsigned long bank =3D io_port / 3; + const unsigned long ppi_port =3D io_port % 3; + + return ioread8(&ppi[bank].port[ppi_port]) & mask; +} + +static u8 i8255_direction_mask(const unsigned long offset) +{ + const unsigned long port_offset =3D offset % 8; + const unsigned long io_port =3D offset / 8; + const unsigned long ppi_port =3D io_port % 3; + + switch (ppi_port) { + case I8255_PORTA: + return I8255_CONTROL_PORTA_DIRECTION; + case I8255_PORTB: + return I8255_CONTROL_PORTB_DIRECTION; + case I8255_PORTC: + /* Port C can be configured by nibble */ + if (port_offset >=3D 4) + return I8255_CONTROL_PORTC_UPPER_DIRECTION; + return I8255_CONTROL_PORTC_LOWER_DIRECTION; + default: + /* Should never reach this path */ + return 0; + } +} + +static void i8255_set_port(struct i8255 __iomem *const ppi, + struct i8255_state *const state, + const unsigned long io_port, + const unsigned long mask, const unsigned long bits) +{ + const unsigned long bank =3D io_port / 3; + const unsigned long ppi_port =3D io_port % 3; + unsigned long flags; + unsigned long out_state; + + spin_lock_irqsave(&state[bank].lock, flags); + + out_state =3D ioread8(&ppi[bank].port[ppi_port]); + out_state =3D (out_state & ~mask) | (bits & mask); + iowrite8(out_state, &ppi[bank].port[ppi_port]); + + spin_unlock_irqrestore(&state[bank].lock, flags); +} + +/** + * i8255_direction_input - configure signal offset as input + * @ppi: Intel 8255 Programmable Peripheral Interface banks + * @state: devices states of the respective PPI banks + * @offset: signal offset to configure as input + * + * Configures a signal @offset as input for the respective Intel 8255 + * Programmable Peripheral Interface (@ppi) banks. The @state control_state + * values are updated to reflect the new configuration. + */ +void i8255_direction_input(struct i8255 __iomem *const ppi, + struct i8255_state *const state, + const unsigned long offset) +{ + const unsigned long io_port =3D offset / 8; + const unsigned long bank =3D io_port / 3; + unsigned long flags; + + spin_lock_irqsave(&state[bank].lock, flags); + + state[bank].control_state |=3D I8255_CONTROL_MODE_SET; + state[bank].control_state |=3D i8255_direction_mask(offset); + + iowrite8(state[bank].control_state, &ppi[bank].control); + + spin_unlock_irqrestore(&state[bank].lock, flags); +} +EXPORT_SYMBOL_NS_GPL(i8255_direction_input, I8255); + +/** + * i8255_direction_output - configure signal offset as output + * @ppi: Intel 8255 Programmable Peripheral Interface banks + * @state: devices states of the respective PPI banks + * @offset: signal offset to configure as output + * @value: signal value to output + * + * Configures a signal @offset as output for the respective Intel 8255 + * Programmable Peripheral Interface (@ppi) banks and sets the respective = signal + * output to the desired @value. The @state control_state values are updat= ed to + * reflect the new configuration. + */ +void i8255_direction_output(struct i8255 __iomem *const ppi, + struct i8255_state *const state, + const unsigned long offset, + const unsigned long value) +{ + const unsigned long io_port =3D offset / 8; + const unsigned long bank =3D io_port / 3; + unsigned long flags; + + spin_lock_irqsave(&state[bank].lock, flags); + + state[bank].control_state |=3D I8255_CONTROL_MODE_SET; + state[bank].control_state &=3D ~i8255_direction_mask(offset); + + iowrite8(state[bank].control_state, &ppi[bank].control); + + spin_unlock_irqrestore(&state[bank].lock, flags); + + i8255_set(ppi, state, offset, value); +} +EXPORT_SYMBOL_NS_GPL(i8255_direction_output, I8255); + +/** + * i8255_get - get signal value at signal offset + * @ppi: Intel 8255 Programmable Peripheral Interface banks + * @offset: offset of signal to get + * + * Returns the signal value (0=3Dlow, 1=3Dhigh) for the signal at @offset = for the + * respective Intel 8255 Programmable Peripheral Interface (@ppi) banks. + */ +int i8255_get(struct i8255 __iomem *const ppi, const unsigned long offset) +{ + const unsigned long io_port =3D offset / 8; + const unsigned long offset_mask =3D BIT(offset % 8); + + return !!i8255_get_port(ppi, io_port, offset_mask); +} +EXPORT_SYMBOL_NS_GPL(i8255_get, I8255); + +/** + * i8255_get_direction - get the I/O direction for a signal offset + * @state: devices states of the respective PPI banks + * @offset: offset of signal to get direction + * + * Returns the signal direction (0=3Doutput, 1=3Dinput) for the signal at = @offset. + */ +int i8255_get_direction(const struct i8255_state *const state, + const unsigned long offset) +{ + const unsigned long io_port =3D offset / 8; + const unsigned long bank =3D io_port / 3; + + return !!(state[bank].control_state & i8255_direction_mask(offset)); +} +EXPORT_SYMBOL_NS_GPL(i8255_get_direction, I8255); + +/** + * i8255_get_multiple - get multiple signal values at multiple signal offs= ets + * @ppi: Intel 8255 Programmable Peripheral Interface banks + * @mask: mask of signals to get + * @bits: bitmap to store signal values + * @ngpio: number of GPIO signals of the respective PPI banks + * + * Stores in @bits the values (0=3Dlow, 1=3Dhigh) for the signals defined = by @mask + * for the respective Intel 8255 Programmable Peripheral Interface (@ppi) = banks. + */ +void i8255_get_multiple(struct i8255 __iomem *const ppi, + const unsigned long *const mask, + unsigned long *const bits, const unsigned long ngpio) +{ + unsigned long offset; + unsigned long port_mask; + unsigned long io_port; + unsigned long port_state; + + bitmap_zero(bits, ngpio); + + for_each_set_clump8(offset, port_mask, mask, ngpio) { + io_port =3D offset / 8; + port_state =3D i8255_get_port(ppi, io_port, port_mask); + + bitmap_set_value8(bits, port_state, offset); + } +} +EXPORT_SYMBOL_NS_GPL(i8255_get_multiple, I8255); + +/** + * i8255_mode0_output - configure all PPI ports to MODE 0 output mode + * @ppi: Intel 8255 Programmable Peripheral Interface bank + * + * Configures all Intel 8255 Programmable Peripheral Interface (@ppi) port= s to + * MODE 0 (Basic Input/Output) output mode. + */ +void i8255_mode0_output(struct i8255 __iomem *const ppi) +{ + iowrite8(I8255_CONTROL_MODE_SET, &ppi->control); +} +EXPORT_SYMBOL_NS_GPL(i8255_mode0_output, I8255); + +/** + * i8255_set - set signal value at signal offset + * @ppi: Intel 8255 Programmable Peripheral Interface banks + * @state: devices states of the respective PPI banks + * @offset: offset of signal to set + * @value: value of signal to set + * + * Assigns output @value for the signal at @offset for the respective Inte= l 8255 + * Programmable Peripheral Interface (@ppi) banks. + */ +void i8255_set(struct i8255 __iomem *const ppi, struct i8255_state *const = state, + const unsigned long offset, const unsigned long value) +{ + const unsigned long io_port =3D offset / 8; + const unsigned long port_offset =3D offset % 8; + const unsigned long mask =3D BIT(port_offset); + const unsigned long bits =3D value << port_offset; + + i8255_set_port(ppi, state, io_port, mask, bits); +} +EXPORT_SYMBOL_NS_GPL(i8255_set, I8255); + +/** + * i8255_set_multiple - set signal values at multiple signal offsets + * @ppi: Intel 8255 Programmable Peripheral Interface banks + * @state: devices states of the respective PPI banks + * @mask: mask of signals to set + * @bits: bitmap of signal output values + * @ngpio: number of GPIO signals of the respective PPI banks + * + * Assigns output values defined by @bits for the signals defined by @mask= for + * the respective Intel 8255 Programmable Peripheral Interface (@ppi) bank= s. + */ +void i8255_set_multiple(struct i8255 __iomem *const ppi, + struct i8255_state *const state, + const unsigned long *const mask, + const unsigned long *const bits, + const unsigned long ngpio) +{ + unsigned long offset; + unsigned long port_mask; + unsigned long io_port; + unsigned long value; + + for_each_set_clump8(offset, port_mask, mask, ngpio) { + io_port =3D offset / 8; + value =3D bitmap_get_value8(bits, offset); + i8255_set_port(ppi, state, io_port, port_mask, value); + } +} +EXPORT_SYMBOL_NS_GPL(i8255_set_multiple, I8255); + +/** + * i8255_state_init - initialize i8255_state structure + * @state: devices states of the respective PPI banks + * @nbanks: number of Intel 8255 Programmable Peripheral Interface banks + * + * Initializes the @state of each Intel 8255 Programmable Peripheral Inter= face + * bank for use in i8255 library functions. + */ +void i8255_state_init(struct i8255_state *const state, + const unsigned long nbanks) +{ + unsigned long bank; + + for (bank =3D 0; bank < nbanks; bank++) + spin_lock_init(&state[bank].lock); +} +EXPORT_SYMBOL_NS_GPL(i8255_state_init, I8255); + +MODULE_AUTHOR("William Breathitt Gray"); +MODULE_DESCRIPTION("Intel 8255 Programmable Peripheral Interface"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpio/gpio-i8255.h b/drivers/gpio/gpio-i8255.h new file mode 100644 index 000000000000..d9084aae9446 --- /dev/null +++ b/drivers/gpio/gpio-i8255.h @@ -0,0 +1,46 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* Copyright 2022 William Breathitt Gray */ +#ifndef _I8255_H_ +#define _I8255_H_ + +#include +#include + +/** + * struct i8255 - Intel 8255 register structure + * @port: Port A, B, and C + * @control: Control register + */ +struct i8255 { + u8 port[3]; + u8 control; +}; + +/** + * struct i8255_state - Intel 8255 state structure + * @lock: synchronization lock for accessing device state + * @control_state: Control register state + */ +struct i8255_state { + spinlock_t lock; + u8 control_state; +}; + +void i8255_direction_input(struct i8255 __iomem *ppi, struct i8255_state *= state, + unsigned long offset); +void i8255_direction_output(struct i8255 __iomem *ppi, + struct i8255_state *state, unsigned long offset, + unsigned long value); +int i8255_get(struct i8255 __iomem *ppi, unsigned long offset); +int i8255_get_direction(const struct i8255_state *state, unsigned long off= set); +void i8255_get_multiple(struct i8255 __iomem *ppi, const unsigned long *ma= sk, + unsigned long *bits, unsigned long ngpio); +void i8255_mode0_output(struct i8255 __iomem *const ppi); +void i8255_set(struct i8255 __iomem *ppi, struct i8255_state *state, + unsigned long offset, unsigned long value); +void i8255_set_multiple(struct i8255 __iomem *ppi, struct i8255_state *sta= te, + const unsigned long *mask, const unsigned long *bits, + unsigned long ngpio); +void i8255_state_init(struct i8255_state *const state, unsigned long nbank= s); + +#endif /* _I8255_H_ */ --=20 2.36.1 From nobody Fri Apr 17 23:52:39 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 15F47C433EF for ; Wed, 20 Jul 2022 13:46:40 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239803AbiGTNqi (ORCPT ); Wed, 20 Jul 2022 09:46:38 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38934 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239604AbiGTNqV (ORCPT ); Wed, 20 Jul 2022 09:46:21 -0400 Received: from mail-qv1-xf2f.google.com (mail-qv1-xf2f.google.com [IPv6:2607:f8b0:4864:20::f2f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8566D5A2E3 for ; Wed, 20 Jul 2022 06:46:15 -0700 (PDT) Received: by mail-qv1-xf2f.google.com with SMTP id m6so13477576qvq.10 for ; Wed, 20 Jul 2022 06:46:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=BcG0fqjYq31YdVUAfnT7nKHI9Xw/+3glRgxxjox1bxY=; b=wWLHn3i8jl1k5TZdFZ0g5VFxDNy2V7OvKCGAlLJUPIN91roXLilH0PPo0dudUNatEw 4aOEx/awDfwj861SFOqeyiYw/yVDdmPyAWHSfrFMwSoDyLF/09V6f8H8pNsHza+DDw99 9QQdhGYPQzbzyhtsAaMyeEJTJAX7y28x/hYDQy1C1aH8AKEEAcubFN1mES3R8sgJKrBF msw798rxolrnU1B8++vvpm1AH7VraqBxuuM06LTAEqoOJ5hNiu3PfltZoj/a4vPWGuCS GJ3NElT9/Mkr/hoDHGZbSDOmlt2jAARsAQj+Y3v21uYEzJMIHSDKQ/34da16eQak+ZJ+ gg0A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=BcG0fqjYq31YdVUAfnT7nKHI9Xw/+3glRgxxjox1bxY=; b=zi4AtmOcnU+KrUUJvXBLvhH3M2+KIWB6Q++AFunzJW3jm+/Q9krw6qDq9lzHXMdYlm 1pWT073KKsIWiV28qmskBLOuTOZ9SktA/j22Pxkf15cAkALz0ofVQEmcSq6DXJmWbCnf XAR3g0TaK1m4qgMKHHq/YBWruvtxQNlr4YGy+5SkRLKSw8vw9ppEFIaERknSSUBM16MT 7gYi4hzMaLPngit2TBTtjRG6eKro9fibQrGPVUjwiSWO5Lqc+7ptYmOsJifiQAtRLbBi mlVRrXebH539U57wZ7GtuQb9M27HtH+VxlY9GPUBXB3iYgoZLkT4Lsm1rMKVXrh9Jap8 AfDA== X-Gm-Message-State: AJIora+AXaLLWRYOo48UUypivKlswaPUr7j9jjB85MYoeU8VcPi2xe5t pIhyTZyNiNmyA/mjx5LgId+A60khBecAjA== X-Google-Smtp-Source: AGRyM1teDqF6x04mEUHu1wGF+NsJLZkmqttuHFBHepBJlI9YhBW0sm+AHRQWe64+knSXKZR9IBD64g== X-Received: by 2002:a05:6214:5e04:b0:473:6b81:a725 with SMTP id li4-20020a0562145e0400b004736b81a725mr29393935qvb.111.1658324774678; Wed, 20 Jul 2022 06:46:14 -0700 (PDT) Received: from fedora.attlocal.net (69-109-179-158.lightspeed.dybhfl.sbcglobal.net. [69.109.179.158]) by smtp.gmail.com with ESMTPSA id bl13-20020a05620a1a8d00b006b5f8f32a8fsm5289853qkb.114.2022.07.20.06.46.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 20 Jul 2022 06:46:14 -0700 (PDT) From: William Breathitt Gray To: linus.walleij@linaro.org, brgl@bgdev.pl Cc: linux-gpio@vger.kernel.org, linux-kernel@vger.kernel.org, William Breathitt Gray , John Hentges , Jay Dolan Subject: [RESEND PATCH v4 4/6] gpio: 104-dio-48e: Implement and utilize register structures Date: Wed, 20 Jul 2022 09:46:00 -0400 Message-Id: <761376c39a8f5d05199d4390a685fd3399943bfb.1658324498.git.william.gray@linaro.org> X-Mailer: git-send-email 2.36.1 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Reduce magic numbers and improve code readability by implementing and utilizing named register data structures. The 104-DIO-48E device features an Intel 8255 compatible GPIO interface, so the i8255 GPIO module is selected and utilized as well. Reviewed-by: Linus Walleij Cc: John Hentges Cc: Jay Dolan Signed-off-by: William Breathitt Gray --- Changes in v4: - Remove superfluous include drivers/gpio/Kconfig | 1 + drivers/gpio/gpio-104-dio-48e.c | 249 ++++++++++---------------------- 2 files changed, 75 insertions(+), 175 deletions(-) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index df484b72000d..d070bd9f4f94 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -841,6 +841,7 @@ config GPIO_104_DIO_48E depends on PC104 select ISA_BUS_API select GPIOLIB_IRQCHIP + select GPIO_I8255 help Enables GPIO support for the ACCES 104-DIO-48E series (104-DIO-48E, 104-DIO-24E). The base port addresses for the devices may be diff --git a/drivers/gpio/gpio-104-dio-48e.c b/drivers/gpio/gpio-104-dio-48= e.c index f118ad9bcd33..a41551870759 100644 --- a/drivers/gpio/gpio-104-dio-48e.c +++ b/drivers/gpio/gpio-104-dio-48e.c @@ -6,8 +6,7 @@ * This driver supports the following ACCES devices: 104-DIO-48E and * 104-DIO-24E. */ -#include -#include +#include #include #include #include @@ -20,6 +19,11 @@ #include #include #include +#include + +#include "gpio-i8255.h" + +MODULE_IMPORT_NS(I8255); =20 #define DIO48E_EXTENT 16 #define MAX_NUM_DIO48E max_num_isa_dev(DIO48E_EXTENT) @@ -33,34 +37,54 @@ static unsigned int irq[MAX_NUM_DIO48E]; module_param_hw_array(irq, uint, irq, NULL, 0); MODULE_PARM_DESC(irq, "ACCES 104-DIO-48E interrupt line numbers"); =20 +#define DIO48E_NUM_PPI 2 + +/** + * struct dio48e_reg - device register structure + * @ppi: Programmable Peripheral Interface groups + * @enable_buffer: Enable/Disable Buffer groups + * @unused1: Unused + * @enable_interrupt: Write: Enable Interrupt + * Read: Disable Interrupt + * @unused2: Unused + * @enable_counter: Write: Enable Counter/Timer Addressing + * Read: Disable Counter/Timer Addressing + * @unused3: Unused + * @clear_interrupt: Clear Interrupt + */ +struct dio48e_reg { + struct i8255 ppi[DIO48E_NUM_PPI]; + u8 enable_buffer[DIO48E_NUM_PPI]; + u8 unused1; + u8 enable_interrupt; + u8 unused2; + u8 enable_counter; + u8 unused3; + u8 clear_interrupt; +}; + /** * struct dio48e_gpio - GPIO device private data structure - * @chip: instance of the gpio_chip - * @io_state: bit I/O state (whether bit is set to input or output) - * @out_state: output bits state - * @control: Control registers state - * @lock: synchronization lock to prevent I/O race conditions - * @base: base port address of the GPIO device - * @irq_mask: I/O bits affected by interrupts + * @chip: instance of the gpio_chip + * @ppi_state: PPI device states + * @lock: synchronization lock to prevent I/O race conditions + * @reg: I/O address offset for the device registers + * @irq_mask: I/O bits affected by interrupts */ struct dio48e_gpio { struct gpio_chip chip; - unsigned char io_state[6]; - unsigned char out_state[6]; - unsigned char control[2]; + struct i8255_state ppi_state[DIO48E_NUM_PPI]; raw_spinlock_t lock; - void __iomem *base; + struct dio48e_reg __iomem *reg; unsigned char irq_mask; }; =20 static int dio48e_gpio_get_direction(struct gpio_chip *chip, unsigned int = offset) { struct dio48e_gpio *const dio48egpio =3D gpiochip_get_data(chip); - const unsigned int port =3D offset / 8; - const unsigned int mask =3D BIT(offset % 8); =20 - if (dio48egpio->io_state[port] & mask) - return GPIO_LINE_DIRECTION_IN; + if (i8255_get_direction(dio48egpio->ppi_state, offset)) + return GPIO_LINE_DIRECTION_IN; =20 return GPIO_LINE_DIRECTION_OUT; } @@ -68,38 +92,9 @@ static int dio48e_gpio_get_direction(struct gpio_chip *c= hip, unsigned int offset static int dio48e_gpio_direction_input(struct gpio_chip *chip, unsigned in= t offset) { struct dio48e_gpio *const dio48egpio =3D gpiochip_get_data(chip); - const unsigned int io_port =3D offset / 8; - const unsigned int control_port =3D io_port / 3; - void __iomem *const control_addr =3D dio48egpio->base + 3 + control_port = * 4; - unsigned long flags; - unsigned int control; - - raw_spin_lock_irqsave(&dio48egpio->lock, flags); =20 - /* Check if configuring Port C */ - if (io_port =3D=3D 2 || io_port =3D=3D 5) { - /* Port C can be configured by nibble */ - if (offset % 8 > 3) { - dio48egpio->io_state[io_port] |=3D 0xF0; - dio48egpio->control[control_port] |=3D BIT(3); - } else { - dio48egpio->io_state[io_port] |=3D 0x0F; - dio48egpio->control[control_port] |=3D BIT(0); - } - } else { - dio48egpio->io_state[io_port] |=3D 0xFF; - if (io_port =3D=3D 0 || io_port =3D=3D 3) - dio48egpio->control[control_port] |=3D BIT(4); - else - dio48egpio->control[control_port] |=3D BIT(1); - } - - control =3D BIT(7) | dio48egpio->control[control_port]; - iowrite8(control, control_addr); - control &=3D ~BIT(7); - iowrite8(control, control_addr); - - raw_spin_unlock_irqrestore(&dio48egpio->lock, flags); + i8255_direction_input(dio48egpio->reg->ppi, dio48egpio->ppi_state, + offset); =20 return 0; } @@ -108,48 +103,9 @@ static int dio48e_gpio_direction_output(struct gpio_ch= ip *chip, unsigned int off int value) { struct dio48e_gpio *const dio48egpio =3D gpiochip_get_data(chip); - const unsigned int io_port =3D offset / 8; - const unsigned int control_port =3D io_port / 3; - const unsigned int mask =3D BIT(offset % 8); - void __iomem *const control_addr =3D dio48egpio->base + 3 + control_port = * 4; - const unsigned int out_port =3D (io_port > 2) ? io_port + 1 : io_port; - unsigned long flags; - unsigned int control; - - raw_spin_lock_irqsave(&dio48egpio->lock, flags); - - /* Check if configuring Port C */ - if (io_port =3D=3D 2 || io_port =3D=3D 5) { - /* Port C can be configured by nibble */ - if (offset % 8 > 3) { - dio48egpio->io_state[io_port] &=3D 0x0F; - dio48egpio->control[control_port] &=3D ~BIT(3); - } else { - dio48egpio->io_state[io_port] &=3D 0xF0; - dio48egpio->control[control_port] &=3D ~BIT(0); - } - } else { - dio48egpio->io_state[io_port] &=3D 0x00; - if (io_port =3D=3D 0 || io_port =3D=3D 3) - dio48egpio->control[control_port] &=3D ~BIT(4); - else - dio48egpio->control[control_port] &=3D ~BIT(1); - } - - if (value) - dio48egpio->out_state[io_port] |=3D mask; - else - dio48egpio->out_state[io_port] &=3D ~mask; =20 - control =3D BIT(7) | dio48egpio->control[control_port]; - iowrite8(control, control_addr); - - iowrite8(dio48egpio->out_state[io_port], dio48egpio->base + out_port); - - control &=3D ~BIT(7); - iowrite8(control, control_addr); - - raw_spin_unlock_irqrestore(&dio48egpio->lock, flags); + i8255_direction_output(dio48egpio->reg->ppi, dio48egpio->ppi_state, + offset, value); =20 return 0; } @@ -157,47 +113,16 @@ static int dio48e_gpio_direction_output(struct gpio_c= hip *chip, unsigned int off static int dio48e_gpio_get(struct gpio_chip *chip, unsigned int offset) { struct dio48e_gpio *const dio48egpio =3D gpiochip_get_data(chip); - const unsigned int port =3D offset / 8; - const unsigned int mask =3D BIT(offset % 8); - const unsigned int in_port =3D (port > 2) ? port + 1 : port; - unsigned long flags; - unsigned int port_state; - - raw_spin_lock_irqsave(&dio48egpio->lock, flags); =20 - /* ensure that GPIO is set for input */ - if (!(dio48egpio->io_state[port] & mask)) { - raw_spin_unlock_irqrestore(&dio48egpio->lock, flags); - return -EINVAL; - } - - port_state =3D ioread8(dio48egpio->base + in_port); - - raw_spin_unlock_irqrestore(&dio48egpio->lock, flags); - - return !!(port_state & mask); + return i8255_get(dio48egpio->reg->ppi, offset); } =20 -static const size_t ports[] =3D { 0, 1, 2, 4, 5, 6 }; - static int dio48e_gpio_get_multiple(struct gpio_chip *chip, unsigned long = *mask, unsigned long *bits) { struct dio48e_gpio *const dio48egpio =3D gpiochip_get_data(chip); - unsigned long offset; - unsigned long gpio_mask; - void __iomem *port_addr; - unsigned long port_state; =20 - /* clear bits array to a clean slate */ - bitmap_zero(bits, chip->ngpio); - - for_each_set_clump8(offset, gpio_mask, mask, ARRAY_SIZE(ports) * 8) { - port_addr =3D dio48egpio->base + ports[offset / 8]; - port_state =3D ioread8(port_addr) & gpio_mask; - - bitmap_set_value8(bits, port_state, offset); - } + i8255_get_multiple(dio48egpio->reg->ppi, mask, bits, chip->ngpio); =20 return 0; } @@ -205,49 +130,17 @@ static int dio48e_gpio_get_multiple(struct gpio_chip = *chip, unsigned long *mask, static void dio48e_gpio_set(struct gpio_chip *chip, unsigned int offset, i= nt value) { struct dio48e_gpio *const dio48egpio =3D gpiochip_get_data(chip); - const unsigned int port =3D offset / 8; - const unsigned int mask =3D BIT(offset % 8); - const unsigned int out_port =3D (port > 2) ? port + 1 : port; - unsigned long flags; =20 - raw_spin_lock_irqsave(&dio48egpio->lock, flags); - - if (value) - dio48egpio->out_state[port] |=3D mask; - else - dio48egpio->out_state[port] &=3D ~mask; - - iowrite8(dio48egpio->out_state[port], dio48egpio->base + out_port); - - raw_spin_unlock_irqrestore(&dio48egpio->lock, flags); + i8255_set(dio48egpio->reg->ppi, dio48egpio->ppi_state, offset, value); } =20 static void dio48e_gpio_set_multiple(struct gpio_chip *chip, unsigned long *mask, unsigned long *bits) { struct dio48e_gpio *const dio48egpio =3D gpiochip_get_data(chip); - unsigned long offset; - unsigned long gpio_mask; - size_t index; - void __iomem *port_addr; - unsigned long bitmask; - unsigned long flags; - - for_each_set_clump8(offset, gpio_mask, mask, ARRAY_SIZE(ports) * 8) { - index =3D offset / 8; - port_addr =3D dio48egpio->base + ports[index]; - - bitmask =3D bitmap_get_value8(bits, offset) & gpio_mask; - - raw_spin_lock_irqsave(&dio48egpio->lock, flags); =20 - /* update output state data and set device gpio register */ - dio48egpio->out_state[index] &=3D ~gpio_mask; - dio48egpio->out_state[index] |=3D bitmask; - iowrite8(dio48egpio->out_state[index], port_addr); - - raw_spin_unlock_irqrestore(&dio48egpio->lock, flags); - } + i8255_set_multiple(dio48egpio->reg->ppi, dio48egpio->ppi_state, mask, + bits, chip->ngpio); } =20 static void dio48e_irq_ack(struct irq_data *data) @@ -274,7 +167,7 @@ static void dio48e_irq_mask(struct irq_data *data) =20 if (!dio48egpio->irq_mask) /* disable interrupts */ - ioread8(dio48egpio->base + 0xB); + ioread8(&dio48egpio->reg->enable_interrupt); =20 raw_spin_unlock_irqrestore(&dio48egpio->lock, flags); } @@ -294,8 +187,8 @@ static void dio48e_irq_unmask(struct irq_data *data) =20 if (!dio48egpio->irq_mask) { /* enable interrupts */ - iowrite8(0x00, dio48egpio->base + 0xF); - iowrite8(0x00, dio48egpio->base + 0xB); + iowrite8(0x00, &dio48egpio->reg->clear_interrupt); + iowrite8(0x00, &dio48egpio->reg->enable_interrupt); } =20 if (offset =3D=3D 19) @@ -341,7 +234,7 @@ static irqreturn_t dio48e_irq_handler(int irq, void *de= v_id) =20 raw_spin_lock(&dio48egpio->lock); =20 - iowrite8(0x00, dio48egpio->base + 0xF); + iowrite8(0x00, &dio48egpio->reg->clear_interrupt); =20 raw_spin_unlock(&dio48egpio->lock); =20 @@ -373,11 +266,26 @@ static int dio48e_irq_init_hw(struct gpio_chip *gc) struct dio48e_gpio *const dio48egpio =3D gpiochip_get_data(gc); =20 /* Disable IRQ by default */ - ioread8(dio48egpio->base + 0xB); + ioread8(&dio48egpio->reg->enable_interrupt); =20 return 0; } =20 +static void dio48e_init_ppi(struct i8255 __iomem *const ppi, + struct i8255_state *const ppi_state) +{ + const unsigned long ngpio =3D 24; + const unsigned long mask =3D GENMASK(ngpio - 1, 0); + const unsigned long bits =3D 0; + unsigned long i; + + /* Initialize all GPIO to output 0 */ + for (i =3D 0; i < DIO48E_NUM_PPI; i++) { + i8255_mode0_output(&ppi[i]); + i8255_set_multiple(&ppi[i], &ppi_state[i], &mask, &bits, ngpio); + } +} + static int dio48e_probe(struct device *dev, unsigned int id) { struct dio48e_gpio *dio48egpio; @@ -395,8 +303,8 @@ static int dio48e_probe(struct device *dev, unsigned in= t id) return -EBUSY; } =20 - dio48egpio->base =3D devm_ioport_map(dev, base[id], DIO48E_EXTENT); - if (!dio48egpio->base) + dio48egpio->reg =3D devm_ioport_map(dev, base[id], DIO48E_EXTENT); + if (!dio48egpio->reg) return -ENOMEM; =20 dio48egpio->chip.label =3D name; @@ -425,17 +333,8 @@ static int dio48e_probe(struct device *dev, unsigned i= nt id) =20 raw_spin_lock_init(&dio48egpio->lock); =20 - /* initialize all GPIO as output */ - iowrite8(0x80, dio48egpio->base + 3); - iowrite8(0x00, dio48egpio->base); - iowrite8(0x00, dio48egpio->base + 1); - iowrite8(0x00, dio48egpio->base + 2); - iowrite8(0x00, dio48egpio->base + 3); - iowrite8(0x80, dio48egpio->base + 7); - iowrite8(0x00, dio48egpio->base + 4); - iowrite8(0x00, dio48egpio->base + 5); - iowrite8(0x00, dio48egpio->base + 6); - iowrite8(0x00, dio48egpio->base + 7); + i8255_state_init(dio48egpio->ppi_state, DIO48E_NUM_PPI); + dio48e_init_ppi(dio48egpio->reg->ppi, dio48egpio->ppi_state); =20 err =3D devm_gpiochip_add_data(dev, &dio48egpio->chip, dio48egpio); if (err) { --=20 2.36.1 From nobody Fri Apr 17 23:52:39 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 23B0BC43334 for ; Wed, 20 Jul 2022 13:46:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230434AbiGTNqp (ORCPT ); Wed, 20 Jul 2022 09:46:45 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38936 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239608AbiGTNqV (ORCPT ); Wed, 20 Jul 2022 09:46:21 -0400 Received: from mail-qv1-xf33.google.com (mail-qv1-xf33.google.com [IPv6:2607:f8b0:4864:20::f33]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 85A3E5A47F for ; Wed, 20 Jul 2022 06:46:16 -0700 (PDT) Received: by mail-qv1-xf33.google.com with SMTP id m6so13477600qvq.10 for ; Wed, 20 Jul 2022 06:46:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=RKb2mSasNJyrXspITPqbYCazsTxN0bsowmCfKFzVHKg=; b=QfvoliDbXEH84383CNgRb4d5CFeD9R8VoEKBiSJUISC9bwuvDvZkpx8rLYWbqqGG8D SKMhB9x+SM4H5IP43Vi4ZfMv2FIXLNEiqSMRdlWweL8xZ3DI+AUvbonKVsxxNQWJRqLR 6nEcaDkg8DqyWJXf+E0CL3blUUA5rkOZVdEiK84eBWHItfkOgwwNhHujksdJ6JshUEEg idq4YmpLII3EECNQwKPVNM3p41e+dEb4nycz6IEti3OK9lcXfHiZyTtwPn81Lo/AZDRH KJfSe+gqpzV2sJiNWPbx20ih1Ij74/RHLg9EJmf+BKcpTfBcl3o+8trBrpkSFqdytAXq cJFQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=RKb2mSasNJyrXspITPqbYCazsTxN0bsowmCfKFzVHKg=; b=XzoSRCX+xNFmCoFTzftyA+KtZypIExiWak/V4ZeesruT2kH0LakbpY1VnPbjWYmFbi j7FTH595mc8eRWW/Iy8YdIeTCVUfG2/llgHiAPeyPyF7+sZioJN6fHmaU3/3SADNyYRv 6BHEKWFA2rfbNmsYRxzYx/VyCCyOkm7EfXIN58MQRhFTe10nFxn13NcAns4i7n2ndaNB vRsiWj45VdLw1Rm0KYBaLU0iYmOHI8/kFxl2Fl/6Hblt5JQJwvapBGBT7g3xUhKt9akG RWBhbe8RFiqUOz0LE+v+FmKbcOkvgG/LLQ2O7ITN9ugS4OfEZErzVACKynTzhWbBsKyK eXgA== X-Gm-Message-State: AJIora9nkU7y9Ebu95oIcwX2yulb5YbcCla5oRlnpo9m93poJYFuB4CR 05zJI8sk9LpS8o0Rk69vvTfPtg== X-Google-Smtp-Source: AGRyM1v0AEGI7VmT7Bn6IH56fB09VomJ+U2qWr86iB/4/KVmIsedul2jOWa3AwbO4RfXRcAf6EbN9g== X-Received: by 2002:a05:6214:2021:b0:474:5f9:8385 with SMTP id 1-20020a056214202100b0047405f98385mr1745492qvf.105.1658324775476; Wed, 20 Jul 2022 06:46:15 -0700 (PDT) Received: from fedora.attlocal.net (69-109-179-158.lightspeed.dybhfl.sbcglobal.net. [69.109.179.158]) by smtp.gmail.com with ESMTPSA id bl13-20020a05620a1a8d00b006b5f8f32a8fsm5289853qkb.114.2022.07.20.06.46.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 20 Jul 2022 06:46:15 -0700 (PDT) From: William Breathitt Gray To: linus.walleij@linaro.org, brgl@bgdev.pl Cc: linux-gpio@vger.kernel.org, linux-kernel@vger.kernel.org, William Breathitt Gray , John Hentges , Jay Dolan Subject: [RESEND PATCH v4 5/6] gpio: 104-idi-48: Implement and utilize register structures Date: Wed, 20 Jul 2022 09:46:01 -0400 Message-Id: <699f47f2301d1f6440cde1ecffaeb21a6f87d912.1658324498.git.william.gray@linaro.org> X-Mailer: git-send-email 2.36.1 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Reduce magic numbers and improve code readability by implementing and utilizing named register data structures. The 104-IDI-48 device features an Intel 8255 compatible GPIO interface, so the i8255 GPIO module is selected and utilized as well. Reviewed-by: Linus Walleij Cc: John Hentges Cc: Jay Dolan Signed-off-by: William Breathitt Gray --- Changes in v4: - Replace superfluous include with - Remove 'const' from '__iomem' pointers drivers/gpio/Kconfig | 1 + drivers/gpio/gpio-104-idi-48.c | 143 ++++++++++++++------------------- 2 files changed, 61 insertions(+), 83 deletions(-) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index d070bd9f4f94..8f1d4d56f0aa 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -865,6 +865,7 @@ config GPIO_104_IDI_48 depends on PC104 select ISA_BUS_API select GPIOLIB_IRQCHIP + select GPIO_I8255 help Enables GPIO support for the ACCES 104-IDI-48 family (104-IDI-48A, 104-IDI-48AC, 104-IDI-48B, 104-IDI-48BC). The base port addresses for diff --git a/drivers/gpio/gpio-104-idi-48.c b/drivers/gpio/gpio-104-idi-48.c index c1e4c3629e17..40be76efeed7 100644 --- a/drivers/gpio/gpio-104-idi-48.c +++ b/drivers/gpio/gpio-104-idi-48.c @@ -6,8 +6,7 @@ * This driver supports the following ACCES devices: 104-IDI-48A, * 104-IDI-48AC, 104-IDI-48B, and 104-IDI-48BC. */ -#include -#include +#include #include #include #include @@ -20,6 +19,11 @@ #include #include #include +#include + +#include "gpio-i8255.h" + +MODULE_IMPORT_NS(I8255); =20 #define IDI_48_EXTENT 8 #define MAX_NUM_IDI_48 max_num_isa_dev(IDI_48_EXTENT) @@ -33,21 +37,34 @@ static unsigned int irq[MAX_NUM_IDI_48]; module_param_hw_array(irq, uint, irq, NULL, 0); MODULE_PARM_DESC(irq, "ACCES 104-IDI-48 interrupt line numbers"); =20 +/** + * struct idi_48_reg - device register structure + * @port0: Port 0 Inputs + * @unused: Unused + * @port1: Port 1 Inputs + * @irq: Read: IRQ Status Register/IRQ Clear + * Write: IRQ Enable/Disable + */ +struct idi_48_reg { + u8 port0[3]; + u8 unused; + u8 port1[3]; + u8 irq; +}; + /** * struct idi_48_gpio - GPIO device private data structure * @chip: instance of the gpio_chip * @lock: synchronization lock to prevent I/O race conditions - * @ack_lock: synchronization lock to prevent IRQ handler race conditions * @irq_mask: input bits affected by interrupts - * @base: base port address of the GPIO device + * @reg: I/O address offset for the device registers * @cos_enb: Change-Of-State IRQ enable boundaries mask */ struct idi_48_gpio { struct gpio_chip chip; - raw_spinlock_t lock; - spinlock_t ack_lock; + spinlock_t lock; unsigned char irq_mask[6]; - void __iomem *base; + struct idi_48_reg __iomem *reg; unsigned char cos_enb; }; =20 @@ -64,42 +81,18 @@ static int idi_48_gpio_direction_input(struct gpio_chip= *chip, unsigned int offs static int idi_48_gpio_get(struct gpio_chip *chip, unsigned int offset) { struct idi_48_gpio *const idi48gpio =3D gpiochip_get_data(chip); - unsigned int i; - static const unsigned int register_offset[6] =3D { 0, 1, 2, 4, 5, 6 }; - void __iomem *port_addr; - unsigned int mask; - - for (i =3D 0; i < 48; i +=3D 8) - if (offset < i + 8) { - port_addr =3D idi48gpio->base + register_offset[i / 8]; - mask =3D BIT(offset - i); - - return !!(ioread8(port_addr) & mask); - } + void __iomem *const ppi =3D idi48gpio->reg; =20 - /* The following line should never execute since offset < 48 */ - return 0; + return i8255_get(ppi, offset); } =20 static int idi_48_gpio_get_multiple(struct gpio_chip *chip, unsigned long = *mask, unsigned long *bits) { struct idi_48_gpio *const idi48gpio =3D gpiochip_get_data(chip); - unsigned long offset; - unsigned long gpio_mask; - static const size_t ports[] =3D { 0, 1, 2, 4, 5, 6 }; - void __iomem *port_addr; - unsigned long port_state; - - /* clear bits array to a clean slate */ - bitmap_zero(bits, chip->ngpio); + void __iomem *const ppi =3D idi48gpio->reg; =20 - for_each_set_clump8(offset, gpio_mask, mask, ARRAY_SIZE(ports) * 8) { - port_addr =3D idi48gpio->base + ports[offset / 8]; - port_state =3D ioread8(port_addr) & gpio_mask; - - bitmap_set_value8(bits, port_state, offset); - } + i8255_get_multiple(ppi, mask, bits, chip->ngpio); =20 return 0; } @@ -113,30 +106,24 @@ static void idi_48_irq_mask(struct irq_data *data) struct gpio_chip *chip =3D irq_data_get_irq_chip_data(data); struct idi_48_gpio *const idi48gpio =3D gpiochip_get_data(chip); const unsigned int offset =3D irqd_to_hwirq(data); - unsigned int i; - unsigned int mask; - unsigned int boundary; + const unsigned long boundary =3D offset / 8; + const unsigned long mask =3D BIT(offset % 8); unsigned long flags; =20 - for (i =3D 0; i < 48; i +=3D 8) - if (offset < i + 8) { - mask =3D BIT(offset - i); - boundary =3D i / 8; - - idi48gpio->irq_mask[boundary] &=3D ~mask; + spin_lock_irqsave(&idi48gpio->lock, flags); =20 - if (!idi48gpio->irq_mask[boundary]) { - idi48gpio->cos_enb &=3D ~BIT(boundary); + idi48gpio->irq_mask[boundary] &=3D ~mask; =20 - raw_spin_lock_irqsave(&idi48gpio->lock, flags); + /* Exit early if there are still input lines with IRQ unmasked */ + if (idi48gpio->irq_mask[boundary]) + goto exit; =20 - iowrite8(idi48gpio->cos_enb, idi48gpio->base + 7); + idi48gpio->cos_enb &=3D ~BIT(boundary); =20 - raw_spin_unlock_irqrestore(&idi48gpio->lock, flags); - } + iowrite8(idi48gpio->cos_enb, &idi48gpio->reg->irq); =20 - return; - } +exit: + spin_unlock_irqrestore(&idi48gpio->lock, flags); } =20 static void idi_48_irq_unmask(struct irq_data *data) @@ -144,32 +131,27 @@ static void idi_48_irq_unmask(struct irq_data *data) struct gpio_chip *chip =3D irq_data_get_irq_chip_data(data); struct idi_48_gpio *const idi48gpio =3D gpiochip_get_data(chip); const unsigned int offset =3D irqd_to_hwirq(data); - unsigned int i; - unsigned int mask; - unsigned int boundary; + const unsigned long boundary =3D offset / 8; + const unsigned long mask =3D BIT(offset % 8); unsigned int prev_irq_mask; unsigned long flags; =20 - for (i =3D 0; i < 48; i +=3D 8) - if (offset < i + 8) { - mask =3D BIT(offset - i); - boundary =3D i / 8; - prev_irq_mask =3D idi48gpio->irq_mask[boundary]; + spin_lock_irqsave(&idi48gpio->lock, flags); =20 - idi48gpio->irq_mask[boundary] |=3D mask; + prev_irq_mask =3D idi48gpio->irq_mask[boundary]; =20 - if (!prev_irq_mask) { - idi48gpio->cos_enb |=3D BIT(boundary); + idi48gpio->irq_mask[boundary] |=3D mask; =20 - raw_spin_lock_irqsave(&idi48gpio->lock, flags); + /* Exit early if IRQ was already unmasked for this boundary */ + if (prev_irq_mask) + goto exit; =20 - iowrite8(idi48gpio->cos_enb, idi48gpio->base + 7); + idi48gpio->cos_enb |=3D BIT(boundary); =20 - raw_spin_unlock_irqrestore(&idi48gpio->lock, flags); - } + iowrite8(idi48gpio->cos_enb, &idi48gpio->reg->irq); =20 - return; - } +exit: + spin_unlock_irqrestore(&idi48gpio->lock, flags); } =20 static int idi_48_irq_set_type(struct irq_data *data, unsigned int flow_ty= pe) @@ -200,17 +182,13 @@ static irqreturn_t idi_48_irq_handler(int irq, void *= dev_id) unsigned long gpio; struct gpio_chip *const chip =3D &idi48gpio->chip; =20 - spin_lock(&idi48gpio->ack_lock); - - raw_spin_lock(&idi48gpio->lock); - - cos_status =3D ioread8(idi48gpio->base + 7); + spin_lock(&idi48gpio->lock); =20 - raw_spin_unlock(&idi48gpio->lock); + cos_status =3D ioread8(&idi48gpio->reg->irq); =20 /* IRQ Status (bit 6) is active low (0 =3D IRQ generated by device) */ if (cos_status & BIT(6)) { - spin_unlock(&idi48gpio->ack_lock); + spin_unlock(&idi48gpio->lock); return IRQ_NONE; } =20 @@ -228,7 +206,7 @@ static irqreturn_t idi_48_irq_handler(int irq, void *de= v_id) } } =20 - spin_unlock(&idi48gpio->ack_lock); + spin_unlock(&idi48gpio->lock); =20 return IRQ_HANDLED; } @@ -250,8 +228,8 @@ static int idi_48_irq_init_hw(struct gpio_chip *gc) struct idi_48_gpio *const idi48gpio =3D gpiochip_get_data(gc); =20 /* Disable IRQ by default */ - iowrite8(0, idi48gpio->base + 7); - ioread8(idi48gpio->base + 7); + iowrite8(0, &idi48gpio->reg->irq); + ioread8(&idi48gpio->reg->irq); =20 return 0; } @@ -273,8 +251,8 @@ static int idi_48_probe(struct device *dev, unsigned in= t id) return -EBUSY; } =20 - idi48gpio->base =3D devm_ioport_map(dev, base[id], IDI_48_EXTENT); - if (!idi48gpio->base) + idi48gpio->reg =3D devm_ioport_map(dev, base[id], IDI_48_EXTENT); + if (!idi48gpio->reg) return -ENOMEM; =20 idi48gpio->chip.label =3D name; @@ -298,8 +276,7 @@ static int idi_48_probe(struct device *dev, unsigned in= t id) girq->handler =3D handle_edge_irq; girq->init_hw =3D idi_48_irq_init_hw; =20 - raw_spin_lock_init(&idi48gpio->lock); - spin_lock_init(&idi48gpio->ack_lock); + spin_lock_init(&idi48gpio->lock); =20 err =3D devm_gpiochip_add_data(dev, &idi48gpio->chip, idi48gpio); if (err) { --=20 2.36.1 From nobody Fri Apr 17 23:52:39 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 34EDDC43334 for ; Wed, 20 Jul 2022 13:46:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237035AbiGTNqt (ORCPT ); Wed, 20 Jul 2022 09:46:49 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38964 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239688AbiGTNqW (ORCPT ); Wed, 20 Jul 2022 09:46:22 -0400 Received: from mail-qv1-xf30.google.com (mail-qv1-xf30.google.com [IPv6:2607:f8b0:4864:20::f30]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 856F45A2E7 for ; Wed, 20 Jul 2022 06:46:17 -0700 (PDT) Received: by mail-qv1-xf30.google.com with SMTP id i4so3850637qvv.7 for ; Wed, 20 Jul 2022 06:46:17 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=YK2m0zUKGidqTcHmu1AnlUorqPw63e2Xchspxtij0bM=; b=SlkC18sy7m2hgmNGirhP1Hxeg4ZPvIgj+6M+Q0iUEOAFH0Yfppym//mM6q2kP20OiE O+3Uv+10rNR58PTkugcj1wLtGTT7d4nIwP/ASAF/o0E9XEIPDAfBP+Wxvk/ph1aX+h7K lFIqQxIKqei/4zPe6+AASyC48FWpiYO7rD5aWmKw1H+PDpvQ3nGoPjDDhN+xuxWRJ5tR xkv945QBRk4iNxYFHlQ5Jg/6+K39RKhvm1BLTPj/abTCpfL323lXIRUtsH081fKQnI2H mYrkRQCD4oCuyil0AfUdveCIKtIHadzmqgb0oZRQ8PaC0R0eDNnbwOugVeAWkyw+wWUd Mc5w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=YK2m0zUKGidqTcHmu1AnlUorqPw63e2Xchspxtij0bM=; b=ogW/OYA3MqfkUc+qYbOtG/NYUa2uGhpUMRsar/7r05USRPvY0R6ixLXPf2Ohtba9fS PVYHobLwCURhNpcWD68/3xT/SBtVdvHW9Y8m7oMtcR1TfbsdSfxqtNlWnlnryQoUQ9qj 4ejrIiQiT9iU4zPNbuptZvK3e/Zi3U5gZCKUc2Yon61J9tTZKOkY3GvynF47aI+KM0MV JR5EyL+KieDnOPVNmZOAn9g7J2slR4ZaoWQvAodi1A0bX4Ux6JsftTjpNp+4IU6EE+d3 QqOA3gVPWOP016Yc+ktS/syHk+671IT1a/c3gnZaQYGVQ1UHY4z4DxtJtewnqNxdFAJY mF3Q== X-Gm-Message-State: AJIora9KVDxVa0yop7B5anuGpnuOXOvMfPiUeS/FjuT8JwgxJGvY3YNK MTCxQk5+WxSxcVbJepq7ACFa0A== X-Google-Smtp-Source: AGRyM1tExfsP8xpOn3FeeCHHKnMWVXJdZOMIXRuHn+SnJoYhgBvSI94Xom11SoWYMpB97xF8xseoPw== X-Received: by 2002:a05:6214:20e9:b0:473:fee5:8f8d with SMTP id 9-20020a05621420e900b00473fee58f8dmr5612840qvk.122.1658324776311; Wed, 20 Jul 2022 06:46:16 -0700 (PDT) Received: from fedora.attlocal.net (69-109-179-158.lightspeed.dybhfl.sbcglobal.net. [69.109.179.158]) by smtp.gmail.com with ESMTPSA id bl13-20020a05620a1a8d00b006b5f8f32a8fsm5289853qkb.114.2022.07.20.06.46.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 20 Jul 2022 06:46:16 -0700 (PDT) From: William Breathitt Gray To: linus.walleij@linaro.org, brgl@bgdev.pl Cc: linux-gpio@vger.kernel.org, linux-kernel@vger.kernel.org, William Breathitt Gray , Fred Eckert Subject: [RESEND PATCH v4 6/6] gpio: gpio-mm: Implement and utilize register structures Date: Wed, 20 Jul 2022 09:46:02 -0400 Message-Id: X-Mailer: git-send-email 2.36.1 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Reduce magic numbers and improve code readability by implementing and utilizing named register data structures. The GPIO-MM device features an Intel 8255 compatible GPIO interface, so the i8255 GPIO module is selected and utilized as well. Tested-by: Fred Eckert Reviewed-by: Linus Walleij Signed-off-by: William Breathitt Gray --- Changes in v4: - Remove superfluous and includes drivers/gpio/Kconfig | 1 + drivers/gpio/gpio-gpio-mm.c | 202 +++++++----------------------------- 2 files changed, 40 insertions(+), 163 deletions(-) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index 8f1d4d56f0aa..0642f579196f 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -886,6 +886,7 @@ config GPIO_GPIO_MM tristate "Diamond Systems GPIO-MM GPIO support" depends on PC104 select ISA_BUS_API + select GPIO_I8255 help Enables GPIO support for the Diamond Systems GPIO-MM and GPIO-MM-12. =20 diff --git a/drivers/gpio/gpio-gpio-mm.c b/drivers/gpio/gpio-gpio-mm.c index 097a06463d01..2689671b6b01 100644 --- a/drivers/gpio/gpio-gpio-mm.c +++ b/drivers/gpio/gpio-gpio-mm.c @@ -6,8 +6,6 @@ * This driver supports the following Diamond Systems devices: GPIO-MM and * GPIO-MM-12. */ -#include -#include #include #include #include @@ -17,7 +15,10 @@ #include #include #include -#include + +#include "gpio-i8255.h" + +MODULE_IMPORT_NS(I8255); =20 #define GPIOMM_EXTENT 8 #define MAX_NUM_GPIOMM max_num_isa_dev(GPIOMM_EXTENT) @@ -27,32 +28,26 @@ static unsigned int num_gpiomm; module_param_hw_array(base, uint, ioport, &num_gpiomm, 0); MODULE_PARM_DESC(base, "Diamond Systems GPIO-MM base addresses"); =20 +#define GPIOMM_NUM_PPI 2 + /** * struct gpiomm_gpio - GPIO device private data structure - * @chip: instance of the gpio_chip - * @io_state: bit I/O state (whether bit is set to input or output) - * @out_state: output bits state - * @control: Control registers state - * @lock: synchronization lock to prevent I/O race conditions - * @base: base port address of the GPIO device + * @chip: instance of the gpio_chip + * @ppi_state: Programmable Peripheral Interface group states + * @ppi: Programmable Peripheral Interface groups */ struct gpiomm_gpio { struct gpio_chip chip; - unsigned char io_state[6]; - unsigned char out_state[6]; - unsigned char control[2]; - spinlock_t lock; - void __iomem *base; + struct i8255_state ppi_state[GPIOMM_NUM_PPI]; + struct i8255 __iomem *ppi; }; =20 static int gpiomm_gpio_get_direction(struct gpio_chip *chip, unsigned int offset) { struct gpiomm_gpio *const gpiommgpio =3D gpiochip_get_data(chip); - const unsigned int port =3D offset / 8; - const unsigned int mask =3D BIT(offset % 8); =20 - if (gpiommgpio->io_state[port] & mask) + if (i8255_get_direction(gpiommgpio->ppi_state, offset)) return GPIO_LINE_DIRECTION_IN; =20 return GPIO_LINE_DIRECTION_OUT; @@ -62,35 +57,8 @@ static int gpiomm_gpio_direction_input(struct gpio_chip = *chip, unsigned int offset) { struct gpiomm_gpio *const gpiommgpio =3D gpiochip_get_data(chip); - const unsigned int io_port =3D offset / 8; - const unsigned int control_port =3D io_port / 3; - unsigned long flags; - unsigned int control; - - spin_lock_irqsave(&gpiommgpio->lock, flags); - - /* Check if configuring Port C */ - if (io_port =3D=3D 2 || io_port =3D=3D 5) { - /* Port C can be configured by nibble */ - if (offset % 8 > 3) { - gpiommgpio->io_state[io_port] |=3D 0xF0; - gpiommgpio->control[control_port] |=3D BIT(3); - } else { - gpiommgpio->io_state[io_port] |=3D 0x0F; - gpiommgpio->control[control_port] |=3D BIT(0); - } - } else { - gpiommgpio->io_state[io_port] |=3D 0xFF; - if (io_port =3D=3D 0 || io_port =3D=3D 3) - gpiommgpio->control[control_port] |=3D BIT(4); - else - gpiommgpio->control[control_port] |=3D BIT(1); - } =20 - control =3D BIT(7) | gpiommgpio->control[control_port]; - iowrite8(control, gpiommgpio->base + 3 + control_port*4); - - spin_unlock_irqrestore(&gpiommgpio->lock, flags); + i8255_direction_input(gpiommgpio->ppi, gpiommgpio->ppi_state, offset); =20 return 0; } @@ -99,44 +67,9 @@ static int gpiomm_gpio_direction_output(struct gpio_chip= *chip, unsigned int offset, int value) { struct gpiomm_gpio *const gpiommgpio =3D gpiochip_get_data(chip); - const unsigned int io_port =3D offset / 8; - const unsigned int control_port =3D io_port / 3; - const unsigned int mask =3D BIT(offset % 8); - const unsigned int out_port =3D (io_port > 2) ? io_port + 1 : io_port; - unsigned long flags; - unsigned int control; - - spin_lock_irqsave(&gpiommgpio->lock, flags); - - /* Check if configuring Port C */ - if (io_port =3D=3D 2 || io_port =3D=3D 5) { - /* Port C can be configured by nibble */ - if (offset % 8 > 3) { - gpiommgpio->io_state[io_port] &=3D 0x0F; - gpiommgpio->control[control_port] &=3D ~BIT(3); - } else { - gpiommgpio->io_state[io_port] &=3D 0xF0; - gpiommgpio->control[control_port] &=3D ~BIT(0); - } - } else { - gpiommgpio->io_state[io_port] &=3D 0x00; - if (io_port =3D=3D 0 || io_port =3D=3D 3) - gpiommgpio->control[control_port] &=3D ~BIT(4); - else - gpiommgpio->control[control_port] &=3D ~BIT(1); - } - - if (value) - gpiommgpio->out_state[io_port] |=3D mask; - else - gpiommgpio->out_state[io_port] &=3D ~mask; - - control =3D BIT(7) | gpiommgpio->control[control_port]; - iowrite8(control, gpiommgpio->base + 3 + control_port*4); =20 - iowrite8(gpiommgpio->out_state[io_port], gpiommgpio->base + out_port); - - spin_unlock_irqrestore(&gpiommgpio->lock, flags); + i8255_direction_output(gpiommgpio->ppi, gpiommgpio->ppi_state, offset, + value); =20 return 0; } @@ -144,47 +77,16 @@ static int gpiomm_gpio_direction_output(struct gpio_ch= ip *chip, static int gpiomm_gpio_get(struct gpio_chip *chip, unsigned int offset) { struct gpiomm_gpio *const gpiommgpio =3D gpiochip_get_data(chip); - const unsigned int port =3D offset / 8; - const unsigned int mask =3D BIT(offset % 8); - const unsigned int in_port =3D (port > 2) ? port + 1 : port; - unsigned long flags; - unsigned int port_state; - - spin_lock_irqsave(&gpiommgpio->lock, flags); - - /* ensure that GPIO is set for input */ - if (!(gpiommgpio->io_state[port] & mask)) { - spin_unlock_irqrestore(&gpiommgpio->lock, flags); - return -EINVAL; - } - - port_state =3D ioread8(gpiommgpio->base + in_port); - - spin_unlock_irqrestore(&gpiommgpio->lock, flags); =20 - return !!(port_state & mask); + return i8255_get(gpiommgpio->ppi, offset); } =20 -static const size_t ports[] =3D { 0, 1, 2, 4, 5, 6 }; - static int gpiomm_gpio_get_multiple(struct gpio_chip *chip, unsigned long = *mask, unsigned long *bits) { struct gpiomm_gpio *const gpiommgpio =3D gpiochip_get_data(chip); - unsigned long offset; - unsigned long gpio_mask; - void __iomem *port_addr; - unsigned long port_state; - - /* clear bits array to a clean slate */ - bitmap_zero(bits, chip->ngpio); =20 - for_each_set_clump8(offset, gpio_mask, mask, ARRAY_SIZE(ports) * 8) { - port_addr =3D gpiommgpio->base + ports[offset / 8]; - port_state =3D ioread8(port_addr) & gpio_mask; - - bitmap_set_value8(bits, port_state, offset); - } + i8255_get_multiple(gpiommgpio->ppi, mask, bits, chip->ngpio); =20 return 0; } @@ -193,49 +95,17 @@ static void gpiomm_gpio_set(struct gpio_chip *chip, un= signed int offset, int value) { struct gpiomm_gpio *const gpiommgpio =3D gpiochip_get_data(chip); - const unsigned int port =3D offset / 8; - const unsigned int mask =3D BIT(offset % 8); - const unsigned int out_port =3D (port > 2) ? port + 1 : port; - unsigned long flags; - - spin_lock_irqsave(&gpiommgpio->lock, flags); - - if (value) - gpiommgpio->out_state[port] |=3D mask; - else - gpiommgpio->out_state[port] &=3D ~mask; - - iowrite8(gpiommgpio->out_state[port], gpiommgpio->base + out_port); =20 - spin_unlock_irqrestore(&gpiommgpio->lock, flags); + i8255_set(gpiommgpio->ppi, gpiommgpio->ppi_state, offset, value); } =20 static void gpiomm_gpio_set_multiple(struct gpio_chip *chip, unsigned long *mask, unsigned long *bits) { struct gpiomm_gpio *const gpiommgpio =3D gpiochip_get_data(chip); - unsigned long offset; - unsigned long gpio_mask; - size_t index; - void __iomem *port_addr; - unsigned long bitmask; - unsigned long flags; - - for_each_set_clump8(offset, gpio_mask, mask, ARRAY_SIZE(ports) * 8) { - index =3D offset / 8; - port_addr =3D gpiommgpio->base + ports[index]; - - bitmask =3D bitmap_get_value8(bits, offset) & gpio_mask; - - spin_lock_irqsave(&gpiommgpio->lock, flags); =20 - /* update output state data and set device gpio register */ - gpiommgpio->out_state[index] &=3D ~gpio_mask; - gpiommgpio->out_state[index] |=3D bitmask; - iowrite8(gpiommgpio->out_state[index], port_addr); - - spin_unlock_irqrestore(&gpiommgpio->lock, flags); - } + i8255_set_multiple(gpiommgpio->ppi, gpiommgpio->ppi_state, mask, bits, + chip->ngpio); } =20 #define GPIOMM_NGPIO 48 @@ -250,6 +120,21 @@ static const char *gpiomm_names[GPIOMM_NGPIO] =3D { "Port 2C2", "Port 2C3", "Port 2C4", "Port 2C5", "Port 2C6", "Port 2C7", }; =20 +static void gpiomm_init_dio(struct i8255 __iomem *const ppi, + struct i8255_state *const ppi_state) +{ + const unsigned long ngpio =3D 24; + const unsigned long mask =3D GENMASK(ngpio - 1, 0); + const unsigned long bits =3D 0; + unsigned long i; + + /* Initialize all GPIO to output 0 */ + for (i =3D 0; i < GPIOMM_NUM_PPI; i++) { + i8255_mode0_output(&ppi[i]); + i8255_set_multiple(&ppi[i], &ppi_state[i], &mask, &bits, ngpio); + } +} + static int gpiomm_probe(struct device *dev, unsigned int id) { struct gpiomm_gpio *gpiommgpio; @@ -266,8 +151,8 @@ static int gpiomm_probe(struct device *dev, unsigned in= t id) return -EBUSY; } =20 - gpiommgpio->base =3D devm_ioport_map(dev, base[id], GPIOMM_EXTENT); - if (!gpiommgpio->base) + gpiommgpio->ppi =3D devm_ioport_map(dev, base[id], GPIOMM_EXTENT); + if (!gpiommgpio->ppi) return -ENOMEM; =20 gpiommgpio->chip.label =3D name; @@ -284,7 +169,8 @@ static int gpiomm_probe(struct device *dev, unsigned in= t id) gpiommgpio->chip.set =3D gpiomm_gpio_set; gpiommgpio->chip.set_multiple =3D gpiomm_gpio_set_multiple; =20 - spin_lock_init(&gpiommgpio->lock); + i8255_state_init(gpiommgpio->ppi_state, GPIOMM_NUM_PPI); + gpiomm_init_dio(gpiommgpio->ppi, gpiommgpio->ppi_state); =20 err =3D devm_gpiochip_add_data(dev, &gpiommgpio->chip, gpiommgpio); if (err) { @@ -292,16 +178,6 @@ static int gpiomm_probe(struct device *dev, unsigned i= nt id) return err; } =20 - /* initialize all GPIO as output */ - iowrite8(0x80, gpiommgpio->base + 3); - iowrite8(0x00, gpiommgpio->base); - iowrite8(0x00, gpiommgpio->base + 1); - iowrite8(0x00, gpiommgpio->base + 2); - iowrite8(0x80, gpiommgpio->base + 7); - iowrite8(0x00, gpiommgpio->base + 4); - iowrite8(0x00, gpiommgpio->base + 5); - iowrite8(0x00, gpiommgpio->base + 6); - return 0; } =20 --=20 2.36.1