Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / 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          /* Update callback used to cope with buggy hardware */
29         ht_irq_update_t *update;
30         unsigned pos;
31         unsigned idx;
32         struct ht_irq_msg msg;
33 };
34
35
36 void write_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg)
37 {
38         struct ht_irq_cfg *cfg = get_irq_data(irq);
39         unsigned long flags;
40         spin_lock_irqsave(&ht_irq_lock, flags);
41         if (cfg->msg.address_lo != msg->address_lo) {
42                 pci_write_config_byte(cfg->dev, cfg->pos + 2, cfg->idx);
43                 pci_write_config_dword(cfg->dev, cfg->pos + 4, msg->address_lo);
44         }
45         if (cfg->msg.address_hi != msg->address_hi) {
46                 pci_write_config_byte(cfg->dev, cfg->pos + 2, cfg->idx + 1);
47                 pci_write_config_dword(cfg->dev, cfg->pos + 4, msg->address_hi);
48         }
49         if (cfg->update)
50                 cfg->update(cfg->dev, irq, msg);
51         spin_unlock_irqrestore(&ht_irq_lock, flags);
52         cfg->msg = *msg;
53 }
54
55 void fetch_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg)
56 {
57         struct ht_irq_cfg *cfg = get_irq_data(irq);
58         *msg = cfg->msg;
59 }
60
61 void mask_ht_irq(unsigned int irq)
62 {
63         struct ht_irq_cfg *cfg;
64         struct ht_irq_msg msg;
65
66         cfg = get_irq_data(irq);
67
68         msg = cfg->msg;
69         msg.address_lo |= 1;
70         write_ht_irq_msg(irq, &msg);
71 }
72
73 void unmask_ht_irq(unsigned int irq)
74 {
75         struct ht_irq_cfg *cfg;
76         struct ht_irq_msg msg;
77
78         cfg = get_irq_data(irq);
79
80         msg = cfg->msg;
81         msg.address_lo &= ~1;
82         write_ht_irq_msg(irq, &msg);
83 }
84
85 /**
86  * __ht_create_irq - create an irq and attach it to a device.
87  * @dev: The hypertransport device to find the irq capability on.
88  * @idx: Which of the possible irqs to attach to.
89  * @update: Function to be called when changing the htirq message
90  *
91  * The irq number of the new irq or a negative error value is returned.
92  */
93 int __ht_create_irq(struct pci_dev *dev, int idx, ht_irq_update_t *update)
94 {
95         struct ht_irq_cfg *cfg;
96         unsigned long flags;
97         u32 data;
98         int max_irq;
99         int pos;
100         int irq;
101         int node;
102
103         pos = pci_find_ht_capability(dev, HT_CAPTYPE_IRQ);
104         if (!pos)
105                 return -EINVAL;
106
107         /* Verify the idx I want to use is in range */
108         spin_lock_irqsave(&ht_irq_lock, flags);
109         pci_write_config_byte(dev, pos + 2, 1);
110         pci_read_config_dword(dev, pos + 4, &data);
111         spin_unlock_irqrestore(&ht_irq_lock, flags);
112
113         max_irq = (data >> 16) & 0xff;
114         if ( idx > max_irq)
115                 return -EINVAL;
116
117         cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
118         if (!cfg)
119                 return -ENOMEM;
120
121         cfg->dev = dev;
122         cfg->update = update;
123         cfg->pos = pos;
124         cfg->idx = 0x10 + (idx * 2);
125         /* Initialize msg to a value that will never match the first write. */
126         cfg->msg.address_lo = 0xffffffff;
127         cfg->msg.address_hi = 0xffffffff;
128
129         node = dev_to_node(&dev->dev);
130         irq = create_irq_nr(0, node);
131
132         if (irq <= 0) {
133                 kfree(cfg);
134                 return -EBUSY;
135         }
136         set_irq_data(irq, cfg);
137
138         if (arch_setup_ht_irq(irq, dev) < 0) {
139                 ht_destroy_irq(irq);
140                 return -EBUSY;
141         }
142
143         return irq;
144 }
145
146 /**
147  * ht_create_irq - create an irq and attach it to a device.
148  * @dev: The hypertransport device to find the irq capability on.
149  * @idx: Which of the possible irqs to attach to.
150  *
151  * ht_create_irq needs to be called for all hypertransport devices
152  * that generate irqs.
153  *
154  * The irq number of the new irq or a negative error value is returned.
155  */
156 int ht_create_irq(struct pci_dev *dev, int idx)
157 {
158         return __ht_create_irq(dev, idx, NULL);
159 }
160
161 /**
162  * ht_destroy_irq - destroy an irq created with ht_create_irq
163  * @irq: irq to be destroyed
164  *
165  * This reverses ht_create_irq removing the specified irq from
166  * existence.  The irq should be free before this happens.
167  */
168 void ht_destroy_irq(unsigned int irq)
169 {
170         struct ht_irq_cfg *cfg;
171
172         cfg = get_irq_data(irq);
173         set_irq_chip(irq, NULL);
174         set_irq_data(irq, NULL);
175         destroy_irq(irq);
176
177         kfree(cfg);
178 }
179
180 EXPORT_SYMBOL(__ht_create_irq);
181 EXPORT_SYMBOL(ht_create_irq);
182 EXPORT_SYMBOL(ht_destroy_irq);