LCOV - code coverage report
Current view: top level - drivers/gpio - gpio-stmpe.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 2 208 1.0 %
Date: 2020-09-30 20:25:40 Functions: 1 17 5.9 %
Branches: 0 98 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * Copyright (C) ST-Ericsson SA 2010
       4                 :            :  *
       5                 :            :  * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
       6                 :            :  */
       7                 :            : 
       8                 :            : #include <linux/init.h>
       9                 :            : #include <linux/platform_device.h>
      10                 :            : #include <linux/slab.h>
      11                 :            : #include <linux/gpio/driver.h>
      12                 :            : #include <linux/interrupt.h>
      13                 :            : #include <linux/of.h>
      14                 :            : #include <linux/mfd/stmpe.h>
      15                 :            : #include <linux/seq_file.h>
      16                 :            : #include <linux/bitops.h>
      17                 :            : 
      18                 :            : /*
      19                 :            :  * These registers are modified under the irq bus lock and cached to avoid
      20                 :            :  * unnecessary writes in bus_sync_unlock.
      21                 :            :  */
      22                 :            : enum { REG_RE, REG_FE, REG_IE };
      23                 :            : 
      24                 :            : enum { LSB, CSB, MSB };
      25                 :            : 
      26                 :            : #define CACHE_NR_REGS   3
      27                 :            : /* No variant has more than 24 GPIOs */
      28                 :            : #define CACHE_NR_BANKS  (24 / 8)
      29                 :            : 
      30                 :            : struct stmpe_gpio {
      31                 :            :         struct gpio_chip chip;
      32                 :            :         struct stmpe *stmpe;
      33                 :            :         struct device *dev;
      34                 :            :         struct mutex irq_lock;
      35                 :            :         u32 norequest_mask;
      36                 :            :         /* Caches of interrupt control registers for bus_lock */
      37                 :            :         u8 regs[CACHE_NR_REGS][CACHE_NR_BANKS];
      38                 :            :         u8 oldregs[CACHE_NR_REGS][CACHE_NR_BANKS];
      39                 :            : };
      40                 :            : 
      41                 :          0 : static int stmpe_gpio_get(struct gpio_chip *chip, unsigned offset)
      42                 :            : {
      43                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(chip);
      44                 :          0 :         struct stmpe *stmpe = stmpe_gpio->stmpe;
      45                 :          0 :         u8 reg = stmpe->regs[STMPE_IDX_GPMR_LSB + (offset / 8)];
      46                 :          0 :         u8 mask = BIT(offset % 8);
      47                 :            :         int ret;
      48                 :            : 
      49                 :          0 :         ret = stmpe_reg_read(stmpe, reg);
      50         [ #  # ]:          0 :         if (ret < 0)
      51                 :            :                 return ret;
      52                 :            : 
      53                 :          0 :         return !!(ret & mask);
      54                 :            : }
      55                 :            : 
      56                 :          0 : static void stmpe_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
      57                 :            : {
      58                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(chip);
      59                 :          0 :         struct stmpe *stmpe = stmpe_gpio->stmpe;
      60         [ #  # ]:          0 :         int which = val ? STMPE_IDX_GPSR_LSB : STMPE_IDX_GPCR_LSB;
      61                 :          0 :         u8 reg = stmpe->regs[which + (offset / 8)];
      62                 :          0 :         u8 mask = BIT(offset % 8);
      63                 :            : 
      64                 :            :         /*
      65                 :            :          * Some variants have single register for gpio set/clear functionality.
      66                 :            :          * For them we need to write 0 to clear and 1 to set.
      67                 :            :          */
      68         [ #  # ]:          0 :         if (stmpe->regs[STMPE_IDX_GPSR_LSB] == stmpe->regs[STMPE_IDX_GPCR_LSB])
      69         [ #  # ]:          0 :                 stmpe_set_bits(stmpe, reg, mask, val ? mask : 0);
      70                 :            :         else
      71                 :          0 :                 stmpe_reg_write(stmpe, reg, mask);
      72                 :          0 : }
      73                 :            : 
      74                 :          0 : static int stmpe_gpio_get_direction(struct gpio_chip *chip,
      75                 :            :                                     unsigned offset)
      76                 :            : {
      77                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(chip);
      78                 :          0 :         struct stmpe *stmpe = stmpe_gpio->stmpe;
      79                 :          0 :         u8 reg = stmpe->regs[STMPE_IDX_GPDR_LSB] - (offset / 8);
      80                 :          0 :         u8 mask = BIT(offset % 8);
      81                 :            :         int ret;
      82                 :            : 
      83                 :          0 :         ret = stmpe_reg_read(stmpe, reg);
      84         [ #  # ]:          0 :         if (ret < 0)
      85                 :            :                 return ret;
      86                 :            : 
      87                 :          0 :         return !(ret & mask);
      88                 :            : }
      89                 :            : 
      90                 :          0 : static int stmpe_gpio_direction_output(struct gpio_chip *chip,
      91                 :            :                                          unsigned offset, int val)
      92                 :            : {
      93                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(chip);
      94                 :          0 :         struct stmpe *stmpe = stmpe_gpio->stmpe;
      95                 :          0 :         u8 reg = stmpe->regs[STMPE_IDX_GPDR_LSB + (offset / 8)];
      96                 :          0 :         u8 mask = BIT(offset % 8);
      97                 :            : 
      98                 :          0 :         stmpe_gpio_set(chip, offset, val);
      99                 :            : 
     100                 :          0 :         return stmpe_set_bits(stmpe, reg, mask, mask);
     101                 :            : }
     102                 :            : 
     103                 :          0 : static int stmpe_gpio_direction_input(struct gpio_chip *chip,
     104                 :            :                                         unsigned offset)
     105                 :            : {
     106                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(chip);
     107                 :          0 :         struct stmpe *stmpe = stmpe_gpio->stmpe;
     108                 :          0 :         u8 reg = stmpe->regs[STMPE_IDX_GPDR_LSB + (offset / 8)];
     109                 :          0 :         u8 mask = BIT(offset % 8);
     110                 :            : 
     111                 :          0 :         return stmpe_set_bits(stmpe, reg, mask, 0);
     112                 :            : }
     113                 :            : 
     114                 :          0 : static int stmpe_gpio_request(struct gpio_chip *chip, unsigned offset)
     115                 :            : {
     116                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(chip);
     117                 :          0 :         struct stmpe *stmpe = stmpe_gpio->stmpe;
     118                 :            : 
     119         [ #  # ]:          0 :         if (stmpe_gpio->norequest_mask & BIT(offset))
     120                 :            :                 return -EINVAL;
     121                 :            : 
     122                 :          0 :         return stmpe_set_altfunc(stmpe, BIT(offset), STMPE_BLOCK_GPIO);
     123                 :            : }
     124                 :            : 
     125                 :            : static const struct gpio_chip template_chip = {
     126                 :            :         .label                  = "stmpe",
     127                 :            :         .owner                  = THIS_MODULE,
     128                 :            :         .get_direction          = stmpe_gpio_get_direction,
     129                 :            :         .direction_input        = stmpe_gpio_direction_input,
     130                 :            :         .get                    = stmpe_gpio_get,
     131                 :            :         .direction_output       = stmpe_gpio_direction_output,
     132                 :            :         .set                    = stmpe_gpio_set,
     133                 :            :         .request                = stmpe_gpio_request,
     134                 :            :         .can_sleep              = true,
     135                 :            : };
     136                 :            : 
     137                 :          0 : static int stmpe_gpio_irq_set_type(struct irq_data *d, unsigned int type)
     138                 :            : {
     139                 :            :         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
     140                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
     141                 :          0 :         int offset = d->hwirq;
     142                 :          0 :         int regoffset = offset / 8;
     143                 :          0 :         int mask = BIT(offset % 8);
     144                 :            : 
     145         [ #  # ]:          0 :         if (type & IRQ_TYPE_LEVEL_LOW || type & IRQ_TYPE_LEVEL_HIGH)
     146                 :            :                 return -EINVAL;
     147                 :            : 
     148                 :            :         /* STMPE801 and STMPE 1600 don't have RE and FE registers */
     149         [ #  # ]:          0 :         if (stmpe_gpio->stmpe->partnum == STMPE801 ||
     150                 :            :             stmpe_gpio->stmpe->partnum == STMPE1600)
     151                 :            :                 return 0;
     152                 :            : 
     153         [ #  # ]:          0 :         if (type & IRQ_TYPE_EDGE_RISING)
     154                 :          0 :                 stmpe_gpio->regs[REG_RE][regoffset] |= mask;
     155                 :            :         else
     156                 :          0 :                 stmpe_gpio->regs[REG_RE][regoffset] &= ~mask;
     157                 :            : 
     158         [ #  # ]:          0 :         if (type & IRQ_TYPE_EDGE_FALLING)
     159                 :          0 :                 stmpe_gpio->regs[REG_FE][regoffset] |= mask;
     160                 :            :         else
     161                 :          0 :                 stmpe_gpio->regs[REG_FE][regoffset] &= ~mask;
     162                 :            : 
     163                 :            :         return 0;
     164                 :            : }
     165                 :            : 
     166                 :          0 : static void stmpe_gpio_irq_lock(struct irq_data *d)
     167                 :            : {
     168                 :            :         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
     169                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
     170                 :            : 
     171                 :          0 :         mutex_lock(&stmpe_gpio->irq_lock);
     172                 :          0 : }
     173                 :            : 
     174                 :          0 : static void stmpe_gpio_irq_sync_unlock(struct irq_data *d)
     175                 :            : {
     176                 :            :         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
     177                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
     178                 :          0 :         struct stmpe *stmpe = stmpe_gpio->stmpe;
     179                 :          0 :         int num_banks = DIV_ROUND_UP(stmpe->num_gpios, 8);
     180                 :            :         static const u8 regmap[CACHE_NR_REGS][CACHE_NR_BANKS] = {
     181                 :            :                 [REG_RE][LSB] = STMPE_IDX_GPRER_LSB,
     182                 :            :                 [REG_RE][CSB] = STMPE_IDX_GPRER_CSB,
     183                 :            :                 [REG_RE][MSB] = STMPE_IDX_GPRER_MSB,
     184                 :            :                 [REG_FE][LSB] = STMPE_IDX_GPFER_LSB,
     185                 :            :                 [REG_FE][CSB] = STMPE_IDX_GPFER_CSB,
     186                 :            :                 [REG_FE][MSB] = STMPE_IDX_GPFER_MSB,
     187                 :            :                 [REG_IE][LSB] = STMPE_IDX_IEGPIOR_LSB,
     188                 :            :                 [REG_IE][CSB] = STMPE_IDX_IEGPIOR_CSB,
     189                 :            :                 [REG_IE][MSB] = STMPE_IDX_IEGPIOR_MSB,
     190                 :            :         };
     191                 :            :         int i, j;
     192                 :            : 
     193                 :            :         /*
     194                 :            :          * STMPE1600: to be able to get IRQ from pins,
     195                 :            :          * a read must be done on GPMR register, or a write in
     196                 :            :          * GPSR or GPCR registers
     197                 :            :          */
     198         [ #  # ]:          0 :         if (stmpe->partnum == STMPE1600) {
     199                 :          0 :                 stmpe_reg_read(stmpe, stmpe->regs[STMPE_IDX_GPMR_LSB]);
     200                 :          0 :                 stmpe_reg_read(stmpe, stmpe->regs[STMPE_IDX_GPMR_CSB]);
     201                 :            :         }
     202                 :            : 
     203         [ #  # ]:          0 :         for (i = 0; i < CACHE_NR_REGS; i++) {
     204                 :            :                 /* STMPE801 and STMPE1600 don't have RE and FE registers */
     205         [ #  # ]:          0 :                 if ((stmpe->partnum == STMPE801 ||
     206         [ #  # ]:          0 :                      stmpe->partnum == STMPE1600) &&
     207                 :            :                      (i != REG_IE))
     208                 :          0 :                         continue;
     209                 :            : 
     210         [ #  # ]:          0 :                 for (j = 0; j < num_banks; j++) {
     211                 :          0 :                         u8 old = stmpe_gpio->oldregs[i][j];
     212                 :          0 :                         u8 new = stmpe_gpio->regs[i][j];
     213                 :            : 
     214         [ #  # ]:          0 :                         if (new == old)
     215                 :          0 :                                 continue;
     216                 :            : 
     217                 :          0 :                         stmpe_gpio->oldregs[i][j] = new;
     218                 :          0 :                         stmpe_reg_write(stmpe, stmpe->regs[regmap[i][j]], new);
     219                 :            :                 }
     220                 :            :         }
     221                 :            : 
     222                 :          0 :         mutex_unlock(&stmpe_gpio->irq_lock);
     223                 :          0 : }
     224                 :            : 
     225                 :          0 : static void stmpe_gpio_irq_mask(struct irq_data *d)
     226                 :            : {
     227                 :            :         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
     228                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
     229                 :          0 :         int offset = d->hwirq;
     230                 :          0 :         int regoffset = offset / 8;
     231                 :          0 :         int mask = BIT(offset % 8);
     232                 :            : 
     233                 :          0 :         stmpe_gpio->regs[REG_IE][regoffset] &= ~mask;
     234                 :          0 : }
     235                 :            : 
     236                 :          0 : static void stmpe_gpio_irq_unmask(struct irq_data *d)
     237                 :            : {
     238                 :            :         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
     239                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
     240                 :          0 :         int offset = d->hwirq;
     241                 :          0 :         int regoffset = offset / 8;
     242                 :          0 :         int mask = BIT(offset % 8);
     243                 :            : 
     244                 :          0 :         stmpe_gpio->regs[REG_IE][regoffset] |= mask;
     245                 :          0 : }
     246                 :            : 
     247                 :          0 : static void stmpe_dbg_show_one(struct seq_file *s,
     248                 :            :                                struct gpio_chip *gc,
     249                 :            :                                unsigned offset, unsigned gpio)
     250                 :            : {
     251                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
     252                 :          0 :         struct stmpe *stmpe = stmpe_gpio->stmpe;
     253                 :          0 :         const char *label = gpiochip_is_requested(gc, offset);
     254                 :          0 :         bool val = !!stmpe_gpio_get(gc, offset);
     255                 :          0 :         u8 bank = offset / 8;
     256                 :          0 :         u8 dir_reg = stmpe->regs[STMPE_IDX_GPDR_LSB + bank];
     257                 :          0 :         u8 mask = BIT(offset % 8);
     258                 :            :         int ret;
     259                 :            :         u8 dir;
     260                 :            : 
     261                 :          0 :         ret = stmpe_reg_read(stmpe, dir_reg);
     262         [ #  # ]:          0 :         if (ret < 0)
     263                 :            :                 return;
     264                 :          0 :         dir = !!(ret & mask);
     265                 :            : 
     266         [ #  # ]:          0 :         if (dir) {
     267   [ #  #  #  # ]:          0 :                 seq_printf(s, " gpio-%-3d (%-20.20s) out %s",
     268                 :            :                            gpio, label ?: "(none)",
     269                 :            :                            val ? "hi" : "lo");
     270                 :            :         } else {
     271                 :            :                 u8 edge_det_reg;
     272                 :            :                 u8 rise_reg;
     273                 :            :                 u8 fall_reg;
     274                 :            :                 u8 irqen_reg;
     275                 :            : 
     276                 :            :                 static const char * const edge_det_values[] = {
     277                 :            :                         "edge-inactive",
     278                 :            :                         "edge-asserted",
     279                 :            :                         "not-supported"
     280                 :            :                 };
     281                 :            :                 static const char * const rise_values[] = {
     282                 :            :                         "no-rising-edge-detection",
     283                 :            :                         "rising-edge-detection",
     284                 :            :                         "not-supported"
     285                 :            :                 };
     286                 :            :                 static const char * const fall_values[] = {
     287                 :            :                         "no-falling-edge-detection",
     288                 :            :                         "falling-edge-detection",
     289                 :            :                         "not-supported"
     290                 :            :                 };
     291                 :            :                 #define NOT_SUPPORTED_IDX 2
     292                 :            :                 u8 edge_det = NOT_SUPPORTED_IDX;
     293                 :            :                 u8 rise = NOT_SUPPORTED_IDX;
     294                 :            :                 u8 fall = NOT_SUPPORTED_IDX;
     295                 :            :                 bool irqen;
     296                 :            : 
     297   [ #  #  #  # ]:          0 :                 switch (stmpe->partnum) {
     298                 :            :                 case STMPE610:
     299                 :            :                 case STMPE811:
     300                 :            :                 case STMPE1601:
     301                 :            :                 case STMPE2401:
     302                 :            :                 case STMPE2403:
     303                 :          0 :                         edge_det_reg = stmpe->regs[STMPE_IDX_GPEDR_LSB + bank];
     304                 :          0 :                         ret = stmpe_reg_read(stmpe, edge_det_reg);
     305         [ #  # ]:          0 :                         if (ret < 0)
     306                 :            :                                 return;
     307                 :          0 :                         edge_det = !!(ret & mask);
     308                 :            :                         /* fall through */
     309                 :            :                 case STMPE1801:
     310                 :          0 :                         rise_reg = stmpe->regs[STMPE_IDX_GPRER_LSB + bank];
     311                 :          0 :                         fall_reg = stmpe->regs[STMPE_IDX_GPFER_LSB + bank];
     312                 :            : 
     313                 :          0 :                         ret = stmpe_reg_read(stmpe, rise_reg);
     314         [ #  # ]:          0 :                         if (ret < 0)
     315                 :            :                                 return;
     316                 :          0 :                         rise = !!(ret & mask);
     317                 :          0 :                         ret = stmpe_reg_read(stmpe, fall_reg);
     318         [ #  # ]:          0 :                         if (ret < 0)
     319                 :            :                                 return;
     320                 :          0 :                         fall = !!(ret & mask);
     321                 :            :                         /* fall through */
     322                 :            :                 case STMPE801:
     323                 :            :                 case STMPE1600:
     324                 :          0 :                         irqen_reg = stmpe->regs[STMPE_IDX_IEGPIOR_LSB + bank];
     325                 :            :                         break;
     326                 :            : 
     327                 :            :                 default:
     328                 :            :                         return;
     329                 :            :                 }
     330                 :            : 
     331                 :          0 :                 ret = stmpe_reg_read(stmpe, irqen_reg);
     332         [ #  # ]:          0 :                 if (ret < 0)
     333                 :            :                         return;
     334                 :          0 :                 irqen = !!(ret & mask);
     335                 :            : 
     336   [ #  #  #  #  :          0 :                 seq_printf(s, " gpio-%-3d (%-20.20s) in  %s %13s %13s %25s %25s",
                   #  # ]
     337                 :            :                            gpio, label ?: "(none)",
     338                 :            :                            val ? "hi" : "lo",
     339                 :            :                            edge_det_values[edge_det],
     340                 :            :                            irqen ? "IRQ-enabled" : "IRQ-disabled",
     341                 :            :                            rise_values[rise],
     342                 :            :                            fall_values[fall]);
     343                 :            :         }
     344                 :            : }
     345                 :            : 
     346                 :          0 : static void stmpe_dbg_show(struct seq_file *s, struct gpio_chip *gc)
     347                 :            : {
     348                 :            :         unsigned i;
     349                 :          0 :         unsigned gpio = gc->base;
     350                 :            : 
     351         [ #  # ]:          0 :         for (i = 0; i < gc->ngpio; i++, gpio++) {
     352                 :          0 :                 stmpe_dbg_show_one(s, gc, i, gpio);
     353                 :          0 :                 seq_putc(s, '\n');
     354                 :            :         }
     355                 :          0 : }
     356                 :            : 
     357                 :            : static struct irq_chip stmpe_gpio_irq_chip = {
     358                 :            :         .name                   = "stmpe-gpio",
     359                 :            :         .irq_bus_lock           = stmpe_gpio_irq_lock,
     360                 :            :         .irq_bus_sync_unlock    = stmpe_gpio_irq_sync_unlock,
     361                 :            :         .irq_mask               = stmpe_gpio_irq_mask,
     362                 :            :         .irq_unmask             = stmpe_gpio_irq_unmask,
     363                 :            :         .irq_set_type           = stmpe_gpio_irq_set_type,
     364                 :            : };
     365                 :            : 
     366                 :            : #define MAX_GPIOS 24
     367                 :            : 
     368                 :          0 : static irqreturn_t stmpe_gpio_irq(int irq, void *dev)
     369                 :            : {
     370                 :            :         struct stmpe_gpio *stmpe_gpio = dev;
     371                 :          0 :         struct stmpe *stmpe = stmpe_gpio->stmpe;
     372                 :            :         u8 statmsbreg;
     373                 :          0 :         int num_banks = DIV_ROUND_UP(stmpe->num_gpios, 8);
     374                 :            :         u8 status[DIV_ROUND_UP(MAX_GPIOS, 8)];
     375                 :            :         int ret;
     376                 :            :         int i;
     377                 :            : 
     378                 :            :         /*
     379                 :            :          * the stmpe_block_read() call below, imposes to set statmsbreg
     380                 :            :          * with the register located at the lowest address. As STMPE1600
     381                 :            :          * variant is the only one which respect registers address's order
     382                 :            :          * (LSB regs located at lowest address than MSB ones) whereas all
     383                 :            :          * the others have a registers layout with MSB located before the
     384                 :            :          * LSB regs.
     385                 :            :          */
     386         [ #  # ]:          0 :         if (stmpe->partnum == STMPE1600)
     387                 :          0 :                 statmsbreg = stmpe->regs[STMPE_IDX_ISGPIOR_LSB];
     388                 :            :         else
     389                 :          0 :                 statmsbreg = stmpe->regs[STMPE_IDX_ISGPIOR_MSB];
     390                 :            : 
     391                 :          0 :         ret = stmpe_block_read(stmpe, statmsbreg, num_banks, status);
     392         [ #  # ]:          0 :         if (ret < 0)
     393                 :            :                 return IRQ_NONE;
     394                 :            : 
     395         [ #  # ]:          0 :         for (i = 0; i < num_banks; i++) {
     396         [ #  # ]:          0 :                 int bank = (stmpe_gpio->stmpe->partnum == STMPE1600) ? i :
     397                 :          0 :                            num_banks - i - 1;
     398                 :          0 :                 unsigned int enabled = stmpe_gpio->regs[REG_IE][bank];
     399                 :          0 :                 unsigned int stat = status[i];
     400                 :            : 
     401                 :          0 :                 stat &= enabled;
     402         [ #  # ]:          0 :                 if (!stat)
     403                 :          0 :                         continue;
     404                 :            : 
     405         [ #  # ]:          0 :                 while (stat) {
     406                 :            :                         int bit = __ffs(stat);
     407                 :          0 :                         int line = bank * 8 + bit;
     408                 :          0 :                         int child_irq = irq_find_mapping(stmpe_gpio->chip.irq.domain,
     409                 :            :                                                          line);
     410                 :            : 
     411                 :          0 :                         handle_nested_irq(child_irq);
     412                 :          0 :                         stat &= ~BIT(bit);
     413                 :            :                 }
     414                 :            : 
     415                 :            :                 /*
     416                 :            :                  * interrupt status register write has no effect on
     417                 :            :                  * 801/1801/1600, bits are cleared when read.
     418                 :            :                  * Edge detect register is not present on 801/1600/1801
     419                 :            :                  */
     420   [ #  #  #  # ]:          0 :                 if (stmpe->partnum != STMPE801 && stmpe->partnum != STMPE1600 &&
     421                 :            :                     stmpe->partnum != STMPE1801) {
     422                 :          0 :                         stmpe_reg_write(stmpe, statmsbreg + i, status[i]);
     423                 :          0 :                         stmpe_reg_write(stmpe,
     424                 :          0 :                                         stmpe->regs[STMPE_IDX_GPEDR_MSB] + i,
     425                 :            :                                         status[i]);
     426                 :            :                 }
     427                 :            :         }
     428                 :            : 
     429                 :            :         return IRQ_HANDLED;
     430                 :            : }
     431                 :            : 
     432                 :          0 : static void stmpe_init_irq_valid_mask(struct gpio_chip *gc,
     433                 :            :                                       unsigned long *valid_mask,
     434                 :            :                                       unsigned int ngpios)
     435                 :            : {
     436                 :          0 :         struct stmpe_gpio *stmpe_gpio = gpiochip_get_data(gc);
     437                 :            :         int i;
     438                 :            : 
     439         [ #  # ]:          0 :         if (!stmpe_gpio->norequest_mask)
     440                 :          0 :                 return;
     441                 :            : 
     442                 :            :         /* Forbid unused lines to be mapped as IRQs */
     443         [ #  # ]:          0 :         for (i = 0; i < sizeof(u32); i++) {
     444         [ #  # ]:          0 :                 if (stmpe_gpio->norequest_mask & BIT(i))
     445                 :          0 :                         clear_bit(i, valid_mask);
     446                 :            :         }
     447                 :            : }
     448                 :            : 
     449                 :          0 : static int stmpe_gpio_probe(struct platform_device *pdev)
     450                 :            : {
     451                 :          0 :         struct stmpe *stmpe = dev_get_drvdata(pdev->dev.parent);
     452                 :          0 :         struct device_node *np = pdev->dev.of_node;
     453                 :            :         struct stmpe_gpio *stmpe_gpio;
     454                 :            :         int ret, irq;
     455                 :            : 
     456         [ #  # ]:          0 :         if (stmpe->num_gpios > MAX_GPIOS) {
     457                 :          0 :                 dev_err(&pdev->dev, "Need to increase maximum GPIO number\n");
     458                 :          0 :                 return -EINVAL;
     459                 :            :         }
     460                 :            : 
     461                 :          0 :         stmpe_gpio = kzalloc(sizeof(*stmpe_gpio), GFP_KERNEL);
     462         [ #  # ]:          0 :         if (!stmpe_gpio)
     463                 :            :                 return -ENOMEM;
     464                 :            : 
     465                 :          0 :         mutex_init(&stmpe_gpio->irq_lock);
     466                 :            : 
     467                 :          0 :         stmpe_gpio->dev = &pdev->dev;
     468                 :          0 :         stmpe_gpio->stmpe = stmpe;
     469                 :          0 :         stmpe_gpio->chip = template_chip;
     470                 :          0 :         stmpe_gpio->chip.ngpio = stmpe->num_gpios;
     471                 :          0 :         stmpe_gpio->chip.parent = &pdev->dev;
     472                 :          0 :         stmpe_gpio->chip.of_node = np;
     473                 :          0 :         stmpe_gpio->chip.base = -1;
     474                 :            :         /*
     475                 :            :          * REVISIT: this makes sure the valid mask gets allocated and
     476                 :            :          * filled in when adding the gpio_chip, but the rest of the
     477                 :            :          * gpio_irqchip is still filled in using the old method
     478                 :            :          * in gpiochip_irqchip_add_nested() so clean this up once we
     479                 :            :          * get the gpio_irqchip to initialize while adding the
     480                 :            :          * gpio_chip also for threaded irqchips.
     481                 :            :          */
     482                 :          0 :         stmpe_gpio->chip.irq.init_valid_mask = stmpe_init_irq_valid_mask;
     483                 :            : 
     484                 :            :         if (IS_ENABLED(CONFIG_DEBUG_FS))
     485                 :          0 :                 stmpe_gpio->chip.dbg_show = stmpe_dbg_show;
     486                 :            : 
     487                 :          0 :         of_property_read_u32(np, "st,norequest-mask",
     488                 :            :                         &stmpe_gpio->norequest_mask);
     489                 :            : 
     490                 :          0 :         irq = platform_get_irq(pdev, 0);
     491         [ #  # ]:          0 :         if (irq < 0)
     492                 :          0 :                 dev_info(&pdev->dev,
     493                 :            :                         "device configured in no-irq mode: "
     494                 :            :                         "irqs are not available\n");
     495                 :            : 
     496                 :          0 :         ret = stmpe_enable(stmpe, STMPE_BLOCK_GPIO);
     497         [ #  # ]:          0 :         if (ret)
     498                 :            :                 goto out_free;
     499                 :            : 
     500                 :          0 :         ret = gpiochip_add_data(&stmpe_gpio->chip, stmpe_gpio);
     501         [ #  # ]:          0 :         if (ret) {
     502                 :          0 :                 dev_err(&pdev->dev, "unable to add gpiochip: %d\n", ret);
     503                 :          0 :                 goto out_disable;
     504                 :            :         }
     505                 :            : 
     506         [ #  # ]:          0 :         if (irq > 0) {
     507                 :          0 :                 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
     508                 :            :                                 stmpe_gpio_irq, IRQF_ONESHOT,
     509                 :            :                                 "stmpe-gpio", stmpe_gpio);
     510         [ #  # ]:          0 :                 if (ret) {
     511                 :          0 :                         dev_err(&pdev->dev, "unable to get irq: %d\n", ret);
     512                 :          0 :                         goto out_disable;
     513                 :            :                 }
     514                 :            :                 ret =  gpiochip_irqchip_add_nested(&stmpe_gpio->chip,
     515                 :            :                                                    &stmpe_gpio_irq_chip,
     516                 :            :                                                    0,
     517                 :            :                                                    handle_simple_irq,
     518                 :            :                                                    IRQ_TYPE_NONE);
     519         [ #  # ]:          0 :                 if (ret) {
     520                 :          0 :                         dev_err(&pdev->dev,
     521                 :            :                                 "could not connect irqchip to gpiochip\n");
     522                 :          0 :                         goto out_disable;
     523                 :            :                 }
     524                 :            : 
     525                 :          0 :                 gpiochip_set_nested_irqchip(&stmpe_gpio->chip,
     526                 :            :                                             &stmpe_gpio_irq_chip,
     527                 :            :                                             irq);
     528                 :            :         }
     529                 :            : 
     530                 :            :         platform_set_drvdata(pdev, stmpe_gpio);
     531                 :            : 
     532                 :          0 :         return 0;
     533                 :            : 
     534                 :            : out_disable:
     535                 :          0 :         stmpe_disable(stmpe, STMPE_BLOCK_GPIO);
     536                 :          0 :         gpiochip_remove(&stmpe_gpio->chip);
     537                 :            : out_free:
     538                 :          0 :         kfree(stmpe_gpio);
     539                 :          0 :         return ret;
     540                 :            : }
     541                 :            : 
     542                 :            : static struct platform_driver stmpe_gpio_driver = {
     543                 :            :         .driver = {
     544                 :            :                 .suppress_bind_attrs    = true,
     545                 :            :                 .name                   = "stmpe-gpio",
     546                 :            :         },
     547                 :            :         .probe          = stmpe_gpio_probe,
     548                 :            : };
     549                 :            : 
     550                 :        207 : static int __init stmpe_gpio_init(void)
     551                 :            : {
     552                 :        207 :         return platform_driver_register(&stmpe_gpio_driver);
     553                 :            : }
     554                 :            : subsys_initcall(stmpe_gpio_init);

Generated by: LCOV version 1.14