Merge tag 'edac_for_4.5' of git://git.kernel.org/pub/scm/linux/kernel/git/bp/bp

[cascardo/linux.git] / drivers / base / regmap / regmap-irq.c

diff --git a/drivers/base/regmap/regmap-irq.c b/drivers/base/regmap/regmap-irq.c
index 8d16db5..9b0d202 100644 (file)
--- a/drivers/base/regmap/regmap-irq.c
+++ b/drivers/base/regmap/regmap-irq.c
@@ -39,8 +39,11 @@ struct regmap_irq_chip_data {
        unsigned int *mask_buf;
        unsigned int *mask_buf_def;
        unsigned int *wake_buf;
+       unsigned int *type_buf;
+       unsigned int *type_buf_def;
 
        unsigned int irq_reg_stride;
+       unsigned int type_reg_stride;
 };
 
 static inline const
@@ -144,6 +147,22 @@ static void regmap_irq_sync_unlock(struct irq_data *data)
                }
        }
 
+       for (i = 0; i < d->chip->num_type_reg; i++) {
+               if (!d->type_buf_def[i])
+                       continue;
+               reg = d->chip->type_base +
+                       (i * map->reg_stride * d->type_reg_stride);
+               if (d->chip->type_invert)
+                       ret = regmap_update_bits(d->map, reg,
+                               d->type_buf_def[i], ~d->type_buf[i]);
+               else
+                       ret = regmap_update_bits(d->map, reg,
+                               d->type_buf_def[i], d->type_buf[i]);
+               if (ret != 0)
+                       dev_err(d->map->dev, "Failed to sync type in %x\n",
+                               reg);
+       }
+
        if (d->chip->runtime_pm)
                pm_runtime_put(map->dev);
 
@@ -178,6 +197,38 @@ static void regmap_irq_disable(struct irq_data *data)
        d->mask_buf[irq_data->reg_offset / map->reg_stride] |= irq_data->mask;
 }
 
+static int regmap_irq_set_type(struct irq_data *data, unsigned int type)
+{
+       struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data);
+       struct regmap *map = d->map;
+       const struct regmap_irq *irq_data = irq_to_regmap_irq(d, data->hwirq);
+       int reg = irq_data->type_reg_offset / map->reg_stride;
+
+       if (!(irq_data->type_rising_mask | irq_data->type_falling_mask))
+               return 0;
+
+       d->type_buf[reg] &= ~(irq_data->type_falling_mask |
+                                       irq_data->type_rising_mask);
+       switch (type) {
+       case IRQ_TYPE_EDGE_FALLING:
+               d->type_buf[reg] |= irq_data->type_falling_mask;
+               break;
+
+       case IRQ_TYPE_EDGE_RISING:
+               d->type_buf[reg] |= irq_data->type_rising_mask;
+               break;
+
+       case IRQ_TYPE_EDGE_BOTH:
+               d->type_buf[reg] |= (irq_data->type_falling_mask |
+                                       irq_data->type_rising_mask);
+               break;
+
+       default:
+               return -EINVAL;
+       }
+       return 0;
+}
+
 static int regmap_irq_set_wake(struct irq_data *data, unsigned int on)
 {
        struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data);
@@ -204,6 +255,7 @@ static const struct irq_chip regmap_irq_chip = {
        .irq_bus_sync_unlock    = regmap_irq_sync_unlock,
        .irq_disable            = regmap_irq_disable,
        .irq_enable             = regmap_irq_enable,
+       .irq_set_type           = regmap_irq_set_type,
        .irq_set_wake           = regmap_irq_set_wake,
 };
 
@@ -386,28 +438,40 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
        if (!d)
                return -ENOMEM;
 
-       d->status_buf = kzalloc(sizeof(unsigned int) * chip->num_regs,
+       d->status_buf = kcalloc(chip->num_regs, sizeof(unsigned int),
                                GFP_KERNEL);
        if (!d->status_buf)
                goto err_alloc;
 
-       d->mask_buf = kzalloc(sizeof(unsigned int) * chip->num_regs,
+       d->mask_buf = kcalloc(chip->num_regs, sizeof(unsigned int),
                              GFP_KERNEL);
        if (!d->mask_buf)
                goto err_alloc;
 
-       d->mask_buf_def = kzalloc(sizeof(unsigned int) * chip->num_regs,
+       d->mask_buf_def = kcalloc(chip->num_regs, sizeof(unsigned int),
                                  GFP_KERNEL);
        if (!d->mask_buf_def)
                goto err_alloc;
 
        if (chip->wake_base) {
-               d->wake_buf = kzalloc(sizeof(unsigned int) * chip->num_regs,
+               d->wake_buf = kcalloc(chip->num_regs, sizeof(unsigned int),
                                      GFP_KERNEL);
                if (!d->wake_buf)
                        goto err_alloc;
        }
 
+       if (chip->num_type_reg) {
+               d->type_buf_def = kcalloc(chip->num_type_reg,
+                                       sizeof(unsigned int), GFP_KERNEL);
+               if (!d->type_buf_def)
+                       goto err_alloc;
+
+               d->type_buf = kcalloc(chip->num_type_reg, sizeof(unsigned int),
+                                     GFP_KERNEL);
+               if (!d->type_buf)
+                       goto err_alloc;
+       }
+
        d->irq_chip = regmap_irq_chip;
        d->irq_chip.name = chip->name;
        d->irq = irq;
@@ -420,10 +484,16 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
        else
                d->irq_reg_stride = 1;
 
+       if (chip->type_reg_stride)
+               d->type_reg_stride = chip->type_reg_stride;
+       else
+               d->type_reg_stride = 1;
+
        if (!map->use_single_read && map->reg_stride == 1 &&
            d->irq_reg_stride == 1) {
-               d->status_reg_buf = kmalloc(map->format.val_bytes *
-                                           chip->num_regs, GFP_KERNEL);
+               d->status_reg_buf = kmalloc_array(chip->num_regs,
+                                                 map->format.val_bytes,
+                                                 GFP_KERNEL);
                if (!d->status_reg_buf)
                        goto err_alloc;
        }
@@ -511,6 +581,33 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
                }
        }
 
+       if (chip->num_type_reg) {
+               for (i = 0; i < chip->num_irqs; i++) {
+                       reg = chip->irqs[i].type_reg_offset / map->reg_stride;
+                       d->type_buf_def[reg] |= chip->irqs[i].type_rising_mask |
+                                       chip->irqs[i].type_falling_mask;
+               }
+               for (i = 0; i < chip->num_type_reg; ++i) {
+                       if (!d->type_buf_def[i])
+                               continue;
+
+                       reg = chip->type_base +
+                               (i * map->reg_stride * d->type_reg_stride);
+                       if (chip->type_invert)
+                               ret = regmap_update_bits(map, reg,
+                                       d->type_buf_def[i], 0xFF);
+                       else
+                               ret = regmap_update_bits(map, reg,
+                                       d->type_buf_def[i], 0x0);
+                       if (ret != 0) {
+                               dev_err(map->dev,
+                                       "Failed to set type in 0x%x: %x\n",
+                                       reg, ret);
+                               goto err_alloc;
+                       }
+               }
+       }
+
        if (irq_base)
                d->domain = irq_domain_add_legacy(map->dev->of_node,
                                                  chip->num_irqs, irq_base, 0,
@@ -541,6 +638,8 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
 err_domain:
        /* Should really dispose of the domain but... */
 err_alloc:
+       kfree(d->type_buf);
+       kfree(d->type_buf_def);
        kfree(d->wake_buf);
        kfree(d->mask_buf_def);
        kfree(d->mask_buf);
@@ -564,6 +663,8 @@ void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *d)
 
        free_irq(irq, d);
        irq_domain_remove(d->domain);
+       kfree(d->type_buf);
+       kfree(d->type_buf_def);
        kfree(d->wake_buf);
        kfree(d->mask_buf_def);
        kfree(d->mask_buf);