git.oblomov.eu Git - linux-2.6/blob - drivers/pci/msi.c

   1 /*
   2  * File:        msi.c
   3  * Purpose:     PCI Message Signaled Interrupt (MSI)
   4  *
   5  * Copyright (C) 2003-2004 Intel
   6  * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
   7  */
   8
   9 #include <linux/mm.h>
  10 #include <linux/irq.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/init.h>
  13 #include <linux/config.h>
  14 #include <linux/ioport.h>
  15 #include <linux/smp_lock.h>
  16 #include <linux/pci.h>
  17 #include <linux/proc_fs.h>
  18
  19 #include <asm/errno.h>
  20 #include <asm/io.h>
  21 #include <asm/smp.h>
  22
  23 #include "pci.h"
  24 #include "msi.h"
  25
  26 static DEFINE_SPINLOCK(msi_lock);
  27 static struct msi_desc* msi_desc[NR_IRQS] = { [0 ... NR_IRQS-1] = NULL };
  28 static kmem_cache_t* msi_cachep;
  29
  30 static int pci_msi_enable = 1;
  31 static int last_alloc_vector;
  32 static int nr_released_vectors;
  33 static int nr_reserved_vectors = NR_HP_RESERVED_VECTORS;
  34 static int nr_msix_devices;
  35
  36 #ifndef CONFIG_X86_IO_APIC
  37 int vector_irq[NR_VECTORS] = { [0 ... NR_VECTORS - 1] = -1};
  38 #endif
  39
  40 static struct msi_ops *msi_ops;
  41
  42 int
  43 msi_register(struct msi_ops *ops)
  44 {
  45         msi_ops = ops;
  46         return 0;
  47 }
  48
  49 static void msi_cache_ctor(void *p, kmem_cache_t *cache, unsigned long flags)
  50 {
  51         memset(p, 0, NR_IRQS * sizeof(struct msi_desc));
  52 }
  53
  54 static int msi_cache_init(void)
  55 {
  56         msi_cachep = kmem_cache_create("msi_cache",
  57                         NR_IRQS * sizeof(struct msi_desc),
  58                         0, SLAB_HWCACHE_ALIGN, msi_cache_ctor, NULL);
  59         if (!msi_cachep)
  60                 return -ENOMEM;
  61
  62         return 0;
  63 }
  64
  65 static void msi_set_mask_bit(unsigned int vector, int flag)
  66 {
  67         struct msi_desc *entry;
  68
  69         entry = (struct msi_desc *)msi_desc[vector];
  70         if (!entry || !entry->dev || !entry->mask_base)
  71                 return;
  72         switch (entry->msi_attrib.type) {
  73         case PCI_CAP_ID_MSI:
  74         {
  75                 int             pos;
  76                 u32             mask_bits;
  77
  78                 pos = (long)entry->mask_base;
  79                 pci_read_config_dword(entry->dev, pos, &mask_bits);
  80                 mask_bits &= ~(1);
  81                 mask_bits |= flag;
  82                 pci_write_config_dword(entry->dev, pos, mask_bits);
  83                 break;
  84         }
  85         case PCI_CAP_ID_MSIX:
  86         {
  87                 int offset = entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
  88                         PCI_MSIX_ENTRY_VECTOR_CTRL_OFFSET;
  89                 writel(flag, entry->mask_base + offset);
  90                 break;
  91         }
  92         default:
  93                 break;
  94         }
  95 }
  96
  97 #ifdef CONFIG_SMP
  98 static void set_msi_affinity(unsigned int vector, cpumask_t cpu_mask)
  99 {
 100         struct msi_desc *entry;
 101         u32 address_hi, address_lo;
 102         unsigned int irq = vector;
 103         unsigned int dest_cpu = first_cpu(cpu_mask);
 104
 105         entry = (struct msi_desc *)msi_desc[vector];
 106         if (!entry || !entry->dev)
 107                 return;
 108
 109         switch (entry->msi_attrib.type) {
 110         case PCI_CAP_ID_MSI:
 111         {
 112                 int pos = pci_find_capability(entry->dev, PCI_CAP_ID_MSI);
 113
 114                 if (!pos)
 115                         return;
 116
 117                 pci_read_config_dword(entry->dev, msi_upper_address_reg(pos),
 118                         &address_hi);
 119                 pci_read_config_dword(entry->dev, msi_lower_address_reg(pos),
 120                         &address_lo);
 121
 122                 msi_ops->target(vector, dest_cpu, &address_hi, &address_lo);
 123
 124                 pci_write_config_dword(entry->dev, msi_upper_address_reg(pos),
 125                         address_hi);
 126                 pci_write_config_dword(entry->dev, msi_lower_address_reg(pos),
 127                         address_lo);
 128                 set_native_irq_info(irq, cpu_mask);
 129                 break;
 130         }
 131         case PCI_CAP_ID_MSIX:
 132         {
 133                 int offset_hi =
 134                         entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
 135                                 PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET;
 136                 int offset_lo =
 137                         entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
 138                                 PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET;
 139
 140                 address_hi = readl(entry->mask_base + offset_hi);
 141                 address_lo = readl(entry->mask_base + offset_lo);
 142
 143                 msi_ops->target(vector, dest_cpu, &address_hi, &address_lo);
 144
 145                 writel(address_hi, entry->mask_base + offset_hi);
 146                 writel(address_lo, entry->mask_base + offset_lo);
 147                 set_native_irq_info(irq, cpu_mask);
 148                 break;
 149         }
 150         default:
 151                 break;
 152         }
 153 }
 154 #else
 155 #define set_msi_affinity NULL
 156 #endif /* CONFIG_SMP */
 157
 158 static void mask_MSI_irq(unsigned int vector)
 159 {
 160         msi_set_mask_bit(vector, 1);
 161 }
 162
 163 static void unmask_MSI_irq(unsigned int vector)
 164 {
 165         msi_set_mask_bit(vector, 0);
 166 }
 167
 168 static unsigned int startup_msi_irq_wo_maskbit(unsigned int vector)
 169 {
 170         struct msi_desc *entry;
 171         unsigned long flags;
 172
 173         spin_lock_irqsave(&msi_lock, flags);
 174         entry = msi_desc[vector];
 175         if (!entry || !entry->dev) {
 176                 spin_unlock_irqrestore(&msi_lock, flags);
 177                 return 0;
 178         }
 179         entry->msi_attrib.state = 1;    /* Mark it active */
 180         spin_unlock_irqrestore(&msi_lock, flags);
 181
 182         return 0;       /* never anything pending */
 183 }
 184
 185 static unsigned int startup_msi_irq_w_maskbit(unsigned int vector)
 186 {
 187         startup_msi_irq_wo_maskbit(vector);
 188         unmask_MSI_irq(vector);
 189         return 0;       /* never anything pending */
 190 }
 191
 192 static void shutdown_msi_irq(unsigned int vector)
 193 {
 194         struct msi_desc *entry;
 195         unsigned long flags;
 196
 197         spin_lock_irqsave(&msi_lock, flags);
 198         entry = msi_desc[vector];
 199         if (entry && entry->dev)
 200                 entry->msi_attrib.state = 0;    /* Mark it not active */
 201         spin_unlock_irqrestore(&msi_lock, flags);
 202 }
 203
 204 static void end_msi_irq_wo_maskbit(unsigned int vector)
 205 {
 206         move_native_irq(vector);
 207         ack_APIC_irq();
 208 }
 209
 210 static void end_msi_irq_w_maskbit(unsigned int vector)
 211 {
 212         move_native_irq(vector);
 213         unmask_MSI_irq(vector);
 214         ack_APIC_irq();
 215 }
 216
 217 static void do_nothing(unsigned int vector)
 218 {
 219 }
 220
 221 /*
 222  * Interrupt Type for MSI-X PCI/PCI-X/PCI-Express Devices,
 223  * which implement the MSI-X Capability Structure.
 224  */
 225 static struct hw_interrupt_type msix_irq_type = {
 226         .typename       = "PCI-MSI-X",
 227         .startup        = startup_msi_irq_w_maskbit,
 228         .shutdown       = shutdown_msi_irq,
 229         .enable         = unmask_MSI_irq,
 230         .disable        = mask_MSI_irq,
 231         .ack            = mask_MSI_irq,
 232         .end            = end_msi_irq_w_maskbit,
 233         .set_affinity   = set_msi_affinity
 234 };
 235
 236 /*
 237  * Interrupt Type for MSI PCI/PCI-X/PCI-Express Devices,
 238  * which implement the MSI Capability Structure with
 239  * Mask-and-Pending Bits.
 240  */
 241 static struct hw_interrupt_type msi_irq_w_maskbit_type = {
 242         .typename       = "PCI-MSI",
 243         .startup        = startup_msi_irq_w_maskbit,
 244         .shutdown       = shutdown_msi_irq,
 245         .enable         = unmask_MSI_irq,
 246         .disable        = mask_MSI_irq,
 247         .ack            = mask_MSI_irq,
 248         .end            = end_msi_irq_w_maskbit,
 249         .set_affinity   = set_msi_affinity
 250 };
 251
 252 /*
 253  * Interrupt Type for MSI PCI/PCI-X/PCI-Express Devices,
 254  * which implement the MSI Capability Structure without
 255  * Mask-and-Pending Bits.
 256  */
 257 static struct hw_interrupt_type msi_irq_wo_maskbit_type = {
 258         .typename       = "PCI-MSI",
 259         .startup        = startup_msi_irq_wo_maskbit,
 260         .shutdown       = shutdown_msi_irq,
 261         .enable         = do_nothing,
 262         .disable        = do_nothing,
 263         .ack            = do_nothing,
 264         .end            = end_msi_irq_wo_maskbit,
 265         .set_affinity   = set_msi_affinity
 266 };
 267
 268 static int msi_free_vector(struct pci_dev* dev, int vector, int reassign);
 269 static int assign_msi_vector(void)
 270 {
 271         static int new_vector_avail = 1;
 272         int vector;
 273         unsigned long flags;
 274
 275         /*
 276          * msi_lock is provided to ensure that successful allocation of MSI
 277          * vector is assigned unique among drivers.
 278          */
 279         spin_lock_irqsave(&msi_lock, flags);
 280
 281         if (!new_vector_avail) {
 282                 int free_vector = 0;
 283
 284                 /*
 285                  * vector_irq[] = -1 indicates that this specific vector is:
 286                  * - assigned for MSI (since MSI have no associated IRQ) or
 287                  * - assigned for legacy if less than 16, or
 288                  * - having no corresponding 1:1 vector-to-IOxAPIC IRQ mapping
 289                  * vector_irq[] = 0 indicates that this vector, previously
 290                  * assigned for MSI, is freed by hotplug removed operations.
 291                  * This vector will be reused for any subsequent hotplug added
 292                  * operations.
 293                  * vector_irq[] > 0 indicates that this vector is assigned for
 294                  * IOxAPIC IRQs. This vector and its value provides a 1-to-1
 295                  * vector-to-IOxAPIC IRQ mapping.
 296                  */
 297                 for (vector = FIRST_DEVICE_VECTOR; vector < NR_IRQS; vector++) {
 298                         if (vector_irq[vector] != 0)
 299                                 continue;
 300                         free_vector = vector;
 301                         if (!msi_desc[vector])
 302                                 break;
 303                         else
 304                                 continue;
 305                 }
 306                 if (!free_vector) {
 307                         spin_unlock_irqrestore(&msi_lock, flags);
 308                         return -EBUSY;
 309                 }
 310                 vector_irq[free_vector] = -1;
 311                 nr_released_vectors--;
 312                 spin_unlock_irqrestore(&msi_lock, flags);
 313                 if (msi_desc[free_vector] != NULL) {
 314                         struct pci_dev *dev;
 315                         int tail;
 316
 317                         /* free all linked vectors before re-assign */
 318                         do {
 319                                 spin_lock_irqsave(&msi_lock, flags);
 320                                 dev = msi_desc[free_vector]->dev;
 321                                 tail = msi_desc[free_vector]->link.tail;
 322                                 spin_unlock_irqrestore(&msi_lock, flags);
 323                                 msi_free_vector(dev, tail, 1);
 324                         } while (free_vector != tail);
 325                 }
 326
 327                 return free_vector;
 328         }
 329         vector = assign_irq_vector(AUTO_ASSIGN);
 330         last_alloc_vector = vector;
 331         if (vector  == LAST_DEVICE_VECTOR)
 332                 new_vector_avail = 0;
 333
 334         spin_unlock_irqrestore(&msi_lock, flags);
 335         return vector;
 336 }
 337
 338 static int get_new_vector(void)
 339 {
 340         int vector = assign_msi_vector();
 341
 342         if (vector > 0)
 343                 set_intr_gate(vector, interrupt[vector]);
 344
 345         return vector;
 346 }
 347
 348 static int msi_init(void)
 349 {
 350         static int status = -ENOMEM;
 351
 352         if (!status)
 353                 return status;
 354
 355         if (pci_msi_quirk) {
 356                 pci_msi_enable = 0;
 357                 printk(KERN_WARNING "PCI: MSI quirk detected. MSI disabled.\n");
 358                 status = -EINVAL;
 359                 return status;
 360         }
 361
 362         status = msi_arch_init();
 363         if (status < 0) {
 364                 pci_msi_enable = 0;
 365                 printk(KERN_WARNING
 366                        "PCI: MSI arch init failed.  MSI disabled.\n");
 367                 return status;
 368         }
 369
 370         if (! msi_ops) {
 371                 printk(KERN_WARNING
 372                        "PCI: MSI ops not registered. MSI disabled.\n");
 373                 status = -EINVAL;
 374                 return status;
 375         }
 376
 377         last_alloc_vector = assign_irq_vector(AUTO_ASSIGN);
 378         status = msi_cache_init();
 379         if (status < 0) {
 380                 pci_msi_enable = 0;
 381                 printk(KERN_WARNING "PCI: MSI cache init failed\n");
 382                 return status;
 383         }
 384
 385         if (last_alloc_vector < 0) {
 386                 pci_msi_enable = 0;
 387                 printk(KERN_WARNING "PCI: No interrupt vectors available for MSI\n");
 388                 status = -EBUSY;
 389                 return status;
 390         }
 391         vector_irq[last_alloc_vector] = 0;
 392         nr_released_vectors++;
 393
 394         return status;
 395 }
 396
 397 static int get_msi_vector(struct pci_dev *dev)
 398 {
 399         return get_new_vector();
 400 }
 401
 402 static struct msi_desc* alloc_msi_entry(void)
 403 {
 404         struct msi_desc *entry;
 405
 406         entry = kmem_cache_alloc(msi_cachep, SLAB_KERNEL);
 407         if (!entry)
 408                 return NULL;
 409
 410         memset(entry, 0, sizeof(struct msi_desc));
 411         entry->link.tail = entry->link.head = 0;        /* single message */
 412         entry->dev = NULL;
 413
 414         return entry;
 415 }
 416
 417 static void attach_msi_entry(struct msi_desc *entry, int vector)
 418 {
 419         unsigned long flags;
 420
 421         spin_lock_irqsave(&msi_lock, flags);
 422         msi_desc[vector] = entry;
 423         spin_unlock_irqrestore(&msi_lock, flags);
 424 }
 425
 426 static void irq_handler_init(int cap_id, int pos, int mask)
 427 {
 428         unsigned long flags;
 429
 430         spin_lock_irqsave(&irq_desc[pos].lock, flags);
 431         if (cap_id == PCI_CAP_ID_MSIX)
 432                 irq_desc[pos].handler = &msix_irq_type;
 433         else {
 434                 if (!mask)
 435                         irq_desc[pos].handler = &msi_irq_wo_maskbit_type;
 436                 else
 437                         irq_desc[pos].handler = &msi_irq_w_maskbit_type;
 438         }
 439         spin_unlock_irqrestore(&irq_desc[pos].lock, flags);
 440 }
 441
 442 static void enable_msi_mode(struct pci_dev *dev, int pos, int type)
 443 {
 444         u16 control;
 445
 446         pci_read_config_word(dev, msi_control_reg(pos), &control);
 447         if (type == PCI_CAP_ID_MSI) {
 448                 /* Set enabled bits to single MSI & enable MSI_enable bit */
 449                 msi_enable(control, 1);
 450                 pci_write_config_word(dev, msi_control_reg(pos), control);
 451                 dev->msi_enabled = 1;
 452         } else {
 453                 msix_enable(control);
 454                 pci_write_config_word(dev, msi_control_reg(pos), control);
 455                 dev->msix_enabled = 1;
 456         }
 457         if (pci_find_capability(dev, PCI_CAP_ID_EXP)) {
 458                 /* PCI Express Endpoint device detected */
 459                 pci_intx(dev, 0);  /* disable intx */
 460         }
 461 }
 462
 463 void disable_msi_mode(struct pci_dev *dev, int pos, int type)
 464 {
 465         u16 control;
 466
 467         pci_read_config_word(dev, msi_control_reg(pos), &control);
 468         if (type == PCI_CAP_ID_MSI) {
 469                 /* Set enabled bits to single MSI & enable MSI_enable bit */
 470                 msi_disable(control);
 471                 pci_write_config_word(dev, msi_control_reg(pos), control);
 472                 dev->msi_enabled = 0;
 473         } else {
 474                 msix_disable(control);
 475                 pci_write_config_word(dev, msi_control_reg(pos), control);
 476                 dev->msix_enabled = 0;
 477         }
 478         if (pci_find_capability(dev, PCI_CAP_ID_EXP)) {
 479                 /* PCI Express Endpoint device detected */
 480                 pci_intx(dev, 1);  /* enable intx */
 481         }
 482 }
 483
 484 static int msi_lookup_vector(struct pci_dev *dev, int type)
 485 {
 486         int vector;
 487         unsigned long flags;
 488
 489         spin_lock_irqsave(&msi_lock, flags);
 490         for (vector = FIRST_DEVICE_VECTOR; vector < NR_IRQS; vector++) {
 491                 if (!msi_desc[vector] || msi_desc[vector]->dev != dev ||
 492                         msi_desc[vector]->msi_attrib.type != type ||
 493                         msi_desc[vector]->msi_attrib.default_vector != dev->irq)
 494                         continue;
 495                 spin_unlock_irqrestore(&msi_lock, flags);
 496                 /* This pre-assigned MSI vector for this device
 497                    already exits. Override dev->irq with this vector */
 498                 dev->irq = vector;
 499                 return 0;
 500         }
 501         spin_unlock_irqrestore(&msi_lock, flags);
 502
 503         return -EACCES;
 504 }
 505
 506 void pci_scan_msi_device(struct pci_dev *dev)
 507 {
 508         if (!dev)
 509                 return;
 510
 511         if (pci_find_capability(dev, PCI_CAP_ID_MSIX) > 0)
 512                 nr_msix_devices++;
 513         else if (pci_find_capability(dev, PCI_CAP_ID_MSI) > 0)
 514                 nr_reserved_vectors++;
 515 }
 516
 517 #ifdef CONFIG_PM
 518 int pci_save_msi_state(struct pci_dev *dev)
 519 {
 520         int pos, i = 0;
 521         u16 control;
 522         struct pci_cap_saved_state *save_state;
 523         u32 *cap;
 524
 525         pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
 526         if (pos <= 0 || dev->no_msi)
 527                 return 0;
 528
 529         pci_read_config_word(dev, msi_control_reg(pos), &control);
 530         if (!(control & PCI_MSI_FLAGS_ENABLE))
 531                 return 0;
 532
 533         save_state = kzalloc(sizeof(struct pci_cap_saved_state) + sizeof(u32) * 5,
 534                 GFP_KERNEL);
 535         if (!save_state) {
 536                 printk(KERN_ERR "Out of memory in pci_save_msi_state\n");
 537                 return -ENOMEM;
 538         }
 539         cap = &save_state->data[0];
 540
 541         pci_read_config_dword(dev, pos, &cap[i++]);
 542         control = cap[0] >> 16;
 543         pci_read_config_dword(dev, pos + PCI_MSI_ADDRESS_LO, &cap[i++]);
 544         if (control & PCI_MSI_FLAGS_64BIT) {
 545                 pci_read_config_dword(dev, pos + PCI_MSI_ADDRESS_HI, &cap[i++]);
 546                 pci_read_config_dword(dev, pos + PCI_MSI_DATA_64, &cap[i++]);
 547         } else
 548                 pci_read_config_dword(dev, pos + PCI_MSI_DATA_32, &cap[i++]);
 549         if (control & PCI_MSI_FLAGS_MASKBIT)
 550                 pci_read_config_dword(dev, pos + PCI_MSI_MASK_BIT, &cap[i++]);
 551         save_state->cap_nr = PCI_CAP_ID_MSI;
 552         pci_add_saved_cap(dev, save_state);
 553         return 0;
 554 }
 555
 556 void pci_restore_msi_state(struct pci_dev *dev)
 557 {
 558         int i = 0, pos;
 559         u16 control;
 560         struct pci_cap_saved_state *save_state;
 561         u32 *cap;
 562
 563         save_state = pci_find_saved_cap(dev, PCI_CAP_ID_MSI);
 564         pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
 565         if (!save_state || pos <= 0)
 566                 return;
 567         cap = &save_state->data[0];
 568
 569         control = cap[i++] >> 16;
 570         pci_write_config_dword(dev, pos + PCI_MSI_ADDRESS_LO, cap[i++]);
 571         if (control & PCI_MSI_FLAGS_64BIT) {
 572                 pci_write_config_dword(dev, pos + PCI_MSI_ADDRESS_HI, cap[i++]);
 573                 pci_write_config_dword(dev, pos + PCI_MSI_DATA_64, cap[i++]);
 574         } else
 575                 pci_write_config_dword(dev, pos + PCI_MSI_DATA_32, cap[i++]);
 576         if (control & PCI_MSI_FLAGS_MASKBIT)
 577                 pci_write_config_dword(dev, pos + PCI_MSI_MASK_BIT, cap[i++]);
 578         pci_write_config_word(dev, pos + PCI_MSI_FLAGS, control);
 579         enable_msi_mode(dev, pos, PCI_CAP_ID_MSI);
 580         pci_remove_saved_cap(save_state);
 581         kfree(save_state);
 582 }
 583
 584 int pci_save_msix_state(struct pci_dev *dev)
 585 {
 586         int pos;
 587         int temp;
 588         int vector, head, tail = 0;
 589         u16 control;
 590         struct pci_cap_saved_state *save_state;
 591
 592         pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
 593         if (pos <= 0 || dev->no_msi)
 594                 return 0;
 595
 596         /* save the capability */
 597         pci_read_config_word(dev, msi_control_reg(pos), &control);
 598         if (!(control & PCI_MSIX_FLAGS_ENABLE))
 599                 return 0;
 600         save_state = kzalloc(sizeof(struct pci_cap_saved_state) + sizeof(u16),
 601                 GFP_KERNEL);
 602         if (!save_state) {
 603                 printk(KERN_ERR "Out of memory in pci_save_msix_state\n");
 604                 return -ENOMEM;
 605         }
 606         *((u16 *)&save_state->data[0]) = control;
 607
 608         /* save the table */
 609         temp = dev->irq;
 610         if (msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
 611                 kfree(save_state);
 612                 return -EINVAL;
 613         }
 614
 615         vector = head = dev->irq;
 616         while (head != tail) {
 617                 int j;
 618                 void __iomem *base;
 619                 struct msi_desc *entry;
 620
 621                 entry = msi_desc[vector];
 622                 base = entry->mask_base;
 623                 j = entry->msi_attrib.entry_nr;
 624
 625                 entry->address_lo_save =
 626                         readl(base + j * PCI_MSIX_ENTRY_SIZE +
 627                               PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
 628                 entry->address_hi_save =
 629                         readl(base + j * PCI_MSIX_ENTRY_SIZE +
 630                               PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
 631                 entry->data_save =
 632                         readl(base + j * PCI_MSIX_ENTRY_SIZE +
 633                               PCI_MSIX_ENTRY_DATA_OFFSET);
 634
 635                 tail = msi_desc[vector]->link.tail;
 636                 vector = tail;
 637         }
 638         dev->irq = temp;
 639
 640         save_state->cap_nr = PCI_CAP_ID_MSIX;
 641         pci_add_saved_cap(dev, save_state);
 642         return 0;
 643 }
 644
 645 void pci_restore_msix_state(struct pci_dev *dev)
 646 {
 647         u16 save;
 648         int pos;
 649         int vector, head, tail = 0;
 650         void __iomem *base;
 651         int j;
 652         struct msi_desc *entry;
 653         int temp;
 654         struct pci_cap_saved_state *save_state;
 655
 656         save_state = pci_find_saved_cap(dev, PCI_CAP_ID_MSIX);
 657         if (!save_state)
 658                 return;
 659         save = *((u16 *)&save_state->data[0]);
 660         pci_remove_saved_cap(save_state);
 661         kfree(save_state);
 662
 663         pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
 664         if (pos <= 0)
 665                 return;
 666
 667         /* route the table */
 668         temp = dev->irq;
 669         if (msi_lookup_vector(dev, PCI_CAP_ID_MSIX))
 670                 return;
 671         vector = head = dev->irq;
 672         while (head != tail) {
 673                 entry = msi_desc[vector];
 674                 base = entry->mask_base;
 675                 j = entry->msi_attrib.entry_nr;
 676
 677                 writel(entry->address_lo_save,
 678                         base + j * PCI_MSIX_ENTRY_SIZE +
 679                         PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
 680                 writel(entry->address_hi_save,
 681                         base + j * PCI_MSIX_ENTRY_SIZE +
 682                         PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
 683                 writel(entry->data_save,
 684                         base + j * PCI_MSIX_ENTRY_SIZE +
 685                         PCI_MSIX_ENTRY_DATA_OFFSET);
 686
 687                 tail = msi_desc[vector]->link.tail;
 688                 vector = tail;
 689         }
 690         dev->irq = temp;
 691
 692         pci_write_config_word(dev, msi_control_reg(pos), save);
 693         enable_msi_mode(dev, pos, PCI_CAP_ID_MSIX);
 694 }
 695 #endif
 696
 697 static int msi_register_init(struct pci_dev *dev, struct msi_desc *entry)
 698 {
 699         int status;
 700         u32 address_hi;
 701         u32 address_lo;
 702         u32 data;
 703         int pos, vector = dev->irq;
 704         u16 control;
 705
 706         pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
 707         pci_read_config_word(dev, msi_control_reg(pos), &control);
 708
 709         /* Configure MSI capability structure */
 710         status = msi_ops->setup(dev, vector, &address_hi, &address_lo, &data);
 711         if (status < 0)
 712                 return status;
 713
 714         pci_write_config_dword(dev, msi_lower_address_reg(pos), address_lo);
 715         if (is_64bit_address(control)) {
 716                 pci_write_config_dword(dev,
 717                         msi_upper_address_reg(pos), address_hi);
 718                 pci_write_config_word(dev,
 719                         msi_data_reg(pos, 1), data);
 720         } else
 721                 pci_write_config_word(dev,
 722                         msi_data_reg(pos, 0), data);
 723         if (entry->msi_attrib.maskbit) {
 724                 unsigned int maskbits, temp;
 725                 /* All MSIs are unmasked by default, Mask them all */
 726                 pci_read_config_dword(dev,
 727                         msi_mask_bits_reg(pos, is_64bit_address(control)),
 728                         &maskbits);
 729                 temp = (1 << multi_msi_capable(control));
 730                 temp = ((temp - 1) & ~temp);
 731                 maskbits |= temp;
 732                 pci_write_config_dword(dev,
 733                         msi_mask_bits_reg(pos, is_64bit_address(control)),
 734                         maskbits);
 735         }
 736
 737         return 0;
 738 }
 739
 740 /**
 741  * msi_capability_init - configure device's MSI capability structure
 742  * @dev: pointer to the pci_dev data structure of MSI device function
 743  *
 744  * Setup the MSI capability structure of device function with a single
 745  * MSI vector, regardless of device function is capable of handling
 746  * multiple messages. A return of zero indicates the successful setup
 747  * of an entry zero with the new MSI vector or non-zero for otherwise.
 748  **/
 749 static int msi_capability_init(struct pci_dev *dev)
 750 {
 751         int status;
 752         struct msi_desc *entry;
 753         int pos, vector;
 754         u16 control;
 755
 756         pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
 757         pci_read_config_word(dev, msi_control_reg(pos), &control);
 758         /* MSI Entry Initialization */
 759         entry = alloc_msi_entry();
 760         if (!entry)
 761                 return -ENOMEM;
 762
 763         vector = get_msi_vector(dev);
 764         if (vector < 0) {
 765                 kmem_cache_free(msi_cachep, entry);
 766                 return -EBUSY;
 767         }
 768         entry->link.head = vector;
 769         entry->link.tail = vector;
 770         entry->msi_attrib.type = PCI_CAP_ID_MSI;
 771         entry->msi_attrib.state = 0;                    /* Mark it not active */
 772         entry->msi_attrib.entry_nr = 0;
 773         entry->msi_attrib.maskbit = is_mask_bit_support(control);
 774         entry->msi_attrib.default_vector = dev->irq;    /* Save IOAPIC IRQ */
 775         dev->irq = vector;
 776         entry->dev = dev;
 777         if (is_mask_bit_support(control)) {
 778                 entry->mask_base = (void __iomem *)(long)msi_mask_bits_reg(pos,
 779                                 is_64bit_address(control));
 780         }
 781         /* Replace with MSI handler */
 782         irq_handler_init(PCI_CAP_ID_MSI, vector, entry->msi_attrib.maskbit);
 783         /* Configure MSI capability structure */
 784         status = msi_register_init(dev, entry);
 785         if (status != 0) {
 786                 dev->irq = entry->msi_attrib.default_vector;
 787                 kmem_cache_free(msi_cachep, entry);
 788                 return status;
 789         }
 790
 791         attach_msi_entry(entry, vector);
 792         /* Set MSI enabled bits  */
 793         enable_msi_mode(dev, pos, PCI_CAP_ID_MSI);
 794
 795         return 0;
 796 }
 797
 798 /**
 799  * msix_capability_init - configure device's MSI-X capability
 800  * @dev: pointer to the pci_dev data structure of MSI-X device function
 801  * @entries: pointer to an array of struct msix_entry entries
 802  * @nvec: number of @entries
 803  *
 804  * Setup the MSI-X capability structure of device function with a
 805  * single MSI-X vector. A return of zero indicates the successful setup of
 806  * requested MSI-X entries with allocated vectors or non-zero for otherwise.
 807  **/
 808 static int msix_capability_init(struct pci_dev *dev,
 809                                 struct msix_entry *entries, int nvec)
 810 {
 811         struct msi_desc *head = NULL, *tail = NULL, *entry = NULL;
 812         u32 address_hi;
 813         u32 address_lo;
 814         u32 data;
 815         int status;
 816         int vector, pos, i, j, nr_entries, temp = 0;
 817         unsigned long phys_addr;
 818         u32 table_offset;
 819         u16 control;
 820         u8 bir;
 821         void __iomem *base;
 822
 823         pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
 824         /* Request & Map MSI-X table region */
 825         pci_read_config_word(dev, msi_control_reg(pos), &control);
 826         nr_entries = multi_msix_capable(control);
 827
 828         pci_read_config_dword(dev, msix_table_offset_reg(pos), &table_offset);
 829         bir = (u8)(table_offset & PCI_MSIX_FLAGS_BIRMASK);
 830         table_offset &= ~PCI_MSIX_FLAGS_BIRMASK;
 831         phys_addr = pci_resource_start (dev, bir) + table_offset;
 832         base = ioremap_nocache(phys_addr, nr_entries * PCI_MSIX_ENTRY_SIZE);
 833         if (base == NULL)
 834                 return -ENOMEM;
 835
 836         /* MSI-X Table Initialization */
 837         for (i = 0; i < nvec; i++) {
 838                 entry = alloc_msi_entry();
 839                 if (!entry)
 840                         break;
 841                 vector = get_msi_vector(dev);
 842                 if (vector < 0) {
 843                         kmem_cache_free(msi_cachep, entry);
 844                         break;
 845                 }
 846
 847                 j = entries[i].entry;
 848                 entries[i].vector = vector;
 849                 entry->msi_attrib.type = PCI_CAP_ID_MSIX;
 850                 entry->msi_attrib.state = 0;            /* Mark it not active */
 851                 entry->msi_attrib.entry_nr = j;
 852                 entry->msi_attrib.maskbit = 1;
 853                 entry->msi_attrib.default_vector = dev->irq;
 854                 entry->dev = dev;
 855                 entry->mask_base = base;
 856                 if (!head) {
 857                         entry->link.head = vector;
 858                         entry->link.tail = vector;
 859                         head = entry;
 860                 } else {
 861                         entry->link.head = temp;
 862                         entry->link.tail = tail->link.tail;
 863                         tail->link.tail = vector;
 864                         head->link.head = vector;
 865                 }
 866                 temp = vector;
 867                 tail = entry;
 868                 /* Replace with MSI-X handler */
 869                 irq_handler_init(PCI_CAP_ID_MSIX, vector, 1);
 870                 /* Configure MSI-X capability structure */
 871                 status = msi_ops->setup(dev, vector,
 872                                         &address_hi,
 873                                         &address_lo,
 874                                         &data);
 875                 if (status < 0)
 876                         break;
 877
 878                 writel(address_lo,
 879                         base + j * PCI_MSIX_ENTRY_SIZE +
 880                         PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
 881                 writel(address_hi,
 882                         base + j * PCI_MSIX_ENTRY_SIZE +
 883                         PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
 884                 writel(data,
 885                         base + j * PCI_MSIX_ENTRY_SIZE +
 886                         PCI_MSIX_ENTRY_DATA_OFFSET);
 887                 attach_msi_entry(entry, vector);
 888         }
 889         if (i != nvec) {
 890                 i--;
 891                 for (; i >= 0; i--) {
 892                         vector = (entries + i)->vector;
 893                         msi_free_vector(dev, vector, 0);
 894                         (entries + i)->vector = 0;
 895                 }
 896                 return -EBUSY;
 897         }
 898         /* Set MSI-X enabled bits */
 899         enable_msi_mode(dev, pos, PCI_CAP_ID_MSIX);
 900
 901         return 0;
 902 }
 903
 904 /**
 905  * pci_enable_msi - configure device's MSI capability structure
 906  * @dev: pointer to the pci_dev data structure of MSI device function
 907  *
 908  * Setup the MSI capability structure of device function with
 909  * a single MSI vector upon its software driver call to request for
 910  * MSI mode enabled on its hardware device function. A return of zero
 911  * indicates the successful setup of an entry zero with the new MSI
 912  * vector or non-zero for otherwise.
 913  **/
 914 int pci_enable_msi(struct pci_dev* dev)
 915 {
 916         struct pci_bus *bus;
 917         int pos, temp, status = -EINVAL;
 918         u16 control;
 919
 920         if (!pci_msi_enable || !dev)
 921                 return status;
 922
 923         if (dev->no_msi)
 924                 return status;
 925
 926         for (bus = dev->bus; bus; bus = bus->parent)
 927                 if (bus->bus_flags & PCI_BUS_FLAGS_NO_MSI)
 928                         return -EINVAL;
 929
 930         temp = dev->irq;
 931
 932         status = msi_init();
 933         if (status < 0)
 934                 return status;
 935
 936         pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
 937         if (!pos)
 938                 return -EINVAL;
 939
 940         if (!msi_lookup_vector(dev, PCI_CAP_ID_MSI)) {
 941                 /* Lookup Sucess */
 942                 unsigned long flags;
 943
 944                 pci_read_config_word(dev, msi_control_reg(pos), &control);
 945                 if (control & PCI_MSI_FLAGS_ENABLE)
 946                         return 0;       /* Already in MSI mode */
 947                 spin_lock_irqsave(&msi_lock, flags);
 948                 if (!vector_irq[dev->irq]) {
 949                         msi_desc[dev->irq]->msi_attrib.state = 0;
 950                         vector_irq[dev->irq] = -1;
 951                         nr_released_vectors--;
 952                         spin_unlock_irqrestore(&msi_lock, flags);
 953                         status = msi_register_init(dev, msi_desc[dev->irq]);
 954                         if (status == 0)
 955                                 enable_msi_mode(dev, pos, PCI_CAP_ID_MSI);
 956                         return status;
 957                 }
 958                 spin_unlock_irqrestore(&msi_lock, flags);
 959                 dev->irq = temp;
 960         }
 961         /* Check whether driver already requested for MSI-X vectors */
 962         pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
 963         if (pos > 0 && !msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
 964                         printk(KERN_INFO "PCI: %s: Can't enable MSI.  "
 965                                "Device already has MSI-X vectors assigned\n",
 966                                pci_name(dev));
 967                         dev->irq = temp;
 968                         return -EINVAL;
 969         }
 970         status = msi_capability_init(dev);
 971         if (!status) {
 972                 if (!pos)
 973                         nr_reserved_vectors--;  /* Only MSI capable */
 974                 else if (nr_msix_devices > 0)
 975                         nr_msix_devices--;      /* Both MSI and MSI-X capable,
 976                                                    but choose enabling MSI */
 977         }
 978
 979         return status;
 980 }
 981
 982 void pci_disable_msi(struct pci_dev* dev)
 983 {
 984         struct msi_desc *entry;
 985         int pos, default_vector;
 986         u16 control;
 987         unsigned long flags;
 988
 989         if (!pci_msi_enable)
 990                 return;
 991         if (!dev)
 992                 return;
 993
 994         pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
 995         if (!pos)
 996                 return;
 997
 998         pci_read_config_word(dev, msi_control_reg(pos), &control);
 999         if (!(control & PCI_MSI_FLAGS_ENABLE))
1000                 return;
1001
1002         spin_lock_irqsave(&msi_lock, flags);
1003         entry = msi_desc[dev->irq];
1004         if (!entry || !entry->dev || entry->msi_attrib.type != PCI_CAP_ID_MSI) {
1005                 spin_unlock_irqrestore(&msi_lock, flags);
1006                 return;
1007         }
1008         if (entry->msi_attrib.state) {
1009                 spin_unlock_irqrestore(&msi_lock, flags);
1010                 printk(KERN_WARNING "PCI: %s: pci_disable_msi() called without "
1011                        "free_irq() on MSI vector %d\n",
1012                        pci_name(dev), dev->irq);
1013                 BUG_ON(entry->msi_attrib.state > 0);
1014         } else {
1015                 vector_irq[dev->irq] = 0; /* free it */
1016                 nr_released_vectors++;
1017                 default_vector = entry->msi_attrib.default_vector;
1018                 spin_unlock_irqrestore(&msi_lock, flags);
1019                 /* Restore dev->irq to its default pin-assertion vector */
1020                 dev->irq = default_vector;
1021                 disable_msi_mode(dev, pci_find_capability(dev, PCI_CAP_ID_MSI),
1022                                         PCI_CAP_ID_MSI);
1023         }
1024 }
1025
1026 static int msi_free_vector(struct pci_dev* dev, int vector, int reassign)
1027 {
1028         struct msi_desc *entry;
1029         int head, entry_nr, type;
1030         void __iomem *base;
1031         unsigned long flags;
1032
1033         msi_ops->teardown(vector);
1034
1035         spin_lock_irqsave(&msi_lock, flags);
1036         entry = msi_desc[vector];
1037         if (!entry || entry->dev != dev) {
1038                 spin_unlock_irqrestore(&msi_lock, flags);
1039                 return -EINVAL;
1040         }
1041         type = entry->msi_attrib.type;
1042         entry_nr = entry->msi_attrib.entry_nr;
1043         head = entry->link.head;
1044         base = entry->mask_base;
1045         msi_desc[entry->link.head]->link.tail = entry->link.tail;
1046         msi_desc[entry->link.tail]->link.head = entry->link.head;
1047         entry->dev = NULL;
1048         if (!reassign) {
1049                 vector_irq[vector] = 0;
1050                 nr_released_vectors++;
1051         }
1052         msi_desc[vector] = NULL;
1053         spin_unlock_irqrestore(&msi_lock, flags);
1054
1055         kmem_cache_free(msi_cachep, entry);
1056
1057         if (type == PCI_CAP_ID_MSIX) {
1058                 if (!reassign)
1059                         writel(1, base +
1060                                 entry_nr * PCI_MSIX_ENTRY_SIZE +
1061                                 PCI_MSIX_ENTRY_VECTOR_CTRL_OFFSET);
1062
1063                 if (head == vector)
1064                         iounmap(base);
1065         }
1066
1067         return 0;
1068 }
1069
1070 static int reroute_msix_table(int head, struct msix_entry *entries, int *nvec)
1071 {
1072         int vector = head, tail = 0;
1073         int i, j = 0, nr_entries = 0;
1074         void __iomem *base;
1075         unsigned long flags;
1076
1077         spin_lock_irqsave(&msi_lock, flags);
1078         while (head != tail) {
1079                 nr_entries++;
1080                 tail = msi_desc[vector]->link.tail;
1081                 if (entries[0].entry == msi_desc[vector]->msi_attrib.entry_nr)
1082                         j = vector;
1083                 vector = tail;
1084         }
1085         if (*nvec > nr_entries) {
1086                 spin_unlock_irqrestore(&msi_lock, flags);
1087                 *nvec = nr_entries;
1088                 return -EINVAL;
1089         }
1090         vector = ((j > 0) ? j : head);
1091         for (i = 0; i < *nvec; i++) {
1092                 j = msi_desc[vector]->msi_attrib.entry_nr;
1093                 msi_desc[vector]->msi_attrib.state = 0; /* Mark it not active */
1094                 vector_irq[vector] = -1;                /* Mark it busy */
1095                 nr_released_vectors--;
1096                 entries[i].vector = vector;
1097                 if (j != (entries + i)->entry) {
1098                         base = msi_desc[vector]->mask_base;
1099                         msi_desc[vector]->msi_attrib.entry_nr =
1100                                 (entries + i)->entry;
1101                         writel( readl(base + j * PCI_MSIX_ENTRY_SIZE +
1102                                 PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET), base +
1103                                 (entries + i)->entry * PCI_MSIX_ENTRY_SIZE +
1104                                 PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
1105                         writel( readl(base + j * PCI_MSIX_ENTRY_SIZE +
1106                                 PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET), base +
1107                                 (entries + i)->entry * PCI_MSIX_ENTRY_SIZE +
1108                                 PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
1109                         writel( (readl(base + j * PCI_MSIX_ENTRY_SIZE +
1110                                 PCI_MSIX_ENTRY_DATA_OFFSET) & 0xff00) | vector,
1111                                 base + (entries+i)->entry*PCI_MSIX_ENTRY_SIZE +
1112                                 PCI_MSIX_ENTRY_DATA_OFFSET);
1113                 }
1114                 vector = msi_desc[vector]->link.tail;
1115         }
1116         spin_unlock_irqrestore(&msi_lock, flags);
1117
1118         return 0;
1119 }
1120
1121 /**
1122  * pci_enable_msix - configure device's MSI-X capability structure
1123  * @dev: pointer to the pci_dev data structure of MSI-X device function
1124  * @entries: pointer to an array of MSI-X entries
1125  * @nvec: number of MSI-X vectors requested for allocation by device driver
1126  *
1127  * Setup the MSI-X capability structure of device function with the number
1128  * of requested vectors upon its software driver call to request for
1129  * MSI-X mode enabled on its hardware device function. A return of zero
1130  * indicates the successful configuration of MSI-X capability structure
1131  * with new allocated MSI-X vectors. A return of < 0 indicates a failure.
1132  * Or a return of > 0 indicates that driver request is exceeding the number
1133  * of vectors available. Driver should use the returned value to re-send
1134  * its request.
1135  **/
1136 int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
1137 {
1138         struct pci_bus *bus;
1139         int status, pos, nr_entries, free_vectors;
1140         int i, j, temp;
1141         u16 control;
1142         unsigned long flags;
1143
1144         if (!pci_msi_enable || !dev || !entries)
1145                 return -EINVAL;
1146
1147         if (dev->no_msi)
1148                 return -EINVAL;
1149
1150         for (bus = dev->bus; bus; bus = bus->parent)
1151                 if (bus->bus_flags & PCI_BUS_FLAGS_NO_MSI)
1152                         return -EINVAL;
1153
1154         status = msi_init();
1155         if (status < 0)
1156                 return status;
1157
1158         pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
1159         if (!pos)
1160                 return -EINVAL;
1161
1162         pci_read_config_word(dev, msi_control_reg(pos), &control);
1163         if (control & PCI_MSIX_FLAGS_ENABLE)
1164                 return -EINVAL;                 /* Already in MSI-X mode */
1165
1166         nr_entries = multi_msix_capable(control);
1167         if (nvec > nr_entries)
1168                 return -EINVAL;
1169
1170         /* Check for any invalid entries */
1171         for (i = 0; i < nvec; i++) {
1172                 if (entries[i].entry >= nr_entries)
1173                         return -EINVAL;         /* invalid entry */
1174                 for (j = i + 1; j < nvec; j++) {
1175                         if (entries[i].entry == entries[j].entry)
1176                                 return -EINVAL; /* duplicate entry */
1177                 }
1178         }
1179         temp = dev->irq;
1180         if (!msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
1181                 /* Lookup Sucess */
1182                 nr_entries = nvec;
1183                 /* Reroute MSI-X table */
1184                 if (reroute_msix_table(dev->irq, entries, &nr_entries)) {
1185                         /* #requested > #previous-assigned */
1186                         dev->irq = temp;
1187                         return nr_entries;
1188                 }
1189                 dev->irq = temp;
1190                 enable_msi_mode(dev, pos, PCI_CAP_ID_MSIX);
1191                 return 0;
1192         }
1193         /* Check whether driver already requested for MSI vector */
1194         if (pci_find_capability(dev, PCI_CAP_ID_MSI) > 0 &&
1195                 !msi_lookup_vector(dev, PCI_CAP_ID_MSI)) {
1196                 printk(KERN_INFO "PCI: %s: Can't enable MSI-X.  "
1197                        "Device already has an MSI vector assigned\n",
1198                        pci_name(dev));
1199                 dev->irq = temp;
1200                 return -EINVAL;
1201         }
1202
1203         spin_lock_irqsave(&msi_lock, flags);
1204         /*
1205          * msi_lock is provided to ensure that enough vectors resources are
1206          * available before granting.
1207          */
1208         free_vectors = pci_vector_resources(last_alloc_vector,
1209                                 nr_released_vectors);
1210         /* Ensure that each MSI/MSI-X device has one vector reserved by
1211            default to avoid any MSI-X driver to take all available
1212            resources */
1213         free_vectors -= nr_reserved_vectors;
1214         /* Find the average of free vectors among MSI-X devices */
1215         if (nr_msix_devices > 0)
1216                 free_vectors /= nr_msix_devices;
1217         spin_unlock_irqrestore(&msi_lock, flags);
1218
1219         if (nvec > free_vectors) {
1220                 if (free_vectors > 0)
1221                         return free_vectors;
1222                 else
1223                         return -EBUSY;
1224         }
1225
1226         status = msix_capability_init(dev, entries, nvec);
1227         if (!status && nr_msix_devices > 0)
1228                 nr_msix_devices--;
1229
1230         return status;
1231 }
1232
1233 void pci_disable_msix(struct pci_dev* dev)
1234 {
1235         int pos, temp;
1236         u16 control;
1237
1238         if (!pci_msi_enable)
1239                 return;
1240         if (!dev)
1241                 return;
1242
1243         pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
1244         if (!pos)
1245                 return;
1246
1247         pci_read_config_word(dev, msi_control_reg(pos), &control);
1248         if (!(control & PCI_MSIX_FLAGS_ENABLE))
1249                 return;
1250
1251         temp = dev->irq;
1252         if (!msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
1253                 int state, vector, head, tail = 0, warning = 0;
1254                 unsigned long flags;
1255
1256                 vector = head = dev->irq;
1257                 spin_lock_irqsave(&msi_lock, flags);
1258                 while (head != tail) {
1259                         state = msi_desc[vector]->msi_attrib.state;
1260                         if (state)
1261                                 warning = 1;
1262                         else {
1263                                 vector_irq[vector] = 0; /* free it */
1264                                 nr_released_vectors++;
1265                         }
1266                         tail = msi_desc[vector]->link.tail;
1267                         vector = tail;
1268                 }
1269                 spin_unlock_irqrestore(&msi_lock, flags);
1270                 if (warning) {
1271                         dev->irq = temp;
1272                         printk(KERN_WARNING "PCI: %s: pci_disable_msix() called without "
1273                                "free_irq() on all MSI-X vectors\n",
1274                                pci_name(dev));
1275                         BUG_ON(warning > 0);
1276                 } else {
1277                         dev->irq = temp;
1278                         disable_msi_mode(dev,
1279                                 pci_find_capability(dev, PCI_CAP_ID_MSIX),
1280                                 PCI_CAP_ID_MSIX);
1281
1282                 }
1283         }
1284 }
1285
1286 /**
1287  * msi_remove_pci_irq_vectors - reclaim MSI(X) vectors to unused state
1288  * @dev: pointer to the pci_dev data structure of MSI(X) device function
1289  *
1290  * Being called during hotplug remove, from which the device function
1291  * is hot-removed. All previous assigned MSI/MSI-X vectors, if
1292  * allocated for this device function, are reclaimed to unused state,
1293  * which may be used later on.
1294  **/
1295 void msi_remove_pci_irq_vectors(struct pci_dev* dev)
1296 {
1297         int state, pos, temp;
1298         unsigned long flags;
1299
1300         if (!pci_msi_enable || !dev)
1301                 return;
1302
1303         temp = dev->irq;                /* Save IOAPIC IRQ */
1304         pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
1305         if (pos > 0 && !msi_lookup_vector(dev, PCI_CAP_ID_MSI)) {
1306                 spin_lock_irqsave(&msi_lock, flags);
1307                 state = msi_desc[dev->irq]->msi_attrib.state;
1308                 spin_unlock_irqrestore(&msi_lock, flags);
1309                 if (state) {
1310                         printk(KERN_WARNING "PCI: %s: msi_remove_pci_irq_vectors() "
1311                                "called without free_irq() on MSI vector %d\n",
1312                                pci_name(dev), dev->irq);
1313                         BUG_ON(state > 0);
1314                 } else /* Release MSI vector assigned to this device */
1315                         msi_free_vector(dev, dev->irq, 0);
1316                 dev->irq = temp;                /* Restore IOAPIC IRQ */
1317         }
1318         pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
1319         if (pos > 0 && !msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
1320                 int vector, head, tail = 0, warning = 0;
1321                 void __iomem *base = NULL;
1322
1323                 vector = head = dev->irq;
1324                 while (head != tail) {
1325                         spin_lock_irqsave(&msi_lock, flags);
1326                         state = msi_desc[vector]->msi_attrib.state;
1327                         tail = msi_desc[vector]->link.tail;
1328                         base = msi_desc[vector]->mask_base;
1329                         spin_unlock_irqrestore(&msi_lock, flags);
1330                         if (state)
1331                                 warning = 1;
1332                         else if (vector != head) /* Release MSI-X vector */
1333                                 msi_free_vector(dev, vector, 0);
1334                         vector = tail;
1335                 }
1336                 msi_free_vector(dev, vector, 0);
1337                 if (warning) {
1338                         iounmap(base);
1339                         printk(KERN_WARNING "PCI: %s: msi_remove_pci_irq_vectors() "
1340                                "called without free_irq() on all MSI-X vectors\n",
1341                                pci_name(dev));
1342                         BUG_ON(warning > 0);
1343                 }
1344                 dev->irq = temp;                /* Restore IOAPIC IRQ */
1345         }
1346 }
1347
1348 void pci_no_msi(void)
1349 {
1350         pci_msi_enable = 0;
1351 }
1352
1353 EXPORT_SYMBOL(pci_enable_msi);
1354 EXPORT_SYMBOL(pci_disable_msi);
1355 EXPORT_SYMBOL(pci_enable_msix);
1356 EXPORT_SYMBOL(pci_disable_msix);