target/linux/omap24xx/patches-3.1/252-cbus-retu-tahvo-ack-fix.patch

   1 Index: linux-3.1.1/drivers/cbus/retu.c
   2 ===================================================================
   3 --- linux-3.1.1.orig/drivers/cbus/retu.c        2011-11-17 23:23:53.542699149 +0100
   4 +++ linux-3.1.1/drivers/cbus/retu.c     2011-11-17 23:23:55.830689859 +0100
   5 @@ -53,9 +53,6 @@ struct retu {
   6
   7         int                     irq;
   8
   9 -       int                     ack;
  10 -       bool                    ack_pending;
  11 -
  12         int                     mask;
  13         bool                    mask_pending;
  14
  15 @@ -191,9 +188,10 @@ static irqreturn_t retu_irq_handler(int
  16         mutex_lock(&retu->mutex);
  17         idr = __retu_read_reg(retu, RETU_REG_IDR);
  18         imr = __retu_read_reg(retu, RETU_REG_IMR);
  19 +       idr &= ~imr;
  20 +       __retu_write_reg(retu, RETU_REG_IDR, idr);
  21         mutex_unlock(&retu->mutex);
  22
  23 -       idr &= ~imr;
  24         if (!idr) {
  25                 dev_vdbg(retu->dev, "No IRQ, spurious?\n");
  26                 return IRQ_NONE;
  27 @@ -232,15 +230,6 @@ static void retu_irq_unmask(struct irq_d
  28
  29  }
  30
  31 -static void retu_irq_ack(struct irq_data *data)
  32 -{
  33 -       struct retu             *retu = irq_data_get_irq_chip_data(data);
  34 -       int                     irq = data->irq;
  35 -
  36 -       retu->ack |= (1 << (irq - retu->irq_base));
  37 -       retu->ack_pending = true;
  38 -}
  39 -
  40  static void retu_bus_lock(struct irq_data *data)
  41  {
  42         struct retu             *retu = irq_data_get_irq_chip_data(data);
  43 @@ -257,11 +246,6 @@ static void retu_bus_sync_unlock(struct
  44                 retu->mask_pending = false;
  45         }
  46
  47 -       if (retu->ack_pending) {
  48 -               __retu_write_reg(retu, RETU_REG_IDR, retu->ack);
  49 -               retu->ack_pending = false;
  50 -       }
  51 -
  52         mutex_unlock(&retu->mutex);
  53  }
  54
  55 @@ -271,7 +255,6 @@ static struct irq_chip retu_irq_chip = {
  56         .irq_bus_sync_unlock    = retu_bus_sync_unlock,
  57         .irq_mask               = retu_irq_mask,
  58         .irq_unmask             = retu_irq_unmask,
  59 -       .irq_ack                = retu_irq_ack,
  60  };
  61
  62  static inline void retu_irq_setup(int irq)
  63 @@ -291,8 +274,7 @@ static void retu_irq_init(struct retu *r
  64
  65         for (irq = base; irq < end; irq++) {
  66                 irq_set_chip_data(irq, retu);
  67 -               irq_set_chip_and_handler(irq, &retu_irq_chip,
  68 -                               handle_simple_irq);
  69 +               irq_set_chip(irq, &retu_irq_chip);
  70                 irq_set_nested_thread(irq, 1);
  71                 retu_irq_setup(irq);
  72         }
  73 Index: linux-3.1.1/drivers/cbus/tahvo.c
  74 ===================================================================
  75 --- linux-3.1.1.orig/drivers/cbus/tahvo.c       2011-11-17 23:23:54.358695836 +0100
  76 +++ linux-3.1.1/drivers/cbus/tahvo.c    2011-11-17 23:23:55.830689859 +0100
  77 @@ -48,11 +48,9 @@ struct tahvo {
  78         int             irq_end;
  79         int             irq;
  80
  81 -       int             ack;
  82         int             mask;
  83
  84         unsigned int    mask_pending:1;
  85 -       unsigned int    ack_pending:1;
  86         unsigned int    is_betty:1;
  87  };
  88
  89 @@ -138,9 +136,12 @@ static irqreturn_t tahvo_irq_handler(int
  90         u16                     id;
  91         u16                     im;
  92
  93 +       mutex_lock(&tahvo->mutex);
  94         id = __tahvo_read_reg(tahvo, TAHVO_REG_IDR);
  95         im = __tahvo_read_reg(tahvo, TAHVO_REG_IMR);
  96         id &= ~im;
  97 +       __tahvo_write_reg(tahvo, TAHVO_REG_IDR, id);
  98 +       mutex_unlock(&tahvo->mutex);
  99
 100         if (!id) {
 101                 dev_vdbg(tahvo->dev, "No IRQ, spurious ?\n");
 102 @@ -177,11 +178,6 @@ static void tahvo_irq_bus_sync_unlock(st
 103                 tahvo->mask_pending = false;
 104         }
 105
 106 -       if (tahvo->ack_pending) {
 107 -               __tahvo_write_reg(tahvo, TAHVO_REG_IDR, tahvo->ack);
 108 -               tahvo->ack_pending = false;
 109 -       }
 110 -
 111         mutex_unlock(&tahvo->mutex);
 112  }
 113
 114 @@ -203,22 +199,12 @@ static void tahvo_irq_unmask(struct irq_
 115         tahvo->mask_pending = true;
 116  }
 117
 118 -static void tahvo_irq_ack(struct irq_data *data)
 119 -{
 120 -       struct tahvo            *tahvo = irq_data_get_irq_chip_data(data);
 121 -       int                     irq = data->irq;
 122 -
 123 -       tahvo->ack |= (1 << (irq - tahvo->irq_base));
 124 -       tahvo->ack_pending = true;
 125 -}
 126 -
 127  static struct irq_chip tahvo_irq_chip = {
 128         .name                   = "tahvo",
 129         .irq_bus_lock           = tahvo_irq_bus_lock,
 130         .irq_bus_sync_unlock    = tahvo_irq_bus_sync_unlock,
 131         .irq_mask               = tahvo_irq_mask,
 132         .irq_unmask             = tahvo_irq_unmask,
 133 -       .irq_ack                = tahvo_irq_ack,
 134  };
 135
 136  static inline void tahvo_irq_setup(int irq)
 137 @@ -238,8 +224,7 @@ static void tahvo_irq_init(struct tahvo
 138
 139         for (irq = base; irq < end; irq++) {
 140                 irq_set_chip_data(irq, tahvo);
 141 -               irq_set_chip_and_handler(irq, &tahvo_irq_chip,
 142 -                               handle_simple_irq);
 143 +               irq_set_chip(irq, &tahvo_irq_chip);
 144                 irq_set_nested_thread(irq, 1);
 145                 tahvo_irq_setup(irq);
 146         }