drivers/pci/htirq.c

   1 /*
   2  * File:        htirq.c
   3  * Purpose:     Hypertransport Interrupt Capability
   4  *
   5  * Copyright (C) 2006 Linux Networx
   6  * Copyright (C) Eric Biederman <ebiederman@lnxi.com>
   7  */
   8
   9 #include <linux/irq.h>
  10 #include <linux/pci.h>
  11 #include <linux/spinlock.h>
  12 #include <linux/slab.h>
  13 #include <linux/gfp.h>
  14 #include <linux/htirq.h>
  15
  16 /* Global ht irq lock.
  17  *
  18  * This is needed to serialize access to the data port in hypertransport
  19  * irq capability.
  20  *
  21  * With multiple simultaneous hypertransport irq devices it might pay
  22  * to make this more fine grained.  But start with simple, stupid, and correct.
  23  */
  24 static DEFINE_SPINLOCK(ht_irq_lock);
  25
  26 struct ht_irq_cfg {
  27         struct pci_dev *dev;
  28         unsigned pos;
  29         unsigned idx;
  30         struct ht_irq_msg msg;
  31 };
  32
  33
  34 void write_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg)
  35 {
  36         struct ht_irq_cfg *cfg = get_irq_data(irq);
  37         unsigned long flags;
  38         spin_lock_irqsave(&ht_irq_lock, flags);
  39         if (cfg->msg.address_lo != msg->address_lo) {
  40                 pci_write_config_byte(cfg->dev, cfg->pos + 2, cfg->idx);
  41                 pci_write_config_dword(cfg->dev, cfg->pos + 4, msg->address_lo);
  42         }
  43         if (cfg->msg.address_hi != msg->address_hi) {
  44                 pci_write_config_byte(cfg->dev, cfg->pos + 2, cfg->idx + 1);
  45                 pci_write_config_dword(cfg->dev, cfg->pos + 4, msg->address_hi);
  46         }
  47         spin_unlock_irqrestore(&ht_irq_lock, flags);
  48         cfg->msg = *msg;
  49 }
  50
  51 void fetch_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg)
  52 {
  53         struct ht_irq_cfg *cfg = get_irq_data(irq);
  54         *msg = cfg->msg;
  55 }
  56
  57 void mask_ht_irq(unsigned int irq)
  58 {
  59         struct ht_irq_cfg *cfg;
  60         struct ht_irq_msg msg;
  61
  62         cfg = get_irq_data(irq);
  63
  64         msg = cfg->msg;
  65         msg.address_lo |= 1;
  66         write_ht_irq_msg(irq, &msg);
  67 }
  68
  69 void unmask_ht_irq(unsigned int irq)
  70 {
  71         struct ht_irq_cfg *cfg;
  72         struct ht_irq_msg msg;
  73
  74         cfg = get_irq_data(irq);
  75
  76         msg = cfg->msg;
  77         msg.address_lo &= ~1;
  78         write_ht_irq_msg(irq, &msg);
  79 }
  80
  81 /**
  82  * ht_create_irq - create an irq and attach it to a device.
  83  * @dev: The hypertransport device to find the irq capability on.
  84  * @idx: Which of the possible irqs to attach to.
  85  *
  86  * ht_create_irq is needs to be called for all hypertransport devices
  87  * that generate irqs.
  88  *
  89  * The irq number of the new irq or a negative error value is returned.
  90  */
  91 int ht_create_irq(struct pci_dev *dev, int idx)
  92 {
  93         struct ht_irq_cfg *cfg;
  94         unsigned long flags;
  95         u32 data;
  96         int max_irq;
  97         int pos;
  98         int irq;
  99
 100         pos = pci_find_capability(dev, PCI_CAP_ID_HT);
 101         while (pos) {
 102                 u8 subtype;
 103                 pci_read_config_byte(dev, pos + 3, &subtype);
 104                 if (subtype == HT_CAPTYPE_IRQ)
 105                         break;
 106                 pos = pci_find_next_capability(dev, pos, PCI_CAP_ID_HT);
 107         }
 108         if (!pos)
 109                 return -EINVAL;
 110
 111         /* Verify the idx I want to use is in range */
 112         spin_lock_irqsave(&ht_irq_lock, flags);
 113         pci_write_config_byte(dev, pos + 2, 1);
 114         pci_read_config_dword(dev, pos + 4, &data);
 115         spin_unlock_irqrestore(&ht_irq_lock, flags);
 116
 117         max_irq = (data >> 16) & 0xff;
 118         if ( idx > max_irq)
 119                 return -EINVAL;
 120
 121         cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
 122         if (!cfg)
 123                 return -ENOMEM;
 124
 125         cfg->dev = dev;
 126         cfg->pos = pos;
 127         cfg->idx = 0x10 + (idx * 2);
 128         /* Initialize msg to a value that will never match the first write. */
 129         cfg->msg.address_lo = 0xffffffff;
 130         cfg->msg.address_hi = 0xffffffff;
 131
 132         irq = create_irq();
 133         if (irq < 0) {
 134                 kfree(cfg);
 135                 return -EBUSY;
 136         }
 137         set_irq_data(irq, cfg);
 138
 139         if (arch_setup_ht_irq(irq, dev) < 0) {
 140                 ht_destroy_irq(irq);
 141                 return -EBUSY;
 142         }
 143
 144         return irq;
 145 }
 146
 147 /**
 148  * ht_destroy_irq - destroy an irq created with ht_create_irq
 149  *
 150  * This reverses ht_create_irq removing the specified irq from
 151  * existence.  The irq should be free before this happens.
 152  */
 153 void ht_destroy_irq(unsigned int irq)
 154 {
 155         struct ht_irq_cfg *cfg;
 156
 157         cfg = get_irq_data(irq);
 158         set_irq_chip(irq, NULL);
 159         set_irq_data(irq, NULL);
 160         destroy_irq(irq);
 161
 162         kfree(cfg);
 163 }
 164
 165 EXPORT_SYMBOL(ht_create_irq);
 166 EXPORT_SYMBOL(ht_destroy_irq);