]> git.karo-electronics.de Git - mv-sheeva.git/blob - drivers/scsi/fnic/fnic_isr.c
Merge branch 'x86-fpu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[mv-sheeva.git] / drivers / scsi / fnic / fnic_isr.c
1 /*
2  * Copyright 2008 Cisco Systems, Inc.  All rights reserved.
3  * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
4  *
5  * This program is free software; you may redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; version 2 of the License.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
10  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
11  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
12  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
13  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
14  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
15  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
16  * SOFTWARE.
17  */
18 #include <linux/string.h>
19 #include <linux/errno.h>
20 #include <linux/pci.h>
21 #include <linux/interrupt.h>
22 #include <scsi/libfc.h>
23 #include <scsi/fc_frame.h>
24 #include "vnic_dev.h"
25 #include "vnic_intr.h"
26 #include "vnic_stats.h"
27 #include "fnic_io.h"
28 #include "fnic.h"
29
30 static irqreturn_t fnic_isr_legacy(int irq, void *data)
31 {
32         struct fnic *fnic = data;
33         u32 pba;
34         unsigned long work_done = 0;
35
36         pba = vnic_intr_legacy_pba(fnic->legacy_pba);
37         if (!pba)
38                 return IRQ_NONE;
39
40         if (pba & (1 << FNIC_INTX_NOTIFY)) {
41                 vnic_intr_return_all_credits(&fnic->intr[FNIC_INTX_NOTIFY]);
42                 fnic_handle_link_event(fnic);
43         }
44
45         if (pba & (1 << FNIC_INTX_ERR)) {
46                 vnic_intr_return_all_credits(&fnic->intr[FNIC_INTX_ERR]);
47                 fnic_log_q_error(fnic);
48         }
49
50         if (pba & (1 << FNIC_INTX_WQ_RQ_COPYWQ)) {
51                 work_done += fnic_wq_copy_cmpl_handler(fnic, 8);
52                 work_done += fnic_wq_cmpl_handler(fnic, 4);
53                 work_done += fnic_rq_cmpl_handler(fnic, 4);
54
55                 vnic_intr_return_credits(&fnic->intr[FNIC_INTX_WQ_RQ_COPYWQ],
56                                          work_done,
57                                          1 /* unmask intr */,
58                                          1 /* reset intr timer */);
59         }
60
61         return IRQ_HANDLED;
62 }
63
64 static irqreturn_t fnic_isr_msi(int irq, void *data)
65 {
66         struct fnic *fnic = data;
67         unsigned long work_done = 0;
68
69         work_done += fnic_wq_copy_cmpl_handler(fnic, 8);
70         work_done += fnic_wq_cmpl_handler(fnic, 4);
71         work_done += fnic_rq_cmpl_handler(fnic, 4);
72
73         vnic_intr_return_credits(&fnic->intr[0],
74                                  work_done,
75                                  1 /* unmask intr */,
76                                  1 /* reset intr timer */);
77
78         return IRQ_HANDLED;
79 }
80
81 static irqreturn_t fnic_isr_msix_rq(int irq, void *data)
82 {
83         struct fnic *fnic = data;
84         unsigned long rq_work_done = 0;
85
86         rq_work_done = fnic_rq_cmpl_handler(fnic, 4);
87         vnic_intr_return_credits(&fnic->intr[FNIC_MSIX_RQ],
88                                  rq_work_done,
89                                  1 /* unmask intr */,
90                                  1 /* reset intr timer */);
91
92         return IRQ_HANDLED;
93 }
94
95 static irqreturn_t fnic_isr_msix_wq(int irq, void *data)
96 {
97         struct fnic *fnic = data;
98         unsigned long wq_work_done = 0;
99
100         wq_work_done = fnic_wq_cmpl_handler(fnic, 4);
101         vnic_intr_return_credits(&fnic->intr[FNIC_MSIX_WQ],
102                                  wq_work_done,
103                                  1 /* unmask intr */,
104                                  1 /* reset intr timer */);
105         return IRQ_HANDLED;
106 }
107
108 static irqreturn_t fnic_isr_msix_wq_copy(int irq, void *data)
109 {
110         struct fnic *fnic = data;
111         unsigned long wq_copy_work_done = 0;
112
113         wq_copy_work_done = fnic_wq_copy_cmpl_handler(fnic, 8);
114         vnic_intr_return_credits(&fnic->intr[FNIC_MSIX_WQ_COPY],
115                                  wq_copy_work_done,
116                                  1 /* unmask intr */,
117                                  1 /* reset intr timer */);
118         return IRQ_HANDLED;
119 }
120
121 static irqreturn_t fnic_isr_msix_err_notify(int irq, void *data)
122 {
123         struct fnic *fnic = data;
124
125         vnic_intr_return_all_credits(&fnic->intr[FNIC_MSIX_ERR_NOTIFY]);
126         fnic_log_q_error(fnic);
127         fnic_handle_link_event(fnic);
128
129         return IRQ_HANDLED;
130 }
131
132 void fnic_free_intr(struct fnic *fnic)
133 {
134         int i;
135
136         switch (vnic_dev_get_intr_mode(fnic->vdev)) {
137         case VNIC_DEV_INTR_MODE_INTX:
138         case VNIC_DEV_INTR_MODE_MSI:
139                 free_irq(fnic->pdev->irq, fnic);
140                 break;
141
142         case VNIC_DEV_INTR_MODE_MSIX:
143                 for (i = 0; i < ARRAY_SIZE(fnic->msix); i++)
144                         if (fnic->msix[i].requested)
145                                 free_irq(fnic->msix_entry[i].vector,
146                                          fnic->msix[i].devid);
147                 break;
148
149         default:
150                 break;
151         }
152 }
153
154 int fnic_request_intr(struct fnic *fnic)
155 {
156         int err = 0;
157         int i;
158
159         switch (vnic_dev_get_intr_mode(fnic->vdev)) {
160
161         case VNIC_DEV_INTR_MODE_INTX:
162                 err = request_irq(fnic->pdev->irq, &fnic_isr_legacy,
163                                   IRQF_SHARED, DRV_NAME, fnic);
164                 break;
165
166         case VNIC_DEV_INTR_MODE_MSI:
167                 err = request_irq(fnic->pdev->irq, &fnic_isr_msi,
168                                   0, fnic->name, fnic);
169                 break;
170
171         case VNIC_DEV_INTR_MODE_MSIX:
172
173                 sprintf(fnic->msix[FNIC_MSIX_RQ].devname,
174                         "%.11s-fcs-rq", fnic->name);
175                 fnic->msix[FNIC_MSIX_RQ].isr = fnic_isr_msix_rq;
176                 fnic->msix[FNIC_MSIX_RQ].devid = fnic;
177
178                 sprintf(fnic->msix[FNIC_MSIX_WQ].devname,
179                         "%.11s-fcs-wq", fnic->name);
180                 fnic->msix[FNIC_MSIX_WQ].isr = fnic_isr_msix_wq;
181                 fnic->msix[FNIC_MSIX_WQ].devid = fnic;
182
183                 sprintf(fnic->msix[FNIC_MSIX_WQ_COPY].devname,
184                         "%.11s-scsi-wq", fnic->name);
185                 fnic->msix[FNIC_MSIX_WQ_COPY].isr = fnic_isr_msix_wq_copy;
186                 fnic->msix[FNIC_MSIX_WQ_COPY].devid = fnic;
187
188                 sprintf(fnic->msix[FNIC_MSIX_ERR_NOTIFY].devname,
189                         "%.11s-err-notify", fnic->name);
190                 fnic->msix[FNIC_MSIX_ERR_NOTIFY].isr =
191                         fnic_isr_msix_err_notify;
192                 fnic->msix[FNIC_MSIX_ERR_NOTIFY].devid = fnic;
193
194                 for (i = 0; i < ARRAY_SIZE(fnic->msix); i++) {
195                         err = request_irq(fnic->msix_entry[i].vector,
196                                           fnic->msix[i].isr, 0,
197                                           fnic->msix[i].devname,
198                                           fnic->msix[i].devid);
199                         if (err) {
200                                 shost_printk(KERN_ERR, fnic->lport->host,
201                                              "MSIX: request_irq"
202                                              " failed %d\n", err);
203                                 fnic_free_intr(fnic);
204                                 break;
205                         }
206                         fnic->msix[i].requested = 1;
207                 }
208                 break;
209
210         default:
211                 break;
212         }
213
214         return err;
215 }
216
217 int fnic_set_intr_mode(struct fnic *fnic)
218 {
219         unsigned int n = ARRAY_SIZE(fnic->rq);
220         unsigned int m = ARRAY_SIZE(fnic->wq);
221         unsigned int o = ARRAY_SIZE(fnic->wq_copy);
222         unsigned int i;
223
224         /*
225          * Set interrupt mode (INTx, MSI, MSI-X) depending
226          * system capabilities.
227          *
228          * Try MSI-X first
229          *
230          * We need n RQs, m WQs, o Copy WQs, n+m+o CQs, and n+m+o+1 INTRs
231          * (last INTR is used for WQ/RQ errors and notification area)
232          */
233
234         BUG_ON(ARRAY_SIZE(fnic->msix_entry) < n + m + o + 1);
235         for (i = 0; i < n + m + o + 1; i++)
236                 fnic->msix_entry[i].entry = i;
237
238         if (fnic->rq_count >= n &&
239             fnic->raw_wq_count >= m &&
240             fnic->wq_copy_count >= o &&
241             fnic->cq_count >= n + m + o) {
242                 if (!pci_enable_msix(fnic->pdev, fnic->msix_entry,
243                                     n + m + o + 1)) {
244                         fnic->rq_count = n;
245                         fnic->raw_wq_count = m;
246                         fnic->wq_copy_count = o;
247                         fnic->wq_count = m + o;
248                         fnic->cq_count = n + m + o;
249                         fnic->intr_count = n + m + o + 1;
250                         fnic->err_intr_offset = FNIC_MSIX_ERR_NOTIFY;
251
252                         FNIC_ISR_DBG(KERN_DEBUG, fnic->lport->host,
253                                      "Using MSI-X Interrupts\n");
254                         vnic_dev_set_intr_mode(fnic->vdev,
255                                                VNIC_DEV_INTR_MODE_MSIX);
256                         return 0;
257                 }
258         }
259
260         /*
261          * Next try MSI
262          * We need 1 RQ, 1 WQ, 1 WQ_COPY, 3 CQs, and 1 INTR
263          */
264         if (fnic->rq_count >= 1 &&
265             fnic->raw_wq_count >= 1 &&
266             fnic->wq_copy_count >= 1 &&
267             fnic->cq_count >= 3 &&
268             fnic->intr_count >= 1 &&
269             !pci_enable_msi(fnic->pdev)) {
270
271                 fnic->rq_count = 1;
272                 fnic->raw_wq_count = 1;
273                 fnic->wq_copy_count = 1;
274                 fnic->wq_count = 2;
275                 fnic->cq_count = 3;
276                 fnic->intr_count = 1;
277                 fnic->err_intr_offset = 0;
278
279                 FNIC_ISR_DBG(KERN_DEBUG, fnic->lport->host,
280                              "Using MSI Interrupts\n");
281                 vnic_dev_set_intr_mode(fnic->vdev, VNIC_DEV_INTR_MODE_MSI);
282
283                 return 0;
284         }
285
286         /*
287          * Next try INTx
288          * We need 1 RQ, 1 WQ, 1 WQ_COPY, 3 CQs, and 3 INTRs
289          * 1 INTR is used for all 3 queues, 1 INTR for queue errors
290          * 1 INTR for notification area
291          */
292
293         if (fnic->rq_count >= 1 &&
294             fnic->raw_wq_count >= 1 &&
295             fnic->wq_copy_count >= 1 &&
296             fnic->cq_count >= 3 &&
297             fnic->intr_count >= 3) {
298
299                 fnic->rq_count = 1;
300                 fnic->raw_wq_count = 1;
301                 fnic->wq_copy_count = 1;
302                 fnic->cq_count = 3;
303                 fnic->intr_count = 3;
304
305                 FNIC_ISR_DBG(KERN_DEBUG, fnic->lport->host,
306                              "Using Legacy Interrupts\n");
307                 vnic_dev_set_intr_mode(fnic->vdev, VNIC_DEV_INTR_MODE_INTX);
308
309                 return 0;
310         }
311
312         vnic_dev_set_intr_mode(fnic->vdev, VNIC_DEV_INTR_MODE_UNKNOWN);
313
314         return -EINVAL;
315 }
316
317 void fnic_clear_intr_mode(struct fnic *fnic)
318 {
319         switch (vnic_dev_get_intr_mode(fnic->vdev)) {
320         case VNIC_DEV_INTR_MODE_MSIX:
321                 pci_disable_msix(fnic->pdev);
322                 break;
323         case VNIC_DEV_INTR_MODE_MSI:
324                 pci_disable_msi(fnic->pdev);
325                 break;
326         default:
327                 break;
328         }
329
330         vnic_dev_set_intr_mode(fnic->vdev, VNIC_DEV_INTR_MODE_INTX);
331 }
332