arch/x86/platform/uv/uv_irq.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * SGI UV IRQ functions
   7  *
   8  * Copyright (C) 2008 Silicon Graphics, Inc. All rights reserved.
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/rbtree.h>
  13 #include <linux/slab.h>
  14 #include <linux/irq.h>
  15
  16 #include <asm/apic.h>
  17 #include <asm/uv/uv_irq.h>
  18 #include <asm/uv/uv_hub.h>
  19
  20 /* MMR offset and pnode of hub sourcing interrupts for a given irq */
  21 struct uv_irq_2_mmr_pnode{
  22         struct rb_node          list;
  23         unsigned long           offset;
  24         int                     pnode;
  25         int                     irq;
  26 };
  27
  28 static DEFINE_SPINLOCK(uv_irq_lock);
  29 static struct rb_root           uv_irq_root;
  30
  31 static int uv_set_irq_affinity(struct irq_data *, const struct cpumask *, bool);
  32
  33 static void uv_noop(struct irq_data *data) { }
  34
  35 static void uv_ack_apic(struct irq_data *data)
  36 {
  37         ack_APIC_irq();
  38 }
  39
  40 static struct irq_chip uv_irq_chip = {
  41         .name                   = "UV-CORE",
  42         .irq_mask               = uv_noop,
  43         .irq_unmask             = uv_noop,
  44         .irq_eoi                = uv_ack_apic,
  45         .irq_set_affinity       = uv_set_irq_affinity,
  46 };
  47
  48 /*
  49  * Add offset and pnode information of the hub sourcing interrupts to the
  50  * rb tree for a specific irq.
  51  */
  52 static int uv_set_irq_2_mmr_info(int irq, unsigned long offset, unsigned blade)
  53 {
  54         struct rb_node **link = &uv_irq_root.rb_node;
  55         struct rb_node *parent = NULL;
  56         struct uv_irq_2_mmr_pnode *n;
  57         struct uv_irq_2_mmr_pnode *e;
  58         unsigned long irqflags;
  59
  60         n = kmalloc_node(sizeof(struct uv_irq_2_mmr_pnode), GFP_KERNEL,
  61                                 uv_blade_to_memory_nid(blade));
  62         if (!n)
  63                 return -ENOMEM;
  64
  65         n->irq = irq;
  66         n->offset = offset;
  67         n->pnode = uv_blade_to_pnode(blade);
  68         spin_lock_irqsave(&uv_irq_lock, irqflags);
  69         /* Find the right place in the rbtree: */
  70         while (*link) {
  71                 parent = *link;
  72                 e = rb_entry(parent, struct uv_irq_2_mmr_pnode, list);
  73
  74                 if (unlikely(irq == e->irq)) {
  75                         /* irq entry exists */
  76                         e->pnode = uv_blade_to_pnode(blade);
  77                         e->offset = offset;
  78                         spin_unlock_irqrestore(&uv_irq_lock, irqflags);
  79                         kfree(n);
  80                         return 0;
  81                 }
  82
  83                 if (irq < e->irq)
  84                         link = &(*link)->rb_left;
  85                 else
  86                         link = &(*link)->rb_right;
  87         }
  88
  89         /* Insert the node into the rbtree. */
  90         rb_link_node(&n->list, parent, link);
  91         rb_insert_color(&n->list, &uv_irq_root);
  92
  93         spin_unlock_irqrestore(&uv_irq_lock, irqflags);
  94         return 0;
  95 }
  96
  97 /* Retrieve offset and pnode information from the rb tree for a specific irq */
  98 int uv_irq_2_mmr_info(int irq, unsigned long *offset, int *pnode)
  99 {
 100         struct uv_irq_2_mmr_pnode *e;
 101         struct rb_node *n;
 102         unsigned long irqflags;
 103
 104         spin_lock_irqsave(&uv_irq_lock, irqflags);
 105         n = uv_irq_root.rb_node;
 106         while (n) {
 107                 e = rb_entry(n, struct uv_irq_2_mmr_pnode, list);
 108
 109                 if (e->irq == irq) {
 110                         *offset = e->offset;
 111                         *pnode = e->pnode;
 112                         spin_unlock_irqrestore(&uv_irq_lock, irqflags);
 113                         return 0;
 114                 }
 115
 116                 if (irq < e->irq)
 117                         n = n->rb_left;
 118                 else
 119                         n = n->rb_right;
 120         }
 121         spin_unlock_irqrestore(&uv_irq_lock, irqflags);
 122         return -1;
 123 }
 124
 125 /*
 126  * Re-target the irq to the specified CPU and enable the specified MMR located
 127  * on the specified blade to allow the sending of MSIs to the specified CPU.
 128  */
 129 static int
 130 arch_enable_uv_irq(char *irq_name, unsigned int irq, int cpu, int mmr_blade,
 131                        unsigned long mmr_offset, int limit)
 132 {
 133         const struct cpumask *eligible_cpu = cpumask_of(cpu);
 134         struct irq_cfg *cfg = irq_cfg(irq);
 135         unsigned long mmr_value;
 136         struct uv_IO_APIC_route_entry *entry;
 137         int mmr_pnode, err;
 138         unsigned int dest;
 139
 140         BUILD_BUG_ON(sizeof(struct uv_IO_APIC_route_entry) !=
 141                         sizeof(unsigned long));
 142
 143         err = assign_irq_vector(irq, cfg, eligible_cpu);
 144         if (err != 0)
 145                 return err;
 146
 147         err = apic->cpu_mask_to_apicid_and(eligible_cpu, eligible_cpu, &dest);
 148         if (err != 0)
 149                 return err;
 150
 151         if (limit == UV_AFFINITY_CPU)
 152                 irq_set_status_flags(irq, IRQ_NO_BALANCING);
 153         else
 154                 irq_set_status_flags(irq, IRQ_MOVE_PCNTXT);
 155
 156         irq_set_chip_and_handler_name(irq, &uv_irq_chip, handle_percpu_irq,
 157                                       irq_name);
 158
 159         mmr_value = 0;
 160         entry = (struct uv_IO_APIC_route_entry *)&mmr_value;
 161         entry->vector           = cfg->vector;
 162         entry->delivery_mode    = apic->irq_delivery_mode;
 163         entry->dest_mode        = apic->irq_dest_mode;
 164         entry->polarity         = 0;
 165         entry->trigger          = 0;
 166         entry->mask             = 0;
 167         entry->dest             = dest;
 168
 169         mmr_pnode = uv_blade_to_pnode(mmr_blade);
 170         uv_write_global_mmr64(mmr_pnode, mmr_offset, mmr_value);
 171
 172         if (cfg->move_in_progress)
 173                 send_cleanup_vector(cfg);
 174
 175         return irq;
 176 }
 177
 178 /*
 179  * Disable the specified MMR located on the specified blade so that MSIs are
 180  * longer allowed to be sent.
 181  */
 182 static void arch_disable_uv_irq(int mmr_pnode, unsigned long mmr_offset)
 183 {
 184         unsigned long mmr_value;
 185         struct uv_IO_APIC_route_entry *entry;
 186
 187         BUILD_BUG_ON(sizeof(struct uv_IO_APIC_route_entry) !=
 188                         sizeof(unsigned long));
 189
 190         mmr_value = 0;
 191         entry = (struct uv_IO_APIC_route_entry *)&mmr_value;
 192         entry->mask = 1;
 193
 194         uv_write_global_mmr64(mmr_pnode, mmr_offset, mmr_value);
 195 }
 196
 197 static int
 198 uv_set_irq_affinity(struct irq_data *data, const struct cpumask *mask,
 199                     bool force)
 200 {
 201         struct irq_cfg *cfg = irqd_cfg(data);
 202         unsigned int dest;
 203         unsigned long mmr_value, mmr_offset;
 204         struct uv_IO_APIC_route_entry *entry;
 205         int mmr_pnode;
 206
 207         if (apic_set_affinity(data, mask, &dest))
 208                 return -1;
 209
 210         mmr_value = 0;
 211         entry = (struct uv_IO_APIC_route_entry *)&mmr_value;
 212
 213         entry->vector           = cfg->vector;
 214         entry->delivery_mode    = apic->irq_delivery_mode;
 215         entry->dest_mode        = apic->irq_dest_mode;
 216         entry->polarity         = 0;
 217         entry->trigger          = 0;
 218         entry->mask             = 0;
 219         entry->dest             = dest;
 220
 221         /* Get previously stored MMR and pnode of hub sourcing interrupts */
 222         if (uv_irq_2_mmr_info(data->irq, &mmr_offset, &mmr_pnode))
 223                 return -1;
 224
 225         uv_write_global_mmr64(mmr_pnode, mmr_offset, mmr_value);
 226
 227         if (cfg->move_in_progress)
 228                 send_cleanup_vector(cfg);
 229
 230         return IRQ_SET_MASK_OK_NOCOPY;
 231 }
 232
 233 /*
 234  * Set up a mapping of an available irq and vector, and enable the specified
 235  * MMR that defines the MSI that is to be sent to the specified CPU when an
 236  * interrupt is raised.
 237  */
 238 int uv_setup_irq(char *irq_name, int cpu, int mmr_blade,
 239                  unsigned long mmr_offset, int limit)
 240 {
 241         int ret, irq = irq_alloc_hwirq(uv_blade_to_memory_nid(mmr_blade));
 242
 243         if (!irq)
 244                 return -EBUSY;
 245
 246         ret = arch_enable_uv_irq(irq_name, irq, cpu, mmr_blade, mmr_offset,
 247                 limit);
 248         if (ret == irq)
 249                 uv_set_irq_2_mmr_info(irq, mmr_offset, mmr_blade);
 250         else
 251                 irq_free_hwirq(irq);
 252
 253         return ret;
 254 }
 255 EXPORT_SYMBOL_GPL(uv_setup_irq);
 256
 257 /*
 258  * Tear down a mapping of an irq and vector, and disable the specified MMR that
 259  * defined the MSI that was to be sent to the specified CPU when an interrupt
 260  * was raised.
 261  *
 262  * Set mmr_blade and mmr_offset to what was passed in on uv_setup_irq().
 263  */
 264 void uv_teardown_irq(unsigned int irq)
 265 {
 266         struct uv_irq_2_mmr_pnode *e;
 267         struct rb_node *n;
 268         unsigned long irqflags;
 269
 270         spin_lock_irqsave(&uv_irq_lock, irqflags);
 271         n = uv_irq_root.rb_node;
 272         while (n) {
 273                 e = rb_entry(n, struct uv_irq_2_mmr_pnode, list);
 274                 if (e->irq == irq) {
 275                         arch_disable_uv_irq(e->pnode, e->offset);
 276                         rb_erase(n, &uv_irq_root);
 277                         kfree(e);
 278                         break;
 279                 }
 280                 if (irq < e->irq)
 281                         n = n->rb_left;
 282                 else
 283                         n = n->rb_right;
 284         }
 285         spin_unlock_irqrestore(&uv_irq_lock, irqflags);
 286         irq_free_hwirq(irq);
 287 }
 288 EXPORT_SYMBOL_GPL(uv_teardown_irq);