Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw
[linux-2.6] / drivers / scsi / fnic / fnic_res.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/errno.h>
19 #include <linux/types.h>
20 #include <linux/pci.h>
21 #include "wq_enet_desc.h"
22 #include "rq_enet_desc.h"
23 #include "cq_enet_desc.h"
24 #include "vnic_resource.h"
25 #include "vnic_dev.h"
26 #include "vnic_wq.h"
27 #include "vnic_rq.h"
28 #include "vnic_cq.h"
29 #include "vnic_intr.h"
30 #include "vnic_stats.h"
31 #include "vnic_nic.h"
32 #include "fnic.h"
33
34 int fnic_get_vnic_config(struct fnic *fnic)
35 {
36         struct vnic_fc_config *c = &fnic->config;
37         int err;
38
39 #define GET_CONFIG(m) \
40         do { \
41                 err = vnic_dev_spec(fnic->vdev, \
42                                     offsetof(struct vnic_fc_config, m), \
43                                     sizeof(c->m), &c->m); \
44                 if (err) { \
45                         shost_printk(KERN_ERR, fnic->lport->host, \
46                                      "Error getting %s, %d\n", #m, \
47                                      err); \
48                         return err; \
49                 } \
50         } while (0);
51
52         GET_CONFIG(node_wwn);
53         GET_CONFIG(port_wwn);
54         GET_CONFIG(wq_enet_desc_count);
55         GET_CONFIG(wq_copy_desc_count);
56         GET_CONFIG(rq_desc_count);
57         GET_CONFIG(maxdatafieldsize);
58         GET_CONFIG(ed_tov);
59         GET_CONFIG(ra_tov);
60         GET_CONFIG(intr_timer);
61         GET_CONFIG(intr_timer_type);
62         GET_CONFIG(flags);
63         GET_CONFIG(flogi_retries);
64         GET_CONFIG(flogi_timeout);
65         GET_CONFIG(plogi_retries);
66         GET_CONFIG(plogi_timeout);
67         GET_CONFIG(io_throttle_count);
68         GET_CONFIG(link_down_timeout);
69         GET_CONFIG(port_down_timeout);
70         GET_CONFIG(port_down_io_retries);
71         GET_CONFIG(luns_per_tgt);
72
73         c->wq_enet_desc_count =
74                 min_t(u32, VNIC_FNIC_WQ_DESCS_MAX,
75                       max_t(u32, VNIC_FNIC_WQ_DESCS_MIN,
76                             c->wq_enet_desc_count));
77         c->wq_enet_desc_count = ALIGN(c->wq_enet_desc_count, 16);
78
79         c->wq_copy_desc_count =
80                 min_t(u32, VNIC_FNIC_WQ_COPY_DESCS_MAX,
81                       max_t(u32, VNIC_FNIC_WQ_COPY_DESCS_MIN,
82                             c->wq_copy_desc_count));
83         c->wq_copy_desc_count = ALIGN(c->wq_copy_desc_count, 16);
84
85         c->rq_desc_count =
86                 min_t(u32, VNIC_FNIC_RQ_DESCS_MAX,
87                       max_t(u32, VNIC_FNIC_RQ_DESCS_MIN,
88                             c->rq_desc_count));
89         c->rq_desc_count = ALIGN(c->rq_desc_count, 16);
90
91         c->maxdatafieldsize =
92                 min_t(u16, VNIC_FNIC_MAXDATAFIELDSIZE_MAX,
93                       max_t(u16, VNIC_FNIC_MAXDATAFIELDSIZE_MIN,
94                             c->maxdatafieldsize));
95         c->ed_tov =
96                 min_t(u32, VNIC_FNIC_EDTOV_MAX,
97                       max_t(u32, VNIC_FNIC_EDTOV_MIN,
98                             c->ed_tov));
99
100         c->ra_tov =
101                 min_t(u32, VNIC_FNIC_RATOV_MAX,
102                       max_t(u32, VNIC_FNIC_RATOV_MIN,
103                             c->ra_tov));
104
105         c->flogi_retries =
106                 min_t(u32, VNIC_FNIC_FLOGI_RETRIES_MAX, c->flogi_retries);
107
108         c->flogi_timeout =
109                 min_t(u32, VNIC_FNIC_FLOGI_TIMEOUT_MAX,
110                       max_t(u32, VNIC_FNIC_FLOGI_TIMEOUT_MIN,
111                             c->flogi_timeout));
112
113         c->plogi_retries =
114                 min_t(u32, VNIC_FNIC_PLOGI_RETRIES_MAX, c->plogi_retries);
115
116         c->plogi_timeout =
117                 min_t(u32, VNIC_FNIC_PLOGI_TIMEOUT_MAX,
118                       max_t(u32, VNIC_FNIC_PLOGI_TIMEOUT_MIN,
119                             c->plogi_timeout));
120
121         c->io_throttle_count =
122                 min_t(u32, VNIC_FNIC_IO_THROTTLE_COUNT_MAX,
123                       max_t(u32, VNIC_FNIC_IO_THROTTLE_COUNT_MIN,
124                             c->io_throttle_count));
125
126         c->link_down_timeout =
127                 min_t(u32, VNIC_FNIC_LINK_DOWN_TIMEOUT_MAX,
128                       c->link_down_timeout);
129
130         c->port_down_timeout =
131                 min_t(u32, VNIC_FNIC_PORT_DOWN_TIMEOUT_MAX,
132                       c->port_down_timeout);
133
134         c->port_down_io_retries =
135                 min_t(u32, VNIC_FNIC_PORT_DOWN_IO_RETRIES_MAX,
136                       c->port_down_io_retries);
137
138         c->luns_per_tgt =
139                 min_t(u32, VNIC_FNIC_LUNS_PER_TARGET_MAX,
140                       max_t(u32, VNIC_FNIC_LUNS_PER_TARGET_MIN,
141                             c->luns_per_tgt));
142
143         c->intr_timer = min_t(u16, VNIC_INTR_TIMER_MAX, c->intr_timer);
144         c->intr_timer_type = c->intr_timer_type;
145
146         shost_printk(KERN_INFO, fnic->lport->host,
147                      "vNIC MAC addr %02x:%02x:%02x:%02x:%02x:%02x "
148                      "wq/wq_copy/rq %d/%d/%d\n",
149                      fnic->mac_addr[0], fnic->mac_addr[1], fnic->mac_addr[2],
150                      fnic->mac_addr[3], fnic->mac_addr[4], fnic->mac_addr[5],
151                      c->wq_enet_desc_count, c->wq_copy_desc_count,
152                      c->rq_desc_count);
153         shost_printk(KERN_INFO, fnic->lport->host,
154                      "vNIC node wwn %llx port wwn %llx\n",
155                      c->node_wwn, c->port_wwn);
156         shost_printk(KERN_INFO, fnic->lport->host,
157                      "vNIC ed_tov %d ra_tov %d\n",
158                      c->ed_tov, c->ra_tov);
159         shost_printk(KERN_INFO, fnic->lport->host,
160                      "vNIC mtu %d intr timer %d\n",
161                      c->maxdatafieldsize, c->intr_timer);
162         shost_printk(KERN_INFO, fnic->lport->host,
163                      "vNIC flags 0x%x luns per tgt %d\n",
164                      c->flags, c->luns_per_tgt);
165         shost_printk(KERN_INFO, fnic->lport->host,
166                      "vNIC flogi_retries %d flogi timeout %d\n",
167                      c->flogi_retries, c->flogi_timeout);
168         shost_printk(KERN_INFO, fnic->lport->host,
169                      "vNIC plogi retries %d plogi timeout %d\n",
170                      c->plogi_retries, c->plogi_timeout);
171         shost_printk(KERN_INFO, fnic->lport->host,
172                      "vNIC io throttle count %d link dn timeout %d\n",
173                      c->io_throttle_count, c->link_down_timeout);
174         shost_printk(KERN_INFO, fnic->lport->host,
175                      "vNIC port dn io retries %d port dn timeout %d\n",
176                      c->port_down_io_retries, c->port_down_timeout);
177
178         return 0;
179 }
180
181 int fnic_set_nic_config(struct fnic *fnic, u8 rss_default_cpu,
182                         u8 rss_hash_type,
183                         u8 rss_hash_bits, u8 rss_base_cpu, u8 rss_enable,
184                         u8 tso_ipid_split_en, u8 ig_vlan_strip_en)
185 {
186         u64 a0, a1;
187         u32 nic_cfg;
188         int wait = 1000;
189
190         vnic_set_nic_cfg(&nic_cfg, rss_default_cpu,
191                 rss_hash_type, rss_hash_bits, rss_base_cpu,
192                 rss_enable, tso_ipid_split_en, ig_vlan_strip_en);
193
194         a0 = nic_cfg;
195         a1 = 0;
196
197         return vnic_dev_cmd(fnic->vdev, CMD_NIC_CFG, &a0, &a1, wait);
198 }
199
200 void fnic_get_res_counts(struct fnic *fnic)
201 {
202         fnic->wq_count = vnic_dev_get_res_count(fnic->vdev, RES_TYPE_WQ);
203         fnic->raw_wq_count = fnic->wq_count - 1;
204         fnic->wq_copy_count = fnic->wq_count - fnic->raw_wq_count;
205         fnic->rq_count = vnic_dev_get_res_count(fnic->vdev, RES_TYPE_RQ);
206         fnic->cq_count = vnic_dev_get_res_count(fnic->vdev, RES_TYPE_CQ);
207         fnic->intr_count = vnic_dev_get_res_count(fnic->vdev,
208                 RES_TYPE_INTR_CTRL);
209 }
210
211 void fnic_free_vnic_resources(struct fnic *fnic)
212 {
213         unsigned int i;
214
215         for (i = 0; i < fnic->raw_wq_count; i++)
216                 vnic_wq_free(&fnic->wq[i]);
217
218         for (i = 0; i < fnic->wq_copy_count; i++)
219                 vnic_wq_copy_free(&fnic->wq_copy[i]);
220
221         for (i = 0; i < fnic->rq_count; i++)
222                 vnic_rq_free(&fnic->rq[i]);
223
224         for (i = 0; i < fnic->cq_count; i++)
225                 vnic_cq_free(&fnic->cq[i]);
226
227         for (i = 0; i < fnic->intr_count; i++)
228                 vnic_intr_free(&fnic->intr[i]);
229 }
230
231 int fnic_alloc_vnic_resources(struct fnic *fnic)
232 {
233         enum vnic_dev_intr_mode intr_mode;
234         unsigned int mask_on_assertion;
235         unsigned int interrupt_offset;
236         unsigned int error_interrupt_enable;
237         unsigned int error_interrupt_offset;
238         unsigned int i, cq_index;
239         unsigned int wq_copy_cq_desc_count;
240         int err;
241
242         intr_mode = vnic_dev_get_intr_mode(fnic->vdev);
243
244         shost_printk(KERN_INFO, fnic->lport->host, "vNIC interrupt mode: %s\n",
245                      intr_mode == VNIC_DEV_INTR_MODE_INTX ? "legacy PCI INTx" :
246                      intr_mode == VNIC_DEV_INTR_MODE_MSI ? "MSI" :
247                      intr_mode == VNIC_DEV_INTR_MODE_MSIX ?
248                      "MSI-X" : "unknown");
249
250         shost_printk(KERN_INFO, fnic->lport->host, "vNIC resources avail: "
251                      "wq %d cp_wq %d raw_wq %d rq %d cq %d intr %d\n",
252                      fnic->wq_count, fnic->wq_copy_count, fnic->raw_wq_count,
253                      fnic->rq_count, fnic->cq_count, fnic->intr_count);
254
255         /* Allocate Raw WQ used for FCS frames */
256         for (i = 0; i < fnic->raw_wq_count; i++) {
257                 err = vnic_wq_alloc(fnic->vdev, &fnic->wq[i], i,
258                         fnic->config.wq_enet_desc_count,
259                         sizeof(struct wq_enet_desc));
260                 if (err)
261                         goto err_out_cleanup;
262         }
263
264         /* Allocate Copy WQs used for SCSI IOs */
265         for (i = 0; i < fnic->wq_copy_count; i++) {
266                 err = vnic_wq_copy_alloc(fnic->vdev, &fnic->wq_copy[i],
267                         (fnic->raw_wq_count + i),
268                         fnic->config.wq_copy_desc_count,
269                         sizeof(struct fcpio_host_req));
270                 if (err)
271                         goto err_out_cleanup;
272         }
273
274         /* RQ for receiving FCS frames */
275         for (i = 0; i < fnic->rq_count; i++) {
276                 err = vnic_rq_alloc(fnic->vdev, &fnic->rq[i], i,
277                         fnic->config.rq_desc_count,
278                         sizeof(struct rq_enet_desc));
279                 if (err)
280                         goto err_out_cleanup;
281         }
282
283         /* CQ for each RQ */
284         for (i = 0; i < fnic->rq_count; i++) {
285                 cq_index = i;
286                 err = vnic_cq_alloc(fnic->vdev,
287                         &fnic->cq[cq_index], cq_index,
288                         fnic->config.rq_desc_count,
289                         sizeof(struct cq_enet_rq_desc));
290                 if (err)
291                         goto err_out_cleanup;
292         }
293
294         /* CQ for each WQ */
295         for (i = 0; i < fnic->raw_wq_count; i++) {
296                 cq_index = fnic->rq_count + i;
297                 err = vnic_cq_alloc(fnic->vdev, &fnic->cq[cq_index], cq_index,
298                         fnic->config.wq_enet_desc_count,
299                         sizeof(struct cq_enet_wq_desc));
300                 if (err)
301                         goto err_out_cleanup;
302         }
303
304         /* CQ for each COPY WQ */
305         wq_copy_cq_desc_count = (fnic->config.wq_copy_desc_count * 3);
306         for (i = 0; i < fnic->wq_copy_count; i++) {
307                 cq_index = fnic->raw_wq_count + fnic->rq_count + i;
308                 err = vnic_cq_alloc(fnic->vdev, &fnic->cq[cq_index],
309                         cq_index,
310                         wq_copy_cq_desc_count,
311                         sizeof(struct fcpio_fw_req));
312                 if (err)
313                         goto err_out_cleanup;
314         }
315
316         for (i = 0; i < fnic->intr_count; i++) {
317                 err = vnic_intr_alloc(fnic->vdev, &fnic->intr[i], i);
318                 if (err)
319                         goto err_out_cleanup;
320         }
321
322         fnic->legacy_pba = vnic_dev_get_res(fnic->vdev,
323                                 RES_TYPE_INTR_PBA_LEGACY, 0);
324
325         if (!fnic->legacy_pba && intr_mode == VNIC_DEV_INTR_MODE_INTX) {
326                 shost_printk(KERN_ERR, fnic->lport->host,
327                              "Failed to hook legacy pba resource\n");
328                 err = -ENODEV;
329                 goto err_out_cleanup;
330         }
331
332         /*
333          * Init RQ/WQ resources.
334          *
335          * RQ[0 to n-1] point to CQ[0 to n-1]
336          * WQ[0 to m-1] point to CQ[n to n+m-1]
337          * WQ_COPY[0 to k-1] points to CQ[n+m to n+m+k-1]
338          *
339          * Note for copy wq we always initialize with cq_index = 0
340          *
341          * Error interrupt is not enabled for MSI.
342          */
343
344         switch (intr_mode) {
345         case VNIC_DEV_INTR_MODE_INTX:
346         case VNIC_DEV_INTR_MODE_MSIX:
347                 error_interrupt_enable = 1;
348                 error_interrupt_offset = fnic->err_intr_offset;
349                 break;
350         default:
351                 error_interrupt_enable = 0;
352                 error_interrupt_offset = 0;
353                 break;
354         }
355
356         for (i = 0; i < fnic->rq_count; i++) {
357                 cq_index = i;
358                 vnic_rq_init(&fnic->rq[i],
359                              cq_index,
360                              error_interrupt_enable,
361                              error_interrupt_offset);
362         }
363
364         for (i = 0; i < fnic->raw_wq_count; i++) {
365                 cq_index = i + fnic->rq_count;
366                 vnic_wq_init(&fnic->wq[i],
367                              cq_index,
368                              error_interrupt_enable,
369                              error_interrupt_offset);
370         }
371
372         for (i = 0; i < fnic->wq_copy_count; i++) {
373                 vnic_wq_copy_init(&fnic->wq_copy[i],
374                                   0 /* cq_index 0 - always */,
375                                   error_interrupt_enable,
376                                   error_interrupt_offset);
377         }
378
379         for (i = 0; i < fnic->cq_count; i++) {
380
381                 switch (intr_mode) {
382                 case VNIC_DEV_INTR_MODE_MSIX:
383                         interrupt_offset = i;
384                         break;
385                 default:
386                         interrupt_offset = 0;
387                         break;
388                 }
389
390                 vnic_cq_init(&fnic->cq[i],
391                         0 /* flow_control_enable */,
392                         1 /* color_enable */,
393                         0 /* cq_head */,
394                         0 /* cq_tail */,
395                         1 /* cq_tail_color */,
396                         1 /* interrupt_enable */,
397                         1 /* cq_entry_enable */,
398                         0 /* cq_message_enable */,
399                         interrupt_offset,
400                         0 /* cq_message_addr */);
401         }
402
403         /*
404          * Init INTR resources
405          *
406          * mask_on_assertion is not used for INTx due to the level-
407          * triggered nature of INTx
408          */
409
410         switch (intr_mode) {
411         case VNIC_DEV_INTR_MODE_MSI:
412         case VNIC_DEV_INTR_MODE_MSIX:
413                 mask_on_assertion = 1;
414                 break;
415         default:
416                 mask_on_assertion = 0;
417                 break;
418         }
419
420         for (i = 0; i < fnic->intr_count; i++) {
421                 vnic_intr_init(&fnic->intr[i],
422                         fnic->config.intr_timer,
423                         fnic->config.intr_timer_type,
424                         mask_on_assertion);
425         }
426
427         /* init the stats memory by making the first call here */
428         err = vnic_dev_stats_dump(fnic->vdev, &fnic->stats);
429         if (err) {
430                 shost_printk(KERN_ERR, fnic->lport->host,
431                              "vnic_dev_stats_dump failed - x%x\n", err);
432                 goto err_out_cleanup;
433         }
434
435         /* Clear LIF stats */
436         vnic_dev_stats_clear(fnic->vdev);
437
438         return 0;
439
440 err_out_cleanup:
441         fnic_free_vnic_resources(fnic);
442
443         return err;
444 }