?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / scsi / bfa / bfad_bsg.c
blobfc515424ca88dbc16e3315f2de7f5d0f957718b4
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
4 * Copyright (c) 2014- QLogic Corporation.
5 * All rights reserved
6 * www.qlogic.com
7 *
8 * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
9 */
10
11 #include <linux/uaccess.h>
12 #include "bfad_drv.h"
13 #include "bfad_im.h"
14 #include "bfad_bsg.h"
15
16 BFA_TRC_FILE(LDRV, BSG);
17
18 static int
19 bfad_iocmd_ioc_enable(struct bfad_s *bfad, void *cmd)
20 {
21 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
22 unsigned long flags;
23
24 spin_lock_irqsave(&bfad->bfad_lock, flags);
25 /* If IOC is not in disabled state - return */
26 if (!bfa_ioc_is_disabled(&bfad->bfa.ioc)) {
27 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
28 iocmd->status = BFA_STATUS_OK;
29 return 0;
30 }
31
32 init_completion(&bfad->enable_comp);
33 bfa_iocfc_enable(&bfad->bfa);
34 iocmd->status = BFA_STATUS_OK;
35 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
36 wait_for_completion(&bfad->enable_comp);
37
38 return 0;
39 }
40
41 static int
42 bfad_iocmd_ioc_disable(struct bfad_s *bfad, void *cmd)
43 {
44 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
45 unsigned long flags;
46
47 spin_lock_irqsave(&bfad->bfad_lock, flags);
48 if (bfa_ioc_is_disabled(&bfad->bfa.ioc)) {
49 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
50 iocmd->status = BFA_STATUS_OK;
51 return 0;
52 }
53
54 if (bfad->disable_active) {
55 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
56 return -EBUSY;
57 }
58
59 bfad->disable_active = BFA_TRUE;
60 init_completion(&bfad->disable_comp);
61 bfa_iocfc_disable(&bfad->bfa);
62 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
63
64 wait_for_completion(&bfad->disable_comp);
65 bfad->disable_active = BFA_FALSE;
66 iocmd->status = BFA_STATUS_OK;
67
68 return 0;
69 }
70
71 static int
72 bfad_iocmd_ioc_get_info(struct bfad_s *bfad, void *cmd)
73 {
74 int i;
75 struct bfa_bsg_ioc_info_s *iocmd = (struct bfa_bsg_ioc_info_s *)cmd;
76 struct bfad_im_port_s *im_port;
77 struct bfa_port_attr_s pattr;
78 unsigned long flags;
79
80 spin_lock_irqsave(&bfad->bfad_lock, flags);
81 bfa_fcport_get_attr(&bfad->bfa, &pattr);
82 iocmd->nwwn = pattr.nwwn;
83 iocmd->pwwn = pattr.pwwn;
84 iocmd->ioc_type = bfa_get_type(&bfad->bfa);
85 iocmd->mac = bfa_get_mac(&bfad->bfa);
86 iocmd->factory_mac = bfa_get_mfg_mac(&bfad->bfa);
87 bfa_get_adapter_serial_num(&bfad->bfa, iocmd->serialnum);
88 iocmd->factorynwwn = pattr.factorynwwn;
89 iocmd->factorypwwn = pattr.factorypwwn;
90 iocmd->bfad_num = bfad->inst_no;
91 im_port = bfad->pport.im_port;
92 iocmd->host = im_port->shost->host_no;
93 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
94
95 strcpy(iocmd->name, bfad->adapter_name);
96 strcpy(iocmd->port_name, bfad->port_name);
97 strcpy(iocmd->hwpath, bfad->pci_name);
98
99 /* set adapter hw path */
100 strcpy(iocmd->adapter_hwpath, bfad->pci_name);
101 for (i = 0; iocmd->adapter_hwpath[i] != ':' && i < BFA_STRING_32; i++)
102 ;
103 for (; iocmd->adapter_hwpath[++i] != ':' && i < BFA_STRING_32; )
104 ;
105 iocmd->adapter_hwpath[i] = '\0';
106 iocmd->status = BFA_STATUS_OK;
107 return 0;
108 }
109
110 static int
111 bfad_iocmd_ioc_get_attr(struct bfad_s *bfad, void *cmd)
112 {
113 struct bfa_bsg_ioc_attr_s *iocmd = (struct bfa_bsg_ioc_attr_s *)cmd;
114 unsigned long flags;
115
116 spin_lock_irqsave(&bfad->bfad_lock, flags);
117 bfa_ioc_get_attr(&bfad->bfa.ioc, &iocmd->ioc_attr);
118 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
119
120 /* fill in driver attr info */
121 strcpy(iocmd->ioc_attr.driver_attr.driver, BFAD_DRIVER_NAME);
122 strlcpy(iocmd->ioc_attr.driver_attr.driver_ver,
123 BFAD_DRIVER_VERSION, BFA_VERSION_LEN);
124 strcpy(iocmd->ioc_attr.driver_attr.fw_ver,
125 iocmd->ioc_attr.adapter_attr.fw_ver);
126 strcpy(iocmd->ioc_attr.driver_attr.bios_ver,
127 iocmd->ioc_attr.adapter_attr.optrom_ver);
128
129 /* copy chip rev info first otherwise it will be overwritten */
130 memcpy(bfad->pci_attr.chip_rev, iocmd->ioc_attr.pci_attr.chip_rev,
131 sizeof(bfad->pci_attr.chip_rev));
132 memcpy(&iocmd->ioc_attr.pci_attr, &bfad->pci_attr,
133 sizeof(struct bfa_ioc_pci_attr_s));
134
135 iocmd->status = BFA_STATUS_OK;
136 return 0;
137 }
138
139 static int
140 bfad_iocmd_ioc_get_stats(struct bfad_s *bfad, void *cmd)
141 {
142 struct bfa_bsg_ioc_stats_s *iocmd = (struct bfa_bsg_ioc_stats_s *)cmd;
143
144 bfa_ioc_get_stats(&bfad->bfa, &iocmd->ioc_stats);
145 iocmd->status = BFA_STATUS_OK;
146 return 0;
147 }
148
149 static int
150 bfad_iocmd_ioc_get_fwstats(struct bfad_s *bfad, void *cmd,
151 unsigned int payload_len)
152 {
153 struct bfa_bsg_ioc_fwstats_s *iocmd =
154 (struct bfa_bsg_ioc_fwstats_s *)cmd;
155 void *iocmd_bufptr;
156 unsigned long flags;
157
158 if (bfad_chk_iocmd_sz(payload_len,
159 sizeof(struct bfa_bsg_ioc_fwstats_s),
160 sizeof(struct bfa_fw_stats_s)) != BFA_STATUS_OK) {
161 iocmd->status = BFA_STATUS_VERSION_FAIL;
162 goto out;
163 }
164
165 iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_ioc_fwstats_s);
166 spin_lock_irqsave(&bfad->bfad_lock, flags);
167 iocmd->status = bfa_ioc_fw_stats_get(&bfad->bfa.ioc, iocmd_bufptr);
168 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
169
170 if (iocmd->status != BFA_STATUS_OK) {
171 bfa_trc(bfad, iocmd->status);
172 goto out;
173 }
174 out:
175 bfa_trc(bfad, 0x6666);
176 return 0;
177 }
178
179 static int
180 bfad_iocmd_ioc_reset_stats(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
181 {
182 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
183 unsigned long flags;
184
185 if (v_cmd == IOCMD_IOC_RESET_STATS) {
186 bfa_ioc_clear_stats(&bfad->bfa);
187 iocmd->status = BFA_STATUS_OK;
188 } else if (v_cmd == IOCMD_IOC_RESET_FWSTATS) {
189 spin_lock_irqsave(&bfad->bfad_lock, flags);
190 iocmd->status = bfa_ioc_fw_stats_clear(&bfad->bfa.ioc);
191 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
192 }
193
194 return 0;
195 }
196
197 static int
198 bfad_iocmd_ioc_set_name(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
199 {
200 struct bfa_bsg_ioc_name_s *iocmd = (struct bfa_bsg_ioc_name_s *) cmd;
201
202 if (v_cmd == IOCMD_IOC_SET_ADAPTER_NAME)
203 strcpy(bfad->adapter_name, iocmd->name);
204 else if (v_cmd == IOCMD_IOC_SET_PORT_NAME)
205 strcpy(bfad->port_name, iocmd->name);
206
207 iocmd->status = BFA_STATUS_OK;
208 return 0;
209 }
210
211 static int
212 bfad_iocmd_iocfc_get_attr(struct bfad_s *bfad, void *cmd)
213 {
214 struct bfa_bsg_iocfc_attr_s *iocmd = (struct bfa_bsg_iocfc_attr_s *)cmd;
215
216 iocmd->status = BFA_STATUS_OK;
217 bfa_iocfc_get_attr(&bfad->bfa, &iocmd->iocfc_attr);
218
219 return 0;
220 }
221
222 static int
223 bfad_iocmd_ioc_fw_sig_inv(struct bfad_s *bfad, void *cmd)
224 {
225 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
226 unsigned long flags;
227
228 spin_lock_irqsave(&bfad->bfad_lock, flags);
229 iocmd->status = bfa_ioc_fwsig_invalidate(&bfad->bfa.ioc);
230 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
231 return 0;
232 }
233
234 static int
235 bfad_iocmd_iocfc_set_intr(struct bfad_s *bfad, void *cmd)
236 {
237 struct bfa_bsg_iocfc_intr_s *iocmd = (struct bfa_bsg_iocfc_intr_s *)cmd;
238 unsigned long flags;
239
240 spin_lock_irqsave(&bfad->bfad_lock, flags);
241 iocmd->status = bfa_iocfc_israttr_set(&bfad->bfa, &iocmd->attr);
242 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
243
244 return 0;
245 }
246
247 static int
248 bfad_iocmd_port_enable(struct bfad_s *bfad, void *cmd)
249 {
250 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
251 struct bfad_hal_comp fcomp;
252 unsigned long flags;
253
254 init_completion(&fcomp.comp);
255 spin_lock_irqsave(&bfad->bfad_lock, flags);
256 iocmd->status = bfa_port_enable(&bfad->bfa.modules.port,
257 bfad_hcb_comp, &fcomp);
258 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
259 if (iocmd->status != BFA_STATUS_OK) {
260 bfa_trc(bfad, iocmd->status);
261 return 0;
262 }
263 wait_for_completion(&fcomp.comp);
264 iocmd->status = fcomp.status;
265 return 0;
266 }
267
268 static int
269 bfad_iocmd_port_disable(struct bfad_s *bfad, void *cmd)
270 {
271 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
272 struct bfad_hal_comp fcomp;
273 unsigned long flags;
274
275 init_completion(&fcomp.comp);
276 spin_lock_irqsave(&bfad->bfad_lock, flags);
277 iocmd->status = bfa_port_disable(&bfad->bfa.modules.port,
278 bfad_hcb_comp, &fcomp);
279 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
280
281 if (iocmd->status != BFA_STATUS_OK) {
282 bfa_trc(bfad, iocmd->status);
283 return 0;
284 }
285 wait_for_completion(&fcomp.comp);
286 iocmd->status = fcomp.status;
287 return 0;
288 }
289
290 static int
291 bfad_iocmd_port_get_attr(struct bfad_s *bfad, void *cmd)
292 {
293 struct bfa_bsg_port_attr_s *iocmd = (struct bfa_bsg_port_attr_s *)cmd;
294 struct bfa_lport_attr_s port_attr;
295 unsigned long flags;
296
297 spin_lock_irqsave(&bfad->bfad_lock, flags);
298 bfa_fcport_get_attr(&bfad->bfa, &iocmd->attr);
299 bfa_fcs_lport_get_attr(&bfad->bfa_fcs.fabric.bport, &port_attr);
300 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
301
302 if (iocmd->attr.topology != BFA_PORT_TOPOLOGY_NONE)
303 iocmd->attr.pid = port_attr.pid;
304 else
305 iocmd->attr.pid = 0;
306
307 iocmd->attr.port_type = port_attr.port_type;
308 iocmd->attr.loopback = port_attr.loopback;
309 iocmd->attr.authfail = port_attr.authfail;
310 strlcpy(iocmd->attr.port_symname.symname,
311 port_attr.port_cfg.sym_name.symname,
312 sizeof(iocmd->attr.port_symname.symname));
313
314 iocmd->status = BFA_STATUS_OK;
315 return 0;
316 }
317
318 static int
319 bfad_iocmd_port_get_stats(struct bfad_s *bfad, void *cmd,
320 unsigned int payload_len)
321 {
322 struct bfa_bsg_port_stats_s *iocmd = (struct bfa_bsg_port_stats_s *)cmd;
323 struct bfad_hal_comp fcomp;
324 void *iocmd_bufptr;
325 unsigned long flags;
326
327 if (bfad_chk_iocmd_sz(payload_len,
328 sizeof(struct bfa_bsg_port_stats_s),
329 sizeof(union bfa_port_stats_u)) != BFA_STATUS_OK) {
330 iocmd->status = BFA_STATUS_VERSION_FAIL;
331 return 0;
332 }
333
334 iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_port_stats_s);
335
336 init_completion(&fcomp.comp);
337 spin_lock_irqsave(&bfad->bfad_lock, flags);
338 iocmd->status = bfa_port_get_stats(&bfad->bfa.modules.port,
339 iocmd_bufptr, bfad_hcb_comp, &fcomp);
340 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
341 if (iocmd->status != BFA_STATUS_OK) {
342 bfa_trc(bfad, iocmd->status);
343 goto out;
344 }
345
346 wait_for_completion(&fcomp.comp);
347 iocmd->status = fcomp.status;
348 out:
349 return 0;
350 }
351
352 static int
353 bfad_iocmd_port_reset_stats(struct bfad_s *bfad, void *cmd)
354 {
355 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
356 struct bfad_hal_comp fcomp;
357 unsigned long flags;
358
359 init_completion(&fcomp.comp);
360 spin_lock_irqsave(&bfad->bfad_lock, flags);
361 iocmd->status = bfa_port_clear_stats(&bfad->bfa.modules.port,
362 bfad_hcb_comp, &fcomp);
363 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
364 if (iocmd->status != BFA_STATUS_OK) {
365 bfa_trc(bfad, iocmd->status);
366 return 0;
367 }
368 wait_for_completion(&fcomp.comp);
369 iocmd->status = fcomp.status;
370 return 0;
371 }
372
373 static int
374 bfad_iocmd_set_port_cfg(struct bfad_s *bfad, void *iocmd, unsigned int v_cmd)
375 {
376 struct bfa_bsg_port_cfg_s *cmd = (struct bfa_bsg_port_cfg_s *)iocmd;
377 unsigned long flags;
378
379 spin_lock_irqsave(&bfad->bfad_lock, flags);
380 if (v_cmd == IOCMD_PORT_CFG_TOPO)
381 cmd->status = bfa_fcport_cfg_topology(&bfad->bfa, cmd->param);
382 else if (v_cmd == IOCMD_PORT_CFG_SPEED)
383 cmd->status = bfa_fcport_cfg_speed(&bfad->bfa, cmd->param);
384 else if (v_cmd == IOCMD_PORT_CFG_ALPA)
385 cmd->status = bfa_fcport_cfg_hardalpa(&bfad->bfa, cmd->param);
386 else if (v_cmd == IOCMD_PORT_CLR_ALPA)
387 cmd->status = bfa_fcport_clr_hardalpa(&bfad->bfa);
388 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
389
390 return 0;
391 }
392
393 static int
394 bfad_iocmd_port_cfg_maxfrsize(struct bfad_s *bfad, void *cmd)
395 {
396 struct bfa_bsg_port_cfg_maxfrsize_s *iocmd =
397 (struct bfa_bsg_port_cfg_maxfrsize_s *)cmd;
398 unsigned long flags;
399
400 spin_lock_irqsave(&bfad->bfad_lock, flags);
401 iocmd->status = bfa_fcport_cfg_maxfrsize(&bfad->bfa, iocmd->maxfrsize);
402 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
403
404 return 0;
405 }
406
407 static int
408 bfad_iocmd_port_cfg_bbcr(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
409 {
410 struct bfa_bsg_bbcr_enable_s *iocmd =
411 (struct bfa_bsg_bbcr_enable_s *)pcmd;
412 unsigned long flags;
413 int rc;
414
415 spin_lock_irqsave(&bfad->bfad_lock, flags);
416 if (cmd == IOCMD_PORT_BBCR_ENABLE)
417 rc = bfa_fcport_cfg_bbcr(&bfad->bfa, BFA_TRUE, iocmd->bb_scn);
418 else if (cmd == IOCMD_PORT_BBCR_DISABLE)
419 rc = bfa_fcport_cfg_bbcr(&bfad->bfa, BFA_FALSE, 0);
420 else {
421 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
422 return -EINVAL;
423 }
424 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
425
426 iocmd->status = rc;
427 return 0;
428 }
429
430 static int
431 bfad_iocmd_port_get_bbcr_attr(struct bfad_s *bfad, void *pcmd)
432 {
433 struct bfa_bsg_bbcr_attr_s *iocmd = (struct bfa_bsg_bbcr_attr_s *) pcmd;
434 unsigned long flags;
435
436 spin_lock_irqsave(&bfad->bfad_lock, flags);
437 iocmd->status =
438 bfa_fcport_get_bbcr_attr(&bfad->bfa, &iocmd->attr);
439 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
440
441 return 0;
442 }
443
444
445 static int
446 bfad_iocmd_lport_get_attr(struct bfad_s *bfad, void *cmd)
447 {
448 struct bfa_fcs_lport_s *fcs_port;
449 struct bfa_bsg_lport_attr_s *iocmd = (struct bfa_bsg_lport_attr_s *)cmd;
450 unsigned long flags;
451
452 spin_lock_irqsave(&bfad->bfad_lock, flags);
453 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
454 iocmd->vf_id, iocmd->pwwn);
455 if (fcs_port == NULL) {
456 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
457 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
458 goto out;
459 }
460
461 bfa_fcs_lport_get_attr(fcs_port, &iocmd->port_attr);
462 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
463 iocmd->status = BFA_STATUS_OK;
464 out:
465 return 0;
466 }
467
468 static int
469 bfad_iocmd_lport_get_stats(struct bfad_s *bfad, void *cmd)
470 {
471 struct bfa_fcs_lport_s *fcs_port;
472 struct bfa_bsg_lport_stats_s *iocmd =
473 (struct bfa_bsg_lport_stats_s *)cmd;
474 unsigned long flags;
475
476 spin_lock_irqsave(&bfad->bfad_lock, flags);
477 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
478 iocmd->vf_id, iocmd->pwwn);
479 if (fcs_port == NULL) {
480 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
481 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
482 goto out;
483 }
484
485 bfa_fcs_lport_get_stats(fcs_port, &iocmd->port_stats);
486 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
487 iocmd->status = BFA_STATUS_OK;
488 out:
489 return 0;
490 }
491
492 static int
493 bfad_iocmd_lport_reset_stats(struct bfad_s *bfad, void *cmd)
494 {
495 struct bfa_fcs_lport_s *fcs_port;
496 struct bfa_bsg_reset_stats_s *iocmd =
497 (struct bfa_bsg_reset_stats_s *)cmd;
498 struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
499 struct list_head *qe, *qen;
500 struct bfa_itnim_s *itnim;
501 unsigned long flags;
502
503 spin_lock_irqsave(&bfad->bfad_lock, flags);
504 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
505 iocmd->vf_id, iocmd->vpwwn);
506 if (fcs_port == NULL) {
507 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
508 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
509 goto out;
510 }
511
512 bfa_fcs_lport_clear_stats(fcs_port);
513 /* clear IO stats from all active itnims */
514 list_for_each_safe(qe, qen, &fcpim->itnim_q) {
515 itnim = (struct bfa_itnim_s *) qe;
516 if (itnim->rport->rport_info.lp_tag != fcs_port->lp_tag)
517 continue;
518 bfa_itnim_clear_stats(itnim);
519 }
520 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
521 iocmd->status = BFA_STATUS_OK;
522 out:
523 return 0;
524 }
525
526 static int
527 bfad_iocmd_lport_get_iostats(struct bfad_s *bfad, void *cmd)
528 {
529 struct bfa_fcs_lport_s *fcs_port;
530 struct bfa_bsg_lport_iostats_s *iocmd =
531 (struct bfa_bsg_lport_iostats_s *)cmd;
532 unsigned long flags;
533
534 spin_lock_irqsave(&bfad->bfad_lock, flags);
535 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
536 iocmd->vf_id, iocmd->pwwn);
537 if (fcs_port == NULL) {
538 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
539 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
540 goto out;
541 }
542
543 bfa_fcpim_port_iostats(&bfad->bfa, &iocmd->iostats,
544 fcs_port->lp_tag);
545 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
546 iocmd->status = BFA_STATUS_OK;
547 out:
548 return 0;
549 }
550
551 static int
552 bfad_iocmd_lport_get_rports(struct bfad_s *bfad, void *cmd,
553 unsigned int payload_len)
554 {
555 struct bfa_bsg_lport_get_rports_s *iocmd =
556 (struct bfa_bsg_lport_get_rports_s *)cmd;
557 struct bfa_fcs_lport_s *fcs_port;
558 unsigned long flags;
559 void *iocmd_bufptr;
560
561 if (iocmd->nrports == 0)
562 return -EINVAL;
563
564 if (bfad_chk_iocmd_sz(payload_len,
565 sizeof(struct bfa_bsg_lport_get_rports_s),
566 sizeof(struct bfa_rport_qualifier_s) * iocmd->nrports)
567 != BFA_STATUS_OK) {
568 iocmd->status = BFA_STATUS_VERSION_FAIL;
569 return 0;
570 }
571
572 iocmd_bufptr = (char *)iocmd +
573 sizeof(struct bfa_bsg_lport_get_rports_s);
574 spin_lock_irqsave(&bfad->bfad_lock, flags);
575 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
576 iocmd->vf_id, iocmd->pwwn);
577 if (fcs_port == NULL) {
578 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
579 bfa_trc(bfad, 0);
580 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
581 goto out;
582 }
583
584 bfa_fcs_lport_get_rport_quals(fcs_port,
585 (struct bfa_rport_qualifier_s *)iocmd_bufptr,
586 &iocmd->nrports);
587 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
588 iocmd->status = BFA_STATUS_OK;
589 out:
590 return 0;
591 }
592
593 static int
594 bfad_iocmd_rport_get_attr(struct bfad_s *bfad, void *cmd)
595 {
596 struct bfa_bsg_rport_attr_s *iocmd = (struct bfa_bsg_rport_attr_s *)cmd;
597 struct bfa_fcs_lport_s *fcs_port;
598 struct bfa_fcs_rport_s *fcs_rport;
599 unsigned long flags;
600
601 spin_lock_irqsave(&bfad->bfad_lock, flags);
602 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
603 iocmd->vf_id, iocmd->pwwn);
604 if (fcs_port == NULL) {
605 bfa_trc(bfad, 0);
606 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
607 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
608 goto out;
609 }
610
611 if (iocmd->pid)
612 fcs_rport = bfa_fcs_lport_get_rport_by_qualifier(fcs_port,
613 iocmd->rpwwn, iocmd->pid);
614 else
615 fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
616 if (fcs_rport == NULL) {
617 bfa_trc(bfad, 0);
618 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
619 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
620 goto out;
621 }
622
623 bfa_fcs_rport_get_attr(fcs_rport, &iocmd->attr);
624 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
625 iocmd->status = BFA_STATUS_OK;
626 out:
627 return 0;
628 }
629
630 static int
631 bfad_iocmd_rport_get_addr(struct bfad_s *bfad, void *cmd)
632 {
633 struct bfa_bsg_rport_scsi_addr_s *iocmd =
634 (struct bfa_bsg_rport_scsi_addr_s *)cmd;
635 struct bfa_fcs_lport_s *fcs_port;
636 struct bfa_fcs_itnim_s *fcs_itnim;
637 struct bfad_itnim_s *drv_itnim;
638 unsigned long flags;
639
640 spin_lock_irqsave(&bfad->bfad_lock, flags);
641 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
642 iocmd->vf_id, iocmd->pwwn);
643 if (fcs_port == NULL) {
644 bfa_trc(bfad, 0);
645 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
646 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
647 goto out;
648 }
649
650 fcs_itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
651 if (fcs_itnim == NULL) {
652 bfa_trc(bfad, 0);
653 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
654 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
655 goto out;
656 }
657
658 drv_itnim = fcs_itnim->itnim_drv;
659
660 if (drv_itnim && drv_itnim->im_port)
661 iocmd->host = drv_itnim->im_port->shost->host_no;
662 else {
663 bfa_trc(bfad, 0);
664 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
665 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
666 goto out;
667 }
668
669 iocmd->target = drv_itnim->scsi_tgt_id;
670 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
671
672 iocmd->bus = 0;
673 iocmd->lun = 0;
674 iocmd->status = BFA_STATUS_OK;
675 out:
676 return 0;
677 }
678
679 static int
680 bfad_iocmd_rport_get_stats(struct bfad_s *bfad, void *cmd)
681 {
682 struct bfa_bsg_rport_stats_s *iocmd =
683 (struct bfa_bsg_rport_stats_s *)cmd;
684 struct bfa_fcs_lport_s *fcs_port;
685 struct bfa_fcs_rport_s *fcs_rport;
686 unsigned long flags;
687
688 spin_lock_irqsave(&bfad->bfad_lock, flags);
689 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
690 iocmd->vf_id, iocmd->pwwn);
691 if (fcs_port == NULL) {
692 bfa_trc(bfad, 0);
693 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
694 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
695 goto out;
696 }
697
698 fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
699 if (fcs_rport == NULL) {
700 bfa_trc(bfad, 0);
701 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
702 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
703 goto out;
704 }
705
706 memcpy((void *)&iocmd->stats, (void *)&fcs_rport->stats,
707 sizeof(struct bfa_rport_stats_s));
708 if (bfa_fcs_rport_get_halrport(fcs_rport)) {
709 memcpy((void *)&iocmd->stats.hal_stats,
710 (void *)&(bfa_fcs_rport_get_halrport(fcs_rport)->stats),
711 sizeof(struct bfa_rport_hal_stats_s));
712 }
713
714 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
715 iocmd->status = BFA_STATUS_OK;
716 out:
717 return 0;
718 }
719
720 static int
721 bfad_iocmd_rport_clr_stats(struct bfad_s *bfad, void *cmd)
722 {
723 struct bfa_bsg_rport_reset_stats_s *iocmd =
724 (struct bfa_bsg_rport_reset_stats_s *)cmd;
725 struct bfa_fcs_lport_s *fcs_port;
726 struct bfa_fcs_rport_s *fcs_rport;
727 struct bfa_rport_s *rport;
728 unsigned long flags;
729
730 spin_lock_irqsave(&bfad->bfad_lock, flags);
731 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
732 iocmd->vf_id, iocmd->pwwn);
733 if (fcs_port == NULL) {
734 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
735 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
736 goto out;
737 }
738
739 fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
740 if (fcs_rport == NULL) {
741 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
742 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
743 goto out;
744 }
745
746 memset((char *)&fcs_rport->stats, 0, sizeof(struct bfa_rport_stats_s));
747 rport = bfa_fcs_rport_get_halrport(fcs_rport);
748 if (rport)
749 memset(&rport->stats, 0, sizeof(rport->stats));
750 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
751 iocmd->status = BFA_STATUS_OK;
752 out:
753 return 0;
754 }
755
756 static int
757 bfad_iocmd_rport_set_speed(struct bfad_s *bfad, void *cmd)
758 {
759 struct bfa_bsg_rport_set_speed_s *iocmd =
760 (struct bfa_bsg_rport_set_speed_s *)cmd;
761 struct bfa_fcs_lport_s *fcs_port;
762 struct bfa_fcs_rport_s *fcs_rport;
763 unsigned long flags;
764
765 spin_lock_irqsave(&bfad->bfad_lock, flags);
766 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
767 iocmd->vf_id, iocmd->pwwn);
768 if (fcs_port == NULL) {
769 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
770 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
771 goto out;
772 }
773
774 fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
775 if (fcs_rport == NULL) {
776 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
777 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
778 goto out;
779 }
780
781 fcs_rport->rpf.assigned_speed = iocmd->speed;
782 /* Set this speed in f/w only if the RPSC speed is not available */
783 if (fcs_rport->rpf.rpsc_speed == BFA_PORT_SPEED_UNKNOWN)
784 if (fcs_rport->bfa_rport)
785 bfa_rport_speed(fcs_rport->bfa_rport, iocmd->speed);
786 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
787 iocmd->status = BFA_STATUS_OK;
788 out:
789 return 0;
790 }
791
792 static int
793 bfad_iocmd_vport_get_attr(struct bfad_s *bfad, void *cmd)
794 {
795 struct bfa_fcs_vport_s *fcs_vport;
796 struct bfa_bsg_vport_attr_s *iocmd = (struct bfa_bsg_vport_attr_s *)cmd;
797 unsigned long flags;
798
799 spin_lock_irqsave(&bfad->bfad_lock, flags);
800 fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs,
801 iocmd->vf_id, iocmd->vpwwn);
802 if (fcs_vport == NULL) {
803 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
804 iocmd->status = BFA_STATUS_UNKNOWN_VWWN;
805 goto out;
806 }
807
808 bfa_fcs_vport_get_attr(fcs_vport, &iocmd->vport_attr);
809 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
810 iocmd->status = BFA_STATUS_OK;
811 out:
812 return 0;
813 }
814
815 static int
816 bfad_iocmd_vport_get_stats(struct bfad_s *bfad, void *cmd)
817 {
818 struct bfa_fcs_vport_s *fcs_vport;
819 struct bfa_bsg_vport_stats_s *iocmd =
820 (struct bfa_bsg_vport_stats_s *)cmd;
821 unsigned long flags;
822
823 spin_lock_irqsave(&bfad->bfad_lock, flags);
824 fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs,
825 iocmd->vf_id, iocmd->vpwwn);
826 if (fcs_vport == NULL) {
827 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
828 iocmd->status = BFA_STATUS_UNKNOWN_VWWN;
829 goto out;
830 }
831
832 memcpy((void *)&iocmd->vport_stats, (void *)&fcs_vport->vport_stats,
833 sizeof(struct bfa_vport_stats_s));
834 memcpy((void *)&iocmd->vport_stats.port_stats,
835 (void *)&fcs_vport->lport.stats,
836 sizeof(struct bfa_lport_stats_s));
837 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
838 iocmd->status = BFA_STATUS_OK;
839 out:
840 return 0;
841 }
842
843 static int
844 bfad_iocmd_vport_clr_stats(struct bfad_s *bfad, void *cmd)
845 {
846 struct bfa_fcs_vport_s *fcs_vport;
847 struct bfa_bsg_reset_stats_s *iocmd =
848 (struct bfa_bsg_reset_stats_s *)cmd;
849 unsigned long flags;
850
851 spin_lock_irqsave(&bfad->bfad_lock, flags);
852 fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs,
853 iocmd->vf_id, iocmd->vpwwn);
854 if (fcs_vport == NULL) {
855 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
856 iocmd->status = BFA_STATUS_UNKNOWN_VWWN;
857 goto out;
858 }
859
860 memset(&fcs_vport->vport_stats, 0, sizeof(struct bfa_vport_stats_s));
861 memset(&fcs_vport->lport.stats, 0, sizeof(struct bfa_lport_stats_s));
862 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
863 iocmd->status = BFA_STATUS_OK;
864 out:
865 return 0;
866 }
867
868 static int
869 bfad_iocmd_fabric_get_lports(struct bfad_s *bfad, void *cmd,
870 unsigned int payload_len)
871 {
872 struct bfa_bsg_fabric_get_lports_s *iocmd =
873 (struct bfa_bsg_fabric_get_lports_s *)cmd;
874 bfa_fcs_vf_t *fcs_vf;
875 uint32_t nports = iocmd->nports;
876 unsigned long flags;
877 void *iocmd_bufptr;
878
879 if (nports == 0) {
880 iocmd->status = BFA_STATUS_EINVAL;
881 goto out;
882 }
883
884 if (bfad_chk_iocmd_sz(payload_len,
885 sizeof(struct bfa_bsg_fabric_get_lports_s),
886 sizeof(wwn_t) * iocmd->nports) != BFA_STATUS_OK) {
887 iocmd->status = BFA_STATUS_VERSION_FAIL;
888 goto out;
889 }
890
891 iocmd_bufptr = (char *)iocmd +
892 sizeof(struct bfa_bsg_fabric_get_lports_s);
893
894 spin_lock_irqsave(&bfad->bfad_lock, flags);
895 fcs_vf = bfa_fcs_vf_lookup(&bfad->bfa_fcs, iocmd->vf_id);
896 if (fcs_vf == NULL) {
897 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
898 iocmd->status = BFA_STATUS_UNKNOWN_VFID;
899 goto out;
900 }
901 bfa_fcs_vf_get_ports(fcs_vf, (wwn_t *)iocmd_bufptr, &nports);
902 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
903
904 iocmd->nports = nports;
905 iocmd->status = BFA_STATUS_OK;
906 out:
907 return 0;
908 }
909
910 static int
911 bfad_iocmd_qos_set_bw(struct bfad_s *bfad, void *pcmd)
912 {
913 struct bfa_bsg_qos_bw_s *iocmd = (struct bfa_bsg_qos_bw_s *)pcmd;
914 unsigned long flags;
915
916 spin_lock_irqsave(&bfad->bfad_lock, flags);
917 iocmd->status = bfa_fcport_set_qos_bw(&bfad->bfa, &iocmd->qos_bw);
918 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
919
920 return 0;
921 }
922
923 static int
924 bfad_iocmd_ratelim(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
925 {
926 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
927 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
928 unsigned long flags;
929
930 spin_lock_irqsave(&bfad->bfad_lock, flags);
931
932 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
933 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
934 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
935 else {
936 if (cmd == IOCMD_RATELIM_ENABLE)
937 fcport->cfg.ratelimit = BFA_TRUE;
938 else if (cmd == IOCMD_RATELIM_DISABLE)
939 fcport->cfg.ratelimit = BFA_FALSE;
940
941 if (fcport->cfg.trl_def_speed == BFA_PORT_SPEED_UNKNOWN)
942 fcport->cfg.trl_def_speed = BFA_PORT_SPEED_1GBPS;
943
944 iocmd->status = BFA_STATUS_OK;
945 }
946
947 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
948
949 return 0;
950 }
951
952 static int
953 bfad_iocmd_ratelim_speed(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
954 {
955 struct bfa_bsg_trl_speed_s *iocmd = (struct bfa_bsg_trl_speed_s *)pcmd;
956 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
957 unsigned long flags;
958
959 spin_lock_irqsave(&bfad->bfad_lock, flags);
960
961 /* Auto and speeds greater than the supported speed, are invalid */
962 if ((iocmd->speed == BFA_PORT_SPEED_AUTO) ||
963 (iocmd->speed > fcport->speed_sup)) {
964 iocmd->status = BFA_STATUS_UNSUPP_SPEED;
965 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
966 return 0;
967 }
968
969 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
970 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
971 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
972 else {
973 fcport->cfg.trl_def_speed = iocmd->speed;
974 iocmd->status = BFA_STATUS_OK;
975 }
976 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
977
978 return 0;
979 }
980
981 static int
982 bfad_iocmd_cfg_fcpim(struct bfad_s *bfad, void *cmd)
983 {
984 struct bfa_bsg_fcpim_s *iocmd = (struct bfa_bsg_fcpim_s *)cmd;
985 unsigned long flags;
986
987 spin_lock_irqsave(&bfad->bfad_lock, flags);
988 bfa_fcpim_path_tov_set(&bfad->bfa, iocmd->param);
989 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
990 iocmd->status = BFA_STATUS_OK;
991 return 0;
992 }
993
994 static int
995 bfad_iocmd_fcpim_get_modstats(struct bfad_s *bfad, void *cmd)
996 {
997 struct bfa_bsg_fcpim_modstats_s *iocmd =
998 (struct bfa_bsg_fcpim_modstats_s *)cmd;
999 struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
1000 struct list_head *qe, *qen;
1001 struct bfa_itnim_s *itnim;
1002 unsigned long flags;
1003
1004 spin_lock_irqsave(&bfad->bfad_lock, flags);
1005 /* accumulate IO stats from itnim */
1006 memset((void *)&iocmd->modstats, 0, sizeof(struct bfa_itnim_iostats_s));
1007 list_for_each_safe(qe, qen, &fcpim->itnim_q) {
1008 itnim = (struct bfa_itnim_s *) qe;
1009 bfa_fcpim_add_stats(&iocmd->modstats, &(itnim->stats));
1010 }
1011 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1012 iocmd->status = BFA_STATUS_OK;
1013 return 0;
1014 }
1015
1016 static int
1017 bfad_iocmd_fcpim_clr_modstats(struct bfad_s *bfad, void *cmd)
1018 {
1019 struct bfa_bsg_fcpim_modstatsclr_s *iocmd =
1020 (struct bfa_bsg_fcpim_modstatsclr_s *)cmd;
1021 struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
1022 struct list_head *qe, *qen;
1023 struct bfa_itnim_s *itnim;
1024 unsigned long flags;
1025
1026 spin_lock_irqsave(&bfad->bfad_lock, flags);
1027 list_for_each_safe(qe, qen, &fcpim->itnim_q) {
1028 itnim = (struct bfa_itnim_s *) qe;
1029 bfa_itnim_clear_stats(itnim);
1030 }
1031 memset(&fcpim->del_itn_stats, 0,
1032 sizeof(struct bfa_fcpim_del_itn_stats_s));
1033 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1034 iocmd->status = BFA_STATUS_OK;
1035 return 0;
1036 }
1037
1038 static int
1039 bfad_iocmd_fcpim_get_del_itn_stats(struct bfad_s *bfad, void *cmd)
1040 {
1041 struct bfa_bsg_fcpim_del_itn_stats_s *iocmd =
1042 (struct bfa_bsg_fcpim_del_itn_stats_s *)cmd;
1043 struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
1044 unsigned long flags;
1045
1046 spin_lock_irqsave(&bfad->bfad_lock, flags);
1047 memcpy((void *)&iocmd->modstats, (void *)&fcpim->del_itn_stats,
1048 sizeof(struct bfa_fcpim_del_itn_stats_s));
1049 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1050
1051 iocmd->status = BFA_STATUS_OK;
1052 return 0;
1053 }
1054
1055 static int
1056 bfad_iocmd_itnim_get_attr(struct bfad_s *bfad, void *cmd)
1057 {
1058 struct bfa_bsg_itnim_attr_s *iocmd = (struct bfa_bsg_itnim_attr_s *)cmd;
1059 struct bfa_fcs_lport_s *fcs_port;
1060 unsigned long flags;
1061
1062 spin_lock_irqsave(&bfad->bfad_lock, flags);
1063 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
1064 iocmd->vf_id, iocmd->lpwwn);
1065 if (!fcs_port)
1066 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
1067 else
1068 iocmd->status = bfa_fcs_itnim_attr_get(fcs_port,
1069 iocmd->rpwwn, &iocmd->attr);
1070 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1071 return 0;
1072 }
1073
1074 static int
1075 bfad_iocmd_itnim_get_iostats(struct bfad_s *bfad, void *cmd)
1076 {
1077 struct bfa_bsg_itnim_iostats_s *iocmd =
1078 (struct bfa_bsg_itnim_iostats_s *)cmd;
1079 struct bfa_fcs_lport_s *fcs_port;
1080 struct bfa_fcs_itnim_s *itnim;
1081 unsigned long flags;
1082
1083 spin_lock_irqsave(&bfad->bfad_lock, flags);
1084 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
1085 iocmd->vf_id, iocmd->lpwwn);
1086 if (!fcs_port) {
1087 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
1088 bfa_trc(bfad, 0);
1089 } else {
1090 itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
1091 if (itnim == NULL)
1092 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
1093 else {
1094 iocmd->status = BFA_STATUS_OK;
1095 if (bfa_fcs_itnim_get_halitn(itnim))
1096 memcpy((void *)&iocmd->iostats, (void *)
1097 &(bfa_fcs_itnim_get_halitn(itnim)->stats),
1098 sizeof(struct bfa_itnim_iostats_s));
1099 }
1100 }
1101 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1102 return 0;
1103 }
1104
1105 static int
1106 bfad_iocmd_itnim_reset_stats(struct bfad_s *bfad, void *cmd)
1107 {
1108 struct bfa_bsg_rport_reset_stats_s *iocmd =
1109 (struct bfa_bsg_rport_reset_stats_s *)cmd;
1110 struct bfa_fcs_lport_s *fcs_port;
1111 struct bfa_fcs_itnim_s *itnim;
1112 unsigned long flags;
1113
1114 spin_lock_irqsave(&bfad->bfad_lock, flags);
1115 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
1116 iocmd->vf_id, iocmd->pwwn);
1117 if (!fcs_port)
1118 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
1119 else {
1120 itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
1121 if (itnim == NULL)
1122 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
1123 else {
1124 iocmd->status = BFA_STATUS_OK;
1125 bfa_fcs_itnim_stats_clear(fcs_port, iocmd->rpwwn);
1126 bfa_itnim_clear_stats(bfa_fcs_itnim_get_halitn(itnim));
1127 }
1128 }
1129 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1130
1131 return 0;
1132 }
1133
1134 static int
1135 bfad_iocmd_itnim_get_itnstats(struct bfad_s *bfad, void *cmd)
1136 {
1137 struct bfa_bsg_itnim_itnstats_s *iocmd =
1138 (struct bfa_bsg_itnim_itnstats_s *)cmd;
1139 struct bfa_fcs_lport_s *fcs_port;
1140 struct bfa_fcs_itnim_s *itnim;
1141 unsigned long flags;
1142
1143 spin_lock_irqsave(&bfad->bfad_lock, flags);
1144 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
1145 iocmd->vf_id, iocmd->lpwwn);
1146 if (!fcs_port) {
1147 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
1148 bfa_trc(bfad, 0);
1149 } else {
1150 itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
1151 if (itnim == NULL)
1152 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
1153 else {
1154 iocmd->status = BFA_STATUS_OK;
1155 bfa_fcs_itnim_stats_get(fcs_port, iocmd->rpwwn,
1156 &iocmd->itnstats);
1157 }
1158 }
1159 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1160 return 0;
1161 }
1162
1163 static int
1164 bfad_iocmd_fcport_enable(struct bfad_s *bfad, void *cmd)
1165 {
1166 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
1167 unsigned long flags;
1168
1169 spin_lock_irqsave(&bfad->bfad_lock, flags);
1170 iocmd->status = bfa_fcport_enable(&bfad->bfa);
1171 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1172
1173 return 0;
1174 }
1175
1176 static int
1177 bfad_iocmd_fcport_disable(struct bfad_s *bfad, void *cmd)
1178 {
1179 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
1180 unsigned long flags;
1181
1182 spin_lock_irqsave(&bfad->bfad_lock, flags);
1183 iocmd->status = bfa_fcport_disable(&bfad->bfa);
1184 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1185
1186 return 0;
1187 }
1188
1189 static int
1190 bfad_iocmd_ioc_get_pcifn_cfg(struct bfad_s *bfad, void *cmd)
1191 {
1192 struct bfa_bsg_pcifn_cfg_s *iocmd = (struct bfa_bsg_pcifn_cfg_s *)cmd;
1193 struct bfad_hal_comp fcomp;
1194 unsigned long flags;
1195
1196 init_completion(&fcomp.comp);
1197 spin_lock_irqsave(&bfad->bfad_lock, flags);
1198 iocmd->status = bfa_ablk_query(&bfad->bfa.modules.ablk,
1199 &iocmd->pcifn_cfg,
1200 bfad_hcb_comp, &fcomp);
1201 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1202 if (iocmd->status != BFA_STATUS_OK)
1203 goto out;
1204
1205 wait_for_completion(&fcomp.comp);
1206 iocmd->status = fcomp.status;
1207 out:
1208 return 0;
1209 }
1210
1211 static int
1212 bfad_iocmd_pcifn_create(struct bfad_s *bfad, void *cmd)
1213 {
1214 struct bfa_bsg_pcifn_s *iocmd = (struct bfa_bsg_pcifn_s *)cmd;
1215 struct bfad_hal_comp fcomp;
1216 unsigned long flags;
1217
1218 init_completion(&fcomp.comp);
1219 spin_lock_irqsave(&bfad->bfad_lock, flags);
1220 iocmd->status = bfa_ablk_pf_create(&bfad->bfa.modules.ablk,
1221 &iocmd->pcifn_id, iocmd->port,
1222 iocmd->pcifn_class, iocmd->bw_min,
1223 iocmd->bw_max, bfad_hcb_comp, &fcomp);
1224 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1225 if (iocmd->status != BFA_STATUS_OK)
1226 goto out;
1227
1228 wait_for_completion(&fcomp.comp);
1229 iocmd->status = fcomp.status;
1230 out:
1231 return 0;
1232 }
1233
1234 static int
1235 bfad_iocmd_pcifn_delete(struct bfad_s *bfad, void *cmd)
1236 {
1237 struct bfa_bsg_pcifn_s *iocmd = (struct bfa_bsg_pcifn_s *)cmd;
1238 struct bfad_hal_comp fcomp;
1239 unsigned long flags;
1240
1241 init_completion(&fcomp.comp);
1242 spin_lock_irqsave(&bfad->bfad_lock, flags);
1243 iocmd->status = bfa_ablk_pf_delete(&bfad->bfa.modules.ablk,
1244 iocmd->pcifn_id,
1245 bfad_hcb_comp, &fcomp);
1246 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1247 if (iocmd->status != BFA_STATUS_OK)
1248 goto out;
1249
1250 wait_for_completion(&fcomp.comp);
1251 iocmd->status = fcomp.status;
1252 out:
1253 return 0;
1254 }
1255
1256 static int
1257 bfad_iocmd_pcifn_bw(struct bfad_s *bfad, void *cmd)
1258 {
1259 struct bfa_bsg_pcifn_s *iocmd = (struct bfa_bsg_pcifn_s *)cmd;
1260 struct bfad_hal_comp fcomp;
1261 unsigned long flags;
1262
1263 init_completion(&fcomp.comp);
1264 spin_lock_irqsave(&bfad->bfad_lock, flags);
1265 iocmd->status = bfa_ablk_pf_update(&bfad->bfa.modules.ablk,
1266 iocmd->pcifn_id, iocmd->bw_min,
1267 iocmd->bw_max, bfad_hcb_comp, &fcomp);
1268 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1269 bfa_trc(bfad, iocmd->status);
1270 if (iocmd->status != BFA_STATUS_OK)
1271 goto out;
1272
1273 wait_for_completion(&fcomp.comp);
1274 iocmd->status = fcomp.status;
1275 bfa_trc(bfad, iocmd->status);
1276 out:
1277 return 0;
1278 }
1279
1280 static int
1281 bfad_iocmd_adapter_cfg_mode(struct bfad_s *bfad, void *cmd)
1282 {
1283 struct bfa_bsg_adapter_cfg_mode_s *iocmd =
1284 (struct bfa_bsg_adapter_cfg_mode_s *)cmd;
1285 struct bfad_hal_comp fcomp;
1286 unsigned long flags = 0;
1287
1288 init_completion(&fcomp.comp);
1289 spin_lock_irqsave(&bfad->bfad_lock, flags);
1290 iocmd->status = bfa_ablk_adapter_config(&bfad->bfa.modules.ablk,
1291 iocmd->cfg.mode, iocmd->cfg.max_pf,
1292 iocmd->cfg.max_vf, bfad_hcb_comp, &fcomp);
1293 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1294 if (iocmd->status != BFA_STATUS_OK)
1295 goto out;
1296
1297 wait_for_completion(&fcomp.comp);
1298 iocmd->status = fcomp.status;
1299 out:
1300 return 0;
1301 }
1302
1303 static int
1304 bfad_iocmd_port_cfg_mode(struct bfad_s *bfad, void *cmd)
1305 {
1306 struct bfa_bsg_port_cfg_mode_s *iocmd =
1307 (struct bfa_bsg_port_cfg_mode_s *)cmd;
1308 struct bfad_hal_comp fcomp;
1309 unsigned long flags = 0;
1310
1311 init_completion(&fcomp.comp);
1312 spin_lock_irqsave(&bfad->bfad_lock, flags);
1313 iocmd->status = bfa_ablk_port_config(&bfad->bfa.modules.ablk,
1314 iocmd->instance, iocmd->cfg.mode,
1315 iocmd->cfg.max_pf, iocmd->cfg.max_vf,
1316 bfad_hcb_comp, &fcomp);
1317 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1318 if (iocmd->status != BFA_STATUS_OK)
1319 goto out;
1320
1321 wait_for_completion(&fcomp.comp);
1322 iocmd->status = fcomp.status;
1323 out:
1324 return 0;
1325 }
1326
1327 static int
1328 bfad_iocmd_ablk_optrom(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
1329 {
1330 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
1331 struct bfad_hal_comp fcomp;
1332 unsigned long flags;
1333
1334 init_completion(&fcomp.comp);
1335 spin_lock_irqsave(&bfad->bfad_lock, flags);
1336 if (cmd == IOCMD_FLASH_ENABLE_OPTROM)
1337 iocmd->status = bfa_ablk_optrom_en(&bfad->bfa.modules.ablk,
1338 bfad_hcb_comp, &fcomp);
1339 else
1340 iocmd->status = bfa_ablk_optrom_dis(&bfad->bfa.modules.ablk,
1341 bfad_hcb_comp, &fcomp);
1342 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1343
1344 if (iocmd->status != BFA_STATUS_OK)
1345 goto out;
1346
1347 wait_for_completion(&fcomp.comp);
1348 iocmd->status = fcomp.status;
1349 out:
1350 return 0;
1351 }
1352
1353 static int
1354 bfad_iocmd_faa_query(struct bfad_s *bfad, void *cmd)
1355 {
1356 struct bfa_bsg_faa_attr_s *iocmd = (struct bfa_bsg_faa_attr_s *)cmd;
1357 struct bfad_hal_comp fcomp;
1358 unsigned long flags;
1359
1360 init_completion(&fcomp.comp);
1361 iocmd->status = BFA_STATUS_OK;
1362 spin_lock_irqsave(&bfad->bfad_lock, flags);
1363 iocmd->status = bfa_faa_query(&bfad->bfa, &iocmd->faa_attr,
1364 bfad_hcb_comp, &fcomp);
1365 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1366
1367 if (iocmd->status != BFA_STATUS_OK)
1368 goto out;
1369
1370 wait_for_completion(&fcomp.comp);
1371 iocmd->status = fcomp.status;
1372 out:
1373 return 0;
1374 }
1375
1376 static int
1377 bfad_iocmd_cee_attr(struct bfad_s *bfad, void *cmd, unsigned int payload_len)
1378 {
1379 struct bfa_bsg_cee_attr_s *iocmd =
1380 (struct bfa_bsg_cee_attr_s *)cmd;
1381 void *iocmd_bufptr;
1382 struct bfad_hal_comp cee_comp;
1383 unsigned long flags;
1384
1385 if (bfad_chk_iocmd_sz(payload_len,
1386 sizeof(struct bfa_bsg_cee_attr_s),
1387 sizeof(struct bfa_cee_attr_s)) != BFA_STATUS_OK) {
1388 iocmd->status = BFA_STATUS_VERSION_FAIL;
1389 return 0;
1390 }
1391
1392 iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_cee_attr_s);
1393
1394 cee_comp.status = 0;
1395 init_completion(&cee_comp.comp);
1396 mutex_lock(&bfad_mutex);
1397 spin_lock_irqsave(&bfad->bfad_lock, flags);
1398 iocmd->status = bfa_cee_get_attr(&bfad->bfa.modules.cee, iocmd_bufptr,
1399 bfad_hcb_comp, &cee_comp);
1400 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1401 if (iocmd->status != BFA_STATUS_OK) {
1402 mutex_unlock(&bfad_mutex);
1403 bfa_trc(bfad, 0x5555);
1404 goto out;
1405 }
1406 wait_for_completion(&cee_comp.comp);
1407 mutex_unlock(&bfad_mutex);
1408 out:
1409 return 0;
1410 }
1411
1412 static int
1413 bfad_iocmd_cee_get_stats(struct bfad_s *bfad, void *cmd,
1414 unsigned int payload_len)
1415 {
1416 struct bfa_bsg_cee_stats_s *iocmd =
1417 (struct bfa_bsg_cee_stats_s *)cmd;
1418 void *iocmd_bufptr;
1419 struct bfad_hal_comp cee_comp;
1420 unsigned long flags;
1421
1422 if (bfad_chk_iocmd_sz(payload_len,
1423 sizeof(struct bfa_bsg_cee_stats_s),
1424 sizeof(struct bfa_cee_stats_s)) != BFA_STATUS_OK) {
1425 iocmd->status = BFA_STATUS_VERSION_FAIL;
1426 return 0;
1427 }
1428
1429 iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_cee_stats_s);
1430
1431 cee_comp.status = 0;
1432 init_completion(&cee_comp.comp);
1433 mutex_lock(&bfad_mutex);
1434 spin_lock_irqsave(&bfad->bfad_lock, flags);
1435 iocmd->status = bfa_cee_get_stats(&bfad->bfa.modules.cee, iocmd_bufptr,
1436 bfad_hcb_comp, &cee_comp);
1437 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1438 if (iocmd->status != BFA_STATUS_OK) {
1439 mutex_unlock(&bfad_mutex);
1440 bfa_trc(bfad, 0x5555);
1441 goto out;
1442 }
1443 wait_for_completion(&cee_comp.comp);
1444 mutex_unlock(&bfad_mutex);
1445 out:
1446 return 0;
1447 }
1448
1449 static int
1450 bfad_iocmd_cee_reset_stats(struct bfad_s *bfad, void *cmd)
1451 {
1452 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
1453 unsigned long flags;
1454
1455 spin_lock_irqsave(&bfad->bfad_lock, flags);
1456 iocmd->status = bfa_cee_reset_stats(&bfad->bfa.modules.cee, NULL, NULL);
1457 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1458 if (iocmd->status != BFA_STATUS_OK)
1459 bfa_trc(bfad, 0x5555);
1460 return 0;
1461 }
1462
1463 static int
1464 bfad_iocmd_sfp_media(struct bfad_s *bfad, void *cmd)
1465 {
1466 struct bfa_bsg_sfp_media_s *iocmd = (struct bfa_bsg_sfp_media_s *)cmd;
1467 struct bfad_hal_comp fcomp;
1468 unsigned long flags;
1469
1470 init_completion(&fcomp.comp);
1471 spin_lock_irqsave(&bfad->bfad_lock, flags);
1472 iocmd->status = bfa_sfp_media(BFA_SFP_MOD(&bfad->bfa), &iocmd->media,
1473 bfad_hcb_comp, &fcomp);
1474 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1475 bfa_trc(bfad, iocmd->status);
1476 if (iocmd->status != BFA_STATUS_SFP_NOT_READY)
1477 goto out;
1478
1479 wait_for_completion(&fcomp.comp);
1480 iocmd->status = fcomp.status;
1481 out:
1482 return 0;
1483 }
1484
1485 static int
1486 bfad_iocmd_sfp_speed(struct bfad_s *bfad, void *cmd)
1487 {
1488 struct bfa_bsg_sfp_speed_s *iocmd = (struct bfa_bsg_sfp_speed_s *)cmd;
1489 struct bfad_hal_comp fcomp;
1490 unsigned long flags;
1491
1492 init_completion(&fcomp.comp);
1493 spin_lock_irqsave(&bfad->bfad_lock, flags);
1494 iocmd->status = bfa_sfp_speed(BFA_SFP_MOD(&bfad->bfa), iocmd->speed,
1495 bfad_hcb_comp, &fcomp);
1496 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1497 bfa_trc(bfad, iocmd->status);
1498 if (iocmd->status != BFA_STATUS_SFP_NOT_READY)
1499 goto out;
1500 wait_for_completion(&fcomp.comp);
1501 iocmd->status = fcomp.status;
1502 out:
1503 return 0;
1504 }
1505
1506 static int
1507 bfad_iocmd_flash_get_attr(struct bfad_s *bfad, void *cmd)
1508 {
1509 struct bfa_bsg_flash_attr_s *iocmd =
1510 (struct bfa_bsg_flash_attr_s *)cmd;
1511 struct bfad_hal_comp fcomp;
1512 unsigned long flags;
1513
1514 init_completion(&fcomp.comp);
1515 spin_lock_irqsave(&bfad->bfad_lock, flags);
1516 iocmd->status = bfa_flash_get_attr(BFA_FLASH(&bfad->bfa), &iocmd->attr,
1517 bfad_hcb_comp, &fcomp);
1518 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1519 if (iocmd->status != BFA_STATUS_OK)
1520 goto out;
1521 wait_for_completion(&fcomp.comp);
1522 iocmd->status = fcomp.status;
1523 out:
1524 return 0;
1525 }
1526
1527 static int
1528 bfad_iocmd_flash_erase_part(struct bfad_s *bfad, void *cmd)
1529 {
1530 struct bfa_bsg_flash_s *iocmd = (struct bfa_bsg_flash_s *)cmd;
1531 struct bfad_hal_comp fcomp;
1532 unsigned long flags;
1533
1534 init_completion(&fcomp.comp);
1535 spin_lock_irqsave(&bfad->bfad_lock, flags);
1536 iocmd->status = bfa_flash_erase_part(BFA_FLASH(&bfad->bfa), iocmd->type,
1537 iocmd->instance, bfad_hcb_comp, &fcomp);
1538 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1539 if (iocmd->status != BFA_STATUS_OK)
1540 goto out;
1541 wait_for_completion(&fcomp.comp);
1542 iocmd->status = fcomp.status;
1543 out:
1544 return 0;
1545 }
1546
1547 static int
1548 bfad_iocmd_flash_update_part(struct bfad_s *bfad, void *cmd,
1549 unsigned int payload_len)
1550 {
1551 struct bfa_bsg_flash_s *iocmd = (struct bfa_bsg_flash_s *)cmd;
1552 void *iocmd_bufptr;
1553 struct bfad_hal_comp fcomp;
1554 unsigned long flags;
1555
1556 if (bfad_chk_iocmd_sz(payload_len,
1557 sizeof(struct bfa_bsg_flash_s),
1558 iocmd->bufsz) != BFA_STATUS_OK) {
1559 iocmd->status = BFA_STATUS_VERSION_FAIL;
1560 return 0;
1561 }
1562
1563 iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_flash_s);
1564
1565 init_completion(&fcomp.comp);
1566 spin_lock_irqsave(&bfad->bfad_lock, flags);
1567 iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
1568 iocmd->type, iocmd->instance, iocmd_bufptr,
1569 iocmd->bufsz, 0, bfad_hcb_comp, &fcomp);
1570 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1571 if (iocmd->status != BFA_STATUS_OK)
1572 goto out;
1573 wait_for_completion(&fcomp.comp);
1574 iocmd->status = fcomp.status;
1575 out:
1576 return 0;
1577 }
1578
1579 static int
1580 bfad_iocmd_flash_read_part(struct bfad_s *bfad, void *cmd,
1581 unsigned int payload_len)
1582 {
1583 struct bfa_bsg_flash_s *iocmd = (struct bfa_bsg_flash_s *)cmd;
1584 struct bfad_hal_comp fcomp;
1585 void *iocmd_bufptr;
1586 unsigned long flags;
1587
1588 if (bfad_chk_iocmd_sz(payload_len,
1589 sizeof(struct bfa_bsg_flash_s),
1590 iocmd->bufsz) != BFA_STATUS_OK) {
1591 iocmd->status = BFA_STATUS_VERSION_FAIL;
1592 return 0;
1593 }
1594
1595 iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_flash_s);
1596
1597 init_completion(&fcomp.comp);
1598 spin_lock_irqsave(&bfad->bfad_lock, flags);
1599 iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa), iocmd->type,
1600 iocmd->instance, iocmd_bufptr, iocmd->bufsz, 0,
1601 bfad_hcb_comp, &fcomp);
1602 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1603 if (iocmd->status != BFA_STATUS_OK)
1604 goto out;
1605 wait_for_completion(&fcomp.comp);
1606 iocmd->status = fcomp.status;
1607 out:
1608 return 0;
1609 }
1610
1611 static int
1612 bfad_iocmd_diag_temp(struct bfad_s *bfad, void *cmd)
1613 {
1614 struct bfa_bsg_diag_get_temp_s *iocmd =
1615 (struct bfa_bsg_diag_get_temp_s *)cmd;
1616 struct bfad_hal_comp fcomp;
1617 unsigned long flags;
1618
1619 init_completion(&fcomp.comp);
1620 spin_lock_irqsave(&bfad->bfad_lock, flags);
1621 iocmd->status = bfa_diag_tsensor_query(BFA_DIAG_MOD(&bfad->bfa),
1622 &iocmd->result, bfad_hcb_comp, &fcomp);
1623 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1624 bfa_trc(bfad, iocmd->status);
1625 if (iocmd->status != BFA_STATUS_OK)
1626 goto out;
1627 wait_for_completion(&fcomp.comp);
1628 iocmd->status = fcomp.status;
1629 out:
1630 return 0;
1631 }
1632
1633 static int
1634 bfad_iocmd_diag_memtest(struct bfad_s *bfad, void *cmd)
1635 {
1636 struct bfa_bsg_diag_memtest_s *iocmd =
1637 (struct bfa_bsg_diag_memtest_s *)cmd;
1638 struct bfad_hal_comp fcomp;
1639 unsigned long flags;
1640
1641 init_completion(&fcomp.comp);
1642 spin_lock_irqsave(&bfad->bfad_lock, flags);
1643 iocmd->status = bfa_diag_memtest(BFA_DIAG_MOD(&bfad->bfa),
1644 &iocmd->memtest, iocmd->pat,
1645 &iocmd->result, bfad_hcb_comp, &fcomp);
1646 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1647 bfa_trc(bfad, iocmd->status);
1648 if (iocmd->status != BFA_STATUS_OK)
1649 goto out;
1650 wait_for_completion(&fcomp.comp);
1651 iocmd->status = fcomp.status;
1652 out:
1653 return 0;
1654 }
1655
1656 static int
1657 bfad_iocmd_diag_loopback(struct bfad_s *bfad, void *cmd)
1658 {
1659 struct bfa_bsg_diag_loopback_s *iocmd =
1660 (struct bfa_bsg_diag_loopback_s *)cmd;
1661 struct bfad_hal_comp fcomp;
1662 unsigned long flags;
1663
1664 init_completion(&fcomp.comp);
1665 spin_lock_irqsave(&bfad->bfad_lock, flags);
1666 iocmd->status = bfa_fcdiag_loopback(&bfad->bfa, iocmd->opmode,
1667 iocmd->speed, iocmd->lpcnt, iocmd->pat,
1668 &iocmd->result, bfad_hcb_comp, &fcomp);
1669 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1670 bfa_trc(bfad, iocmd->status);
1671 if (iocmd->status != BFA_STATUS_OK)
1672 goto out;
1673 wait_for_completion(&fcomp.comp);
1674 iocmd->status = fcomp.status;
1675 out:
1676 return 0;
1677 }
1678
1679 static int
1680 bfad_iocmd_diag_fwping(struct bfad_s *bfad, void *cmd)
1681 {
1682 struct bfa_bsg_diag_fwping_s *iocmd =
1683 (struct bfa_bsg_diag_fwping_s *)cmd;
1684 struct bfad_hal_comp fcomp;
1685 unsigned long flags;
1686
1687 init_completion(&fcomp.comp);
1688 spin_lock_irqsave(&bfad->bfad_lock, flags);
1689 iocmd->status = bfa_diag_fwping(BFA_DIAG_MOD(&bfad->bfa), iocmd->cnt,
1690 iocmd->pattern, &iocmd->result,
1691 bfad_hcb_comp, &fcomp);
1692 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1693 bfa_trc(bfad, iocmd->status);
1694 if (iocmd->status != BFA_STATUS_OK)
1695 goto out;
1696 bfa_trc(bfad, 0x77771);
1697 wait_for_completion(&fcomp.comp);
1698 iocmd->status = fcomp.status;
1699 out:
1700 return 0;
1701 }
1702
1703 static int
1704 bfad_iocmd_diag_queuetest(struct bfad_s *bfad, void *cmd)
1705 {
1706 struct bfa_bsg_diag_qtest_s *iocmd = (struct bfa_bsg_diag_qtest_s *)cmd;
1707 struct bfad_hal_comp fcomp;
1708 unsigned long flags;
1709
1710 init_completion(&fcomp.comp);
1711 spin_lock_irqsave(&bfad->bfad_lock, flags);
1712 iocmd->status = bfa_fcdiag_queuetest(&bfad->bfa, iocmd->force,
1713 iocmd->queue, &iocmd->result,
1714 bfad_hcb_comp, &fcomp);
1715 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1716 if (iocmd->status != BFA_STATUS_OK)
1717 goto out;
1718 wait_for_completion(&fcomp.comp);
1719 iocmd->status = fcomp.status;
1720 out:
1721 return 0;
1722 }
1723
1724 static int
1725 bfad_iocmd_diag_sfp(struct bfad_s *bfad, void *cmd)
1726 {
1727 struct bfa_bsg_sfp_show_s *iocmd =
1728 (struct bfa_bsg_sfp_show_s *)cmd;
1729 struct bfad_hal_comp fcomp;
1730 unsigned long flags;
1731
1732 init_completion(&fcomp.comp);
1733 spin_lock_irqsave(&bfad->bfad_lock, flags);
1734 iocmd->status = bfa_sfp_show(BFA_SFP_MOD(&bfad->bfa), &iocmd->sfp,
1735 bfad_hcb_comp, &fcomp);
1736 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1737 bfa_trc(bfad, iocmd->status);
1738 if (iocmd->status != BFA_STATUS_OK)
1739 goto out;
1740 wait_for_completion(&fcomp.comp);
1741 iocmd->status = fcomp.status;
1742 bfa_trc(bfad, iocmd->status);
1743 out:
1744 return 0;
1745 }
1746
1747 static int
1748 bfad_iocmd_diag_led(struct bfad_s *bfad, void *cmd)
1749 {
1750 struct bfa_bsg_diag_led_s *iocmd = (struct bfa_bsg_diag_led_s *)cmd;
1751 unsigned long flags;
1752
1753 spin_lock_irqsave(&bfad->bfad_lock, flags);
1754 iocmd->status = bfa_diag_ledtest(BFA_DIAG_MOD(&bfad->bfa),
1755 &iocmd->ledtest);
1756 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1757 return 0;
1758 }
1759
1760 static int
1761 bfad_iocmd_diag_beacon_lport(struct bfad_s *bfad, void *cmd)
1762 {
1763 struct bfa_bsg_diag_beacon_s *iocmd =
1764 (struct bfa_bsg_diag_beacon_s *)cmd;
1765 unsigned long flags;
1766
1767 spin_lock_irqsave(&bfad->bfad_lock, flags);
1768 iocmd->status = bfa_diag_beacon_port(BFA_DIAG_MOD(&bfad->bfa),
1769 iocmd->beacon, iocmd->link_e2e_beacon,
1770 iocmd->second);
1771 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1772 return 0;
1773 }
1774
1775 static int
1776 bfad_iocmd_diag_lb_stat(struct bfad_s *bfad, void *cmd)
1777 {
1778 struct bfa_bsg_diag_lb_stat_s *iocmd =
1779 (struct bfa_bsg_diag_lb_stat_s *)cmd;
1780 unsigned long flags;
1781
1782 spin_lock_irqsave(&bfad->bfad_lock, flags);
1783 iocmd->status = bfa_fcdiag_lb_is_running(&bfad->bfa);
1784 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1785 bfa_trc(bfad, iocmd->status);
1786
1787 return 0;
1788 }
1789
1790 static int
1791 bfad_iocmd_diag_dport_enable(struct bfad_s *bfad, void *pcmd)
1792 {
1793 struct bfa_bsg_dport_enable_s *iocmd =
1794 (struct bfa_bsg_dport_enable_s *)pcmd;
1795 unsigned long flags;
1796 struct bfad_hal_comp fcomp;
1797
1798 init_completion(&fcomp.comp);
1799 spin_lock_irqsave(&bfad->bfad_lock, flags);
1800 iocmd->status = bfa_dport_enable(&bfad->bfa, iocmd->lpcnt,
1801 iocmd->pat, bfad_hcb_comp, &fcomp);
1802 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1803 if (iocmd->status != BFA_STATUS_OK)
1804 bfa_trc(bfad, iocmd->status);
1805 else {
1806 wait_for_completion(&fcomp.comp);
1807 iocmd->status = fcomp.status;
1808 }
1809 return 0;
1810 }
1811
1812 static int
1813 bfad_iocmd_diag_dport_disable(struct bfad_s *bfad, void *pcmd)
1814 {
1815 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
1816 unsigned long flags;
1817 struct bfad_hal_comp fcomp;
1818
1819 init_completion(&fcomp.comp);
1820 spin_lock_irqsave(&bfad->bfad_lock, flags);
1821 iocmd->status = bfa_dport_disable(&bfad->bfa, bfad_hcb_comp, &fcomp);
1822 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1823 if (iocmd->status != BFA_STATUS_OK)
1824 bfa_trc(bfad, iocmd->status);
1825 else {
1826 wait_for_completion(&fcomp.comp);
1827 iocmd->status = fcomp.status;
1828 }
1829 return 0;
1830 }
1831
1832 static int
1833 bfad_iocmd_diag_dport_start(struct bfad_s *bfad, void *pcmd)
1834 {
1835 struct bfa_bsg_dport_enable_s *iocmd =
1836 (struct bfa_bsg_dport_enable_s *)pcmd;
1837 unsigned long flags;
1838 struct bfad_hal_comp fcomp;
1839
1840 init_completion(&fcomp.comp);
1841 spin_lock_irqsave(&bfad->bfad_lock, flags);
1842 iocmd->status = bfa_dport_start(&bfad->bfa, iocmd->lpcnt,
1843 iocmd->pat, bfad_hcb_comp,
1844 &fcomp);
1845 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1846
1847 if (iocmd->status != BFA_STATUS_OK) {
1848 bfa_trc(bfad, iocmd->status);
1849 } else {
1850 wait_for_completion(&fcomp.comp);
1851 iocmd->status = fcomp.status;
1852 }
1853
1854 return 0;
1855 }
1856
1857 static int
1858 bfad_iocmd_diag_dport_show(struct bfad_s *bfad, void *pcmd)
1859 {
1860 struct bfa_bsg_diag_dport_show_s *iocmd =
1861 (struct bfa_bsg_diag_dport_show_s *)pcmd;
1862 unsigned long flags;
1863
1864 spin_lock_irqsave(&bfad->bfad_lock, flags);
1865 iocmd->status = bfa_dport_show(&bfad->bfa, &iocmd->result);
1866 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1867
1868 return 0;
1869 }
1870
1871
1872 static int
1873 bfad_iocmd_phy_get_attr(struct bfad_s *bfad, void *cmd)
1874 {
1875 struct bfa_bsg_phy_attr_s *iocmd =
1876 (struct bfa_bsg_phy_attr_s *)cmd;
1877 struct bfad_hal_comp fcomp;
1878 unsigned long flags;
1879
1880 init_completion(&fcomp.comp);
1881 spin_lock_irqsave(&bfad->bfad_lock, flags);
1882 iocmd->status = bfa_phy_get_attr(BFA_PHY(&bfad->bfa), iocmd->instance,
1883 &iocmd->attr, bfad_hcb_comp, &fcomp);
1884 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1885 if (iocmd->status != BFA_STATUS_OK)
1886 goto out;
1887 wait_for_completion(&fcomp.comp);
1888 iocmd->status = fcomp.status;
1889 out:
1890 return 0;
1891 }
1892
1893 static int
1894 bfad_iocmd_phy_get_stats(struct bfad_s *bfad, void *cmd)
1895 {
1896 struct bfa_bsg_phy_stats_s *iocmd =
1897 (struct bfa_bsg_phy_stats_s *)cmd;
1898 struct bfad_hal_comp fcomp;
1899 unsigned long flags;
1900
1901 init_completion(&fcomp.comp);
1902 spin_lock_irqsave(&bfad->bfad_lock, flags);
1903 iocmd->status = bfa_phy_get_stats(BFA_PHY(&bfad->bfa), iocmd->instance,
1904 &iocmd->stats, bfad_hcb_comp, &fcomp);
1905 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1906 if (iocmd->status != BFA_STATUS_OK)
1907 goto out;
1908 wait_for_completion(&fcomp.comp);
1909 iocmd->status = fcomp.status;
1910 out:
1911 return 0;
1912 }
1913
1914 static int
1915 bfad_iocmd_phy_read(struct bfad_s *bfad, void *cmd, unsigned int payload_len)
1916 {
1917 struct bfa_bsg_phy_s *iocmd = (struct bfa_bsg_phy_s *)cmd;
1918 struct bfad_hal_comp fcomp;
1919 void *iocmd_bufptr;
1920 unsigned long flags;
1921
1922 if (bfad_chk_iocmd_sz(payload_len,
1923 sizeof(struct bfa_bsg_phy_s),
1924 iocmd->bufsz) != BFA_STATUS_OK) {
1925 iocmd->status = BFA_STATUS_VERSION_FAIL;
1926 return 0;
1927 }
1928
1929 iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_phy_s);
1930 init_completion(&fcomp.comp);
1931 spin_lock_irqsave(&bfad->bfad_lock, flags);
1932 iocmd->status = bfa_phy_read(BFA_PHY(&bfad->bfa),
1933 iocmd->instance, iocmd_bufptr, iocmd->bufsz,
1934 0, bfad_hcb_comp, &fcomp);
1935 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1936 if (iocmd->status != BFA_STATUS_OK)
1937 goto out;
1938 wait_for_completion(&fcomp.comp);
1939 iocmd->status = fcomp.status;
1940 if (iocmd->status != BFA_STATUS_OK)
1941 goto out;
1942 out:
1943 return 0;
1944 }
1945
1946 static int
1947 bfad_iocmd_vhba_query(struct bfad_s *bfad, void *cmd)
1948 {
1949 struct bfa_bsg_vhba_attr_s *iocmd =
1950 (struct bfa_bsg_vhba_attr_s *)cmd;
1951 struct bfa_vhba_attr_s *attr = &iocmd->attr;
1952 unsigned long flags;
1953
1954 spin_lock_irqsave(&bfad->bfad_lock, flags);
1955 attr->pwwn = bfad->bfa.ioc.attr->pwwn;
1956 attr->nwwn = bfad->bfa.ioc.attr->nwwn;
1957 attr->plog_enabled = (bfa_boolean_t)bfad->bfa.plog->plog_enabled;
1958 attr->io_profile = bfa_fcpim_get_io_profile(&bfad->bfa);
1959 attr->path_tov = bfa_fcpim_path_tov_get(&bfad->bfa);
1960 iocmd->status = BFA_STATUS_OK;
1961 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1962 return 0;
1963 }
1964
1965 static int
1966 bfad_iocmd_phy_update(struct bfad_s *bfad, void *cmd, unsigned int payload_len)
1967 {
1968 struct bfa_bsg_phy_s *iocmd = (struct bfa_bsg_phy_s *)cmd;
1969 void *iocmd_bufptr;
1970 struct bfad_hal_comp fcomp;
1971 unsigned long flags;
1972
1973 if (bfad_chk_iocmd_sz(payload_len,
1974 sizeof(struct bfa_bsg_phy_s),
1975 iocmd->bufsz) != BFA_STATUS_OK) {
1976 iocmd->status = BFA_STATUS_VERSION_FAIL;
1977 return 0;
1978 }
1979
1980 iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_phy_s);
1981 init_completion(&fcomp.comp);
1982 spin_lock_irqsave(&bfad->bfad_lock, flags);
1983 iocmd->status = bfa_phy_update(BFA_PHY(&bfad->bfa),
1984 iocmd->instance, iocmd_bufptr, iocmd->bufsz,
1985 0, bfad_hcb_comp, &fcomp);
1986 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1987 if (iocmd->status != BFA_STATUS_OK)
1988 goto out;
1989 wait_for_completion(&fcomp.comp);
1990 iocmd->status = fcomp.status;
1991 out:
1992 return 0;
1993 }
1994
1995 static int
1996 bfad_iocmd_porglog_get(struct bfad_s *bfad, void *cmd)
1997 {
1998 struct bfa_bsg_debug_s *iocmd = (struct bfa_bsg_debug_s *)cmd;
1999 void *iocmd_bufptr;
2000
2001 if (iocmd->bufsz < sizeof(struct bfa_plog_s)) {
2002 bfa_trc(bfad, sizeof(struct bfa_plog_s));
2003 iocmd->status = BFA_STATUS_EINVAL;
2004 goto out;
2005 }
2006
2007 iocmd->status = BFA_STATUS_OK;
2008 iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_debug_s);
2009 memcpy(iocmd_bufptr, (u8 *) &bfad->plog_buf, sizeof(struct bfa_plog_s));
2010 out:
2011 return 0;
2012 }
2013
2014 #define BFA_DEBUG_FW_CORE_CHUNK_SZ 0x4000U /* 16K chunks for FW dump */
2015 static int
2016 bfad_iocmd_debug_fw_core(struct bfad_s *bfad, void *cmd,
2017 unsigned int payload_len)
2018 {
2019 struct bfa_bsg_debug_s *iocmd = (struct bfa_bsg_debug_s *)cmd;
2020 void *iocmd_bufptr;
2021 unsigned long flags;
2022 u32 offset;
2023
2024 if (bfad_chk_iocmd_sz(payload_len, sizeof(struct bfa_bsg_debug_s),
2025 BFA_DEBUG_FW_CORE_CHUNK_SZ) != BFA_STATUS_OK) {
2026 iocmd->status = BFA_STATUS_VERSION_FAIL;
2027 return 0;
2028 }
2029
2030 if (iocmd->bufsz < BFA_DEBUG_FW_CORE_CHUNK_SZ ||
2031 !IS_ALIGNED(iocmd->bufsz, sizeof(u16)) ||
2032 !IS_ALIGNED(iocmd->offset, sizeof(u32))) {
2033 bfa_trc(bfad, BFA_DEBUG_FW_CORE_CHUNK_SZ);
2034 iocmd->status = BFA_STATUS_EINVAL;
2035 goto out;
2036 }
2037
2038 iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_debug_s);
2039 spin_lock_irqsave(&bfad->bfad_lock, flags);
2040 offset = iocmd->offset;
2041 iocmd->status = bfa_ioc_debug_fwcore(&bfad->bfa.ioc, iocmd_bufptr,
2042 &offset, &iocmd->bufsz);
2043 iocmd->offset = offset;
2044 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2045 out:
2046 return 0;
2047 }
2048
2049 static int
2050 bfad_iocmd_debug_ctl(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2051 {
2052 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2053 unsigned long flags;
2054
2055 if (v_cmd == IOCMD_DEBUG_FW_STATE_CLR) {
2056 spin_lock_irqsave(&bfad->bfad_lock, flags);
2057 bfad->bfa.ioc.dbg_fwsave_once = BFA_TRUE;
2058 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2059 } else if (v_cmd == IOCMD_DEBUG_PORTLOG_CLR)
2060 bfad->plog_buf.head = bfad->plog_buf.tail = 0;
2061 else if (v_cmd == IOCMD_DEBUG_START_DTRC)
2062 bfa_trc_init(bfad->trcmod);
2063 else if (v_cmd == IOCMD_DEBUG_STOP_DTRC)
2064 bfa_trc_stop(bfad->trcmod);
2065
2066 iocmd->status = BFA_STATUS_OK;
2067 return 0;
2068 }
2069
2070 static int
2071 bfad_iocmd_porglog_ctl(struct bfad_s *bfad, void *cmd)
2072 {
2073 struct bfa_bsg_portlogctl_s *iocmd = (struct bfa_bsg_portlogctl_s *)cmd;
2074
2075 if (iocmd->ctl == BFA_TRUE)
2076 bfad->plog_buf.plog_enabled = 1;
2077 else
2078 bfad->plog_buf.plog_enabled = 0;
2079
2080 iocmd->status = BFA_STATUS_OK;
2081 return 0;
2082 }
2083
2084 static int
2085 bfad_iocmd_fcpim_cfg_profile(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2086 {
2087 struct bfa_bsg_fcpim_profile_s *iocmd =
2088 (struct bfa_bsg_fcpim_profile_s *)cmd;
2089 unsigned long flags;
2090
2091 spin_lock_irqsave(&bfad->bfad_lock, flags);
2092 if (v_cmd == IOCMD_FCPIM_PROFILE_ON)
2093 iocmd->status = bfa_fcpim_profile_on(&bfad->bfa, ktime_get_real_seconds());
2094 else if (v_cmd == IOCMD_FCPIM_PROFILE_OFF)
2095 iocmd->status = bfa_fcpim_profile_off(&bfad->bfa);
2096 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2097
2098 return 0;
2099 }
2100
2101 static int
2102 bfad_iocmd_itnim_get_ioprofile(struct bfad_s *bfad, void *cmd)
2103 {
2104 struct bfa_bsg_itnim_ioprofile_s *iocmd =
2105 (struct bfa_bsg_itnim_ioprofile_s *)cmd;
2106 struct bfa_fcs_lport_s *fcs_port;
2107 struct bfa_fcs_itnim_s *itnim;
2108 unsigned long flags;
2109
2110 spin_lock_irqsave(&bfad->bfad_lock, flags);
2111 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
2112 iocmd->vf_id, iocmd->lpwwn);
2113 if (!fcs_port)
2114 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
2115 else {
2116 itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
2117 if (itnim == NULL)
2118 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
2119 else
2120 iocmd->status = bfa_itnim_get_ioprofile(
2121 bfa_fcs_itnim_get_halitn(itnim),
2122 &iocmd->ioprofile);
2123 }
2124 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2125 return 0;
2126 }
2127
2128 static int
2129 bfad_iocmd_fcport_get_stats(struct bfad_s *bfad, void *cmd)
2130 {
2131 struct bfa_bsg_fcport_stats_s *iocmd =
2132 (struct bfa_bsg_fcport_stats_s *)cmd;
2133 struct bfad_hal_comp fcomp;
2134 unsigned long flags;
2135 struct bfa_cb_pending_q_s cb_qe;
2136
2137 init_completion(&fcomp.comp);
2138 bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp,
2139 &fcomp, &iocmd->stats);
2140 spin_lock_irqsave(&bfad->bfad_lock, flags);
2141 iocmd->status = bfa_fcport_get_stats(&bfad->bfa, &cb_qe);
2142 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2143 if (iocmd->status != BFA_STATUS_OK) {
2144 bfa_trc(bfad, iocmd->status);
2145 goto out;
2146 }
2147 wait_for_completion(&fcomp.comp);
2148 iocmd->status = fcomp.status;
2149 out:
2150 return 0;
2151 }
2152
2153 static int
2154 bfad_iocmd_fcport_reset_stats(struct bfad_s *bfad, void *cmd)
2155 {
2156 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2157 struct bfad_hal_comp fcomp;
2158 unsigned long flags;
2159 struct bfa_cb_pending_q_s cb_qe;
2160
2161 init_completion(&fcomp.comp);
2162 bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp, &fcomp, NULL);
2163
2164 spin_lock_irqsave(&bfad->bfad_lock, flags);
2165 iocmd->status = bfa_fcport_clear_stats(&bfad->bfa, &cb_qe);
2166 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2167 if (iocmd->status != BFA_STATUS_OK) {
2168 bfa_trc(bfad, iocmd->status);
2169 goto out;
2170 }
2171 wait_for_completion(&fcomp.comp);
2172 iocmd->status = fcomp.status;
2173 out:
2174 return 0;
2175 }
2176
2177 static int
2178 bfad_iocmd_boot_cfg(struct bfad_s *bfad, void *cmd)
2179 {
2180 struct bfa_bsg_boot_s *iocmd = (struct bfa_bsg_boot_s *)cmd;
2181 struct bfad_hal_comp fcomp;
2182 unsigned long flags;
2183
2184 init_completion(&fcomp.comp);
2185 spin_lock_irqsave(&bfad->bfad_lock, flags);
2186 iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
2187 BFA_FLASH_PART_BOOT, bfad->bfa.ioc.port_id,
2188 &iocmd->cfg, sizeof(struct bfa_boot_cfg_s), 0,
2189 bfad_hcb_comp, &fcomp);
2190 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2191 if (iocmd->status != BFA_STATUS_OK)
2192 goto out;
2193 wait_for_completion(&fcomp.comp);
2194 iocmd->status = fcomp.status;
2195 out:
2196 return 0;
2197 }
2198
2199 static int
2200 bfad_iocmd_boot_query(struct bfad_s *bfad, void *cmd)
2201 {
2202 struct bfa_bsg_boot_s *iocmd = (struct bfa_bsg_boot_s *)cmd;
2203 struct bfad_hal_comp fcomp;
2204 unsigned long flags;
2205
2206 init_completion(&fcomp.comp);
2207 spin_lock_irqsave(&bfad->bfad_lock, flags);
2208 iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa),
2209 BFA_FLASH_PART_BOOT, bfad->bfa.ioc.port_id,
2210 &iocmd->cfg, sizeof(struct bfa_boot_cfg_s), 0,
2211 bfad_hcb_comp, &fcomp);
2212 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2213 if (iocmd->status != BFA_STATUS_OK)
2214 goto out;
2215 wait_for_completion(&fcomp.comp);
2216 iocmd->status = fcomp.status;
2217 out:
2218 return 0;
2219 }
2220
2221 static int
2222 bfad_iocmd_preboot_query(struct bfad_s *bfad, void *cmd)
2223 {
2224 struct bfa_bsg_preboot_s *iocmd = (struct bfa_bsg_preboot_s *)cmd;
2225 struct bfi_iocfc_cfgrsp_s *cfgrsp = bfad->bfa.iocfc.cfgrsp;
2226 struct bfa_boot_pbc_s *pbcfg = &iocmd->cfg;
2227 unsigned long flags;
2228
2229 spin_lock_irqsave(&bfad->bfad_lock, flags);
2230 pbcfg->enable = cfgrsp->pbc_cfg.boot_enabled;
2231 pbcfg->nbluns = cfgrsp->pbc_cfg.nbluns;
2232 pbcfg->speed = cfgrsp->pbc_cfg.port_speed;
2233 memcpy(pbcfg->pblun, cfgrsp->pbc_cfg.blun, sizeof(pbcfg->pblun));
2234 iocmd->status = BFA_STATUS_OK;
2235 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2236
2237 return 0;
2238 }
2239
2240 static int
2241 bfad_iocmd_ethboot_cfg(struct bfad_s *bfad, void *cmd)
2242 {
2243 struct bfa_bsg_ethboot_s *iocmd = (struct bfa_bsg_ethboot_s *)cmd;
2244 struct bfad_hal_comp fcomp;
2245 unsigned long flags;
2246
2247 init_completion(&fcomp.comp);
2248 spin_lock_irqsave(&bfad->bfad_lock, flags);
2249 iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
2250 BFA_FLASH_PART_PXECFG,
2251 bfad->bfa.ioc.port_id, &iocmd->cfg,
2252 sizeof(struct bfa_ethboot_cfg_s), 0,
2253 bfad_hcb_comp, &fcomp);
2254 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2255 if (iocmd->status != BFA_STATUS_OK)
2256 goto out;
2257 wait_for_completion(&fcomp.comp);
2258 iocmd->status = fcomp.status;
2259 out:
2260 return 0;
2261 }
2262
2263 static int
2264 bfad_iocmd_ethboot_query(struct bfad_s *bfad, void *cmd)
2265 {
2266 struct bfa_bsg_ethboot_s *iocmd = (struct bfa_bsg_ethboot_s *)cmd;
2267 struct bfad_hal_comp fcomp;
2268 unsigned long flags;
2269
2270 init_completion(&fcomp.comp);
2271 spin_lock_irqsave(&bfad->bfad_lock, flags);
2272 iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa),
2273 BFA_FLASH_PART_PXECFG,
2274 bfad->bfa.ioc.port_id, &iocmd->cfg,
2275 sizeof(struct bfa_ethboot_cfg_s), 0,
2276 bfad_hcb_comp, &fcomp);
2277 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2278 if (iocmd->status != BFA_STATUS_OK)
2279 goto out;
2280 wait_for_completion(&fcomp.comp);
2281 iocmd->status = fcomp.status;
2282 out:
2283 return 0;
2284 }
2285
2286 static int
2287 bfad_iocmd_cfg_trunk(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2288 {
2289 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2290 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2291 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
2292 unsigned long flags;
2293
2294 spin_lock_irqsave(&bfad->bfad_lock, flags);
2295
2296 if (bfa_fcport_is_dport(&bfad->bfa)) {
2297 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2298 return BFA_STATUS_DPORT_ERR;
2299 }
2300
2301 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) ||
2302 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2303 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2304 else {
2305 if (v_cmd == IOCMD_TRUNK_ENABLE) {
2306 trunk->attr.state = BFA_TRUNK_OFFLINE;
2307 bfa_fcport_disable(&bfad->bfa);
2308 fcport->cfg.trunked = BFA_TRUE;
2309 } else if (v_cmd == IOCMD_TRUNK_DISABLE) {
2310 trunk->attr.state = BFA_TRUNK_DISABLED;
2311 bfa_fcport_disable(&bfad->bfa);
2312 fcport->cfg.trunked = BFA_FALSE;
2313 }
2314
2315 if (!bfa_fcport_is_disabled(&bfad->bfa))
2316 bfa_fcport_enable(&bfad->bfa);
2317
2318 iocmd->status = BFA_STATUS_OK;
2319 }
2320
2321 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2322
2323 return 0;
2324 }
2325
2326 static int
2327 bfad_iocmd_trunk_get_attr(struct bfad_s *bfad, void *cmd)
2328 {
2329 struct bfa_bsg_trunk_attr_s *iocmd = (struct bfa_bsg_trunk_attr_s *)cmd;
2330 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2331 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
2332 unsigned long flags;
2333
2334 spin_lock_irqsave(&bfad->bfad_lock, flags);
2335 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) ||
2336 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2337 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2338 else {
2339 memcpy((void *)&iocmd->attr, (void *)&trunk->attr,
2340 sizeof(struct bfa_trunk_attr_s));
2341 iocmd->attr.port_id = bfa_lps_get_base_pid(&bfad->bfa);
2342 iocmd->status = BFA_STATUS_OK;
2343 }
2344 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2345
2346 return 0;
2347 }
2348
2349 static int
2350 bfad_iocmd_qos(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2351 {
2352 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2353 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2354 unsigned long flags;
2355
2356 spin_lock_irqsave(&bfad->bfad_lock, flags);
2357 if (bfa_ioc_get_type(&bfad->bfa.ioc) == BFA_IOC_TYPE_FC) {
2358 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2359 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2360 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2361 else {
2362 if (v_cmd == IOCMD_QOS_ENABLE)
2363 fcport->cfg.qos_enabled = BFA_TRUE;
2364 else if (v_cmd == IOCMD_QOS_DISABLE) {
2365 fcport->cfg.qos_enabled = BFA_FALSE;
2366 fcport->cfg.qos_bw.high = BFA_QOS_BW_HIGH;
2367 fcport->cfg.qos_bw.med = BFA_QOS_BW_MED;
2368 fcport->cfg.qos_bw.low = BFA_QOS_BW_LOW;
2369 }
2370 }
2371 }
2372 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2373
2374 return 0;
2375 }
2376
2377 static int
2378 bfad_iocmd_qos_get_attr(struct bfad_s *bfad, void *cmd)
2379 {
2380 struct bfa_bsg_qos_attr_s *iocmd = (struct bfa_bsg_qos_attr_s *)cmd;
2381 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2382 unsigned long flags;
2383
2384 spin_lock_irqsave(&bfad->bfad_lock, flags);
2385 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2386 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2387 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2388 else {
2389 iocmd->attr.state = fcport->qos_attr.state;
2390 iocmd->attr.total_bb_cr =
2391 be32_to_cpu(fcport->qos_attr.total_bb_cr);
2392 iocmd->attr.qos_bw.high = fcport->cfg.qos_bw.high;
2393 iocmd->attr.qos_bw.med = fcport->cfg.qos_bw.med;
2394 iocmd->attr.qos_bw.low = fcport->cfg.qos_bw.low;
2395 iocmd->attr.qos_bw_op = fcport->qos_attr.qos_bw_op;
2396 iocmd->status = BFA_STATUS_OK;
2397 }
2398 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2399
2400 return 0;
2401 }
2402
2403 static int
2404 bfad_iocmd_qos_get_vc_attr(struct bfad_s *bfad, void *cmd)
2405 {
2406 struct bfa_bsg_qos_vc_attr_s *iocmd =
2407 (struct bfa_bsg_qos_vc_attr_s *)cmd;
2408 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2409 struct bfa_qos_vc_attr_s *bfa_vc_attr = &fcport->qos_vc_attr;
2410 unsigned long flags;
2411 u32 i = 0;
2412
2413 spin_lock_irqsave(&bfad->bfad_lock, flags);
2414 iocmd->attr.total_vc_count = be16_to_cpu(bfa_vc_attr->total_vc_count);
2415 iocmd->attr.shared_credit = be16_to_cpu(bfa_vc_attr->shared_credit);
2416 iocmd->attr.elp_opmode_flags =
2417 be32_to_cpu(bfa_vc_attr->elp_opmode_flags);
2418
2419 /* Individual VC info */
2420 while (i < iocmd->attr.total_vc_count) {
2421 iocmd->attr.vc_info[i].vc_credit =
2422 bfa_vc_attr->vc_info[i].vc_credit;
2423 iocmd->attr.vc_info[i].borrow_credit =
2424 bfa_vc_attr->vc_info[i].borrow_credit;
2425 iocmd->attr.vc_info[i].priority =
2426 bfa_vc_attr->vc_info[i].priority;
2427 i++;
2428 }
2429 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2430
2431 iocmd->status = BFA_STATUS_OK;
2432 return 0;
2433 }
2434
2435 static int
2436 bfad_iocmd_qos_get_stats(struct bfad_s *bfad, void *cmd)
2437 {
2438 struct bfa_bsg_fcport_stats_s *iocmd =
2439 (struct bfa_bsg_fcport_stats_s *)cmd;
2440 struct bfad_hal_comp fcomp;
2441 unsigned long flags;
2442 struct bfa_cb_pending_q_s cb_qe;
2443 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2444
2445 init_completion(&fcomp.comp);
2446 bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp,
2447 &fcomp, &iocmd->stats);
2448
2449 spin_lock_irqsave(&bfad->bfad_lock, flags);
2450 WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc));
2451 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2452 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2453 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2454 else
2455 iocmd->status = bfa_fcport_get_stats(&bfad->bfa, &cb_qe);
2456 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2457 if (iocmd->status != BFA_STATUS_OK) {
2458 bfa_trc(bfad, iocmd->status);
2459 goto out;
2460 }
2461 wait_for_completion(&fcomp.comp);
2462 iocmd->status = fcomp.status;
2463 out:
2464 return 0;
2465 }
2466
2467 static int
2468 bfad_iocmd_qos_reset_stats(struct bfad_s *bfad, void *cmd)
2469 {
2470 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2471 struct bfad_hal_comp fcomp;
2472 unsigned long flags;
2473 struct bfa_cb_pending_q_s cb_qe;
2474 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2475
2476 init_completion(&fcomp.comp);
2477 bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp,
2478 &fcomp, NULL);
2479
2480 spin_lock_irqsave(&bfad->bfad_lock, flags);
2481 WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc));
2482 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2483 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2484 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2485 else
2486 iocmd->status = bfa_fcport_clear_stats(&bfad->bfa, &cb_qe);
2487 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2488 if (iocmd->status != BFA_STATUS_OK) {
2489 bfa_trc(bfad, iocmd->status);
2490 goto out;
2491 }
2492 wait_for_completion(&fcomp.comp);
2493 iocmd->status = fcomp.status;
2494 out:
2495 return 0;
2496 }
2497
2498 static int
2499 bfad_iocmd_vf_get_stats(struct bfad_s *bfad, void *cmd)
2500 {
2501 struct bfa_bsg_vf_stats_s *iocmd =
2502 (struct bfa_bsg_vf_stats_s *)cmd;
2503 struct bfa_fcs_fabric_s *fcs_vf;
2504 unsigned long flags;
2505
2506 spin_lock_irqsave(&bfad->bfad_lock, flags);
2507 fcs_vf = bfa_fcs_vf_lookup(&bfad->bfa_fcs, iocmd->vf_id);
2508 if (fcs_vf == NULL) {
2509 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2510 iocmd->status = BFA_STATUS_UNKNOWN_VFID;
2511 goto out;
2512 }
2513 memcpy((void *)&iocmd->stats, (void *)&fcs_vf->stats,
2514 sizeof(struct bfa_vf_stats_s));
2515 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2516 iocmd->status = BFA_STATUS_OK;
2517 out:
2518 return 0;
2519 }
2520
2521 static int
2522 bfad_iocmd_vf_clr_stats(struct bfad_s *bfad, void *cmd)
2523 {
2524 struct bfa_bsg_vf_reset_stats_s *iocmd =
2525 (struct bfa_bsg_vf_reset_stats_s *)cmd;
2526 struct bfa_fcs_fabric_s *fcs_vf;
2527 unsigned long flags;
2528
2529 spin_lock_irqsave(&bfad->bfad_lock, flags);
2530 fcs_vf = bfa_fcs_vf_lookup(&bfad->bfa_fcs, iocmd->vf_id);
2531 if (fcs_vf == NULL) {
2532 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2533 iocmd->status = BFA_STATUS_UNKNOWN_VFID;
2534 goto out;
2535 }
2536 memset((void *)&fcs_vf->stats, 0, sizeof(struct bfa_vf_stats_s));
2537 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2538 iocmd->status = BFA_STATUS_OK;
2539 out:
2540 return 0;
2541 }
2542
2543 /* Function to reset the LUN SCAN mode */
2544 static void
2545 bfad_iocmd_lunmask_reset_lunscan_mode(struct bfad_s *bfad, int lunmask_cfg)
2546 {
2547 struct bfad_im_port_s *pport_im = bfad->pport.im_port;
2548 struct bfad_vport_s *vport = NULL;
2549
2550 /* Set the scsi device LUN SCAN flags for base port */
2551 bfad_reset_sdev_bflags(pport_im, lunmask_cfg);
2552
2553 /* Set the scsi device LUN SCAN flags for the vports */
2554 list_for_each_entry(vport, &bfad->vport_list, list_entry)
2555 bfad_reset_sdev_bflags(vport->drv_port.im_port, lunmask_cfg);
2556 }
2557
2558 static int
2559 bfad_iocmd_lunmask(struct bfad_s *bfad, void *pcmd, unsigned int v_cmd)
2560 {
2561 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
2562 unsigned long flags;
2563
2564 spin_lock_irqsave(&bfad->bfad_lock, flags);
2565 if (v_cmd == IOCMD_FCPIM_LUNMASK_ENABLE) {
2566 iocmd->status = bfa_fcpim_lunmask_update(&bfad->bfa, BFA_TRUE);
2567 /* Set the LUN Scanning mode to be Sequential scan */
2568 if (iocmd->status == BFA_STATUS_OK)
2569 bfad_iocmd_lunmask_reset_lunscan_mode(bfad, BFA_TRUE);
2570 } else if (v_cmd == IOCMD_FCPIM_LUNMASK_DISABLE) {
2571 iocmd->status = bfa_fcpim_lunmask_update(&bfad->bfa, BFA_FALSE);
2572 /* Set the LUN Scanning mode to default REPORT_LUNS scan */
2573 if (iocmd->status == BFA_STATUS_OK)
2574 bfad_iocmd_lunmask_reset_lunscan_mode(bfad, BFA_FALSE);
2575 } else if (v_cmd == IOCMD_FCPIM_LUNMASK_CLEAR)
2576 iocmd->status = bfa_fcpim_lunmask_clear(&bfad->bfa);
2577 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2578 return 0;
2579 }
2580
2581 static int
2582 bfad_iocmd_fcpim_lunmask_query(struct bfad_s *bfad, void *cmd)
2583 {
2584 struct bfa_bsg_fcpim_lunmask_query_s *iocmd =
2585 (struct bfa_bsg_fcpim_lunmask_query_s *)cmd;
2586 struct bfa_lunmask_cfg_s *lun_mask = &iocmd->lun_mask;
2587 unsigned long flags;
2588
2589 spin_lock_irqsave(&bfad->bfad_lock, flags);
2590 iocmd->status = bfa_fcpim_lunmask_query(&bfad->bfa, lun_mask);
2591 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2592 return 0;
2593 }
2594
2595 static int
2596 bfad_iocmd_fcpim_cfg_lunmask(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2597 {
2598 struct bfa_bsg_fcpim_lunmask_s *iocmd =
2599 (struct bfa_bsg_fcpim_lunmask_s *)cmd;
2600 unsigned long flags;
2601
2602 spin_lock_irqsave(&bfad->bfad_lock, flags);
2603 if (v_cmd == IOCMD_FCPIM_LUNMASK_ADD)
2604 iocmd->status = bfa_fcpim_lunmask_add(&bfad->bfa, iocmd->vf_id,
2605 &iocmd->pwwn, iocmd->rpwwn, iocmd->lun);
2606 else if (v_cmd == IOCMD_FCPIM_LUNMASK_DELETE)
2607 iocmd->status = bfa_fcpim_lunmask_delete(&bfad->bfa,
2608 iocmd->vf_id, &iocmd->pwwn,
2609 iocmd->rpwwn, iocmd->lun);
2610 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2611 return 0;
2612 }
2613
2614 static int
2615 bfad_iocmd_fcpim_throttle_query(struct bfad_s *bfad, void *cmd)
2616 {
2617 struct bfa_bsg_fcpim_throttle_s *iocmd =
2618 (struct bfa_bsg_fcpim_throttle_s *)cmd;
2619 unsigned long flags;
2620
2621 spin_lock_irqsave(&bfad->bfad_lock, flags);
2622 iocmd->status = bfa_fcpim_throttle_get(&bfad->bfa,
2623 (void *)&iocmd->throttle);
2624 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2625
2626 return 0;
2627 }
2628
2629 static int
2630 bfad_iocmd_fcpim_throttle_set(struct bfad_s *bfad, void *cmd)
2631 {
2632 struct bfa_bsg_fcpim_throttle_s *iocmd =
2633 (struct bfa_bsg_fcpim_throttle_s *)cmd;
2634 unsigned long flags;
2635
2636 spin_lock_irqsave(&bfad->bfad_lock, flags);
2637 iocmd->status = bfa_fcpim_throttle_set(&bfad->bfa,
2638 iocmd->throttle.cfg_value);
2639 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2640
2641 return 0;
2642 }
2643
2644 static int
2645 bfad_iocmd_tfru_read(struct bfad_s *bfad, void *cmd)
2646 {
2647 struct bfa_bsg_tfru_s *iocmd =
2648 (struct bfa_bsg_tfru_s *)cmd;
2649 struct bfad_hal_comp fcomp;
2650 unsigned long flags = 0;
2651
2652 init_completion(&fcomp.comp);
2653 spin_lock_irqsave(&bfad->bfad_lock, flags);
2654 iocmd->status = bfa_tfru_read(BFA_FRU(&bfad->bfa),
2655 &iocmd->data, iocmd->len, iocmd->offset,
2656 bfad_hcb_comp, &fcomp);
2657 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2658 if (iocmd->status == BFA_STATUS_OK) {
2659 wait_for_completion(&fcomp.comp);
2660 iocmd->status = fcomp.status;
2661 }
2662
2663 return 0;
2664 }
2665
2666 static int
2667 bfad_iocmd_tfru_write(struct bfad_s *bfad, void *cmd)
2668 {
2669 struct bfa_bsg_tfru_s *iocmd =
2670 (struct bfa_bsg_tfru_s *)cmd;
2671 struct bfad_hal_comp fcomp;
2672 unsigned long flags = 0;
2673
2674 init_completion(&fcomp.comp);
2675 spin_lock_irqsave(&bfad->bfad_lock, flags);
2676 iocmd->status = bfa_tfru_write(BFA_FRU(&bfad->bfa),
2677 &iocmd->data, iocmd->len, iocmd->offset,
2678 bfad_hcb_comp, &fcomp);
2679 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2680 if (iocmd->status == BFA_STATUS_OK) {
2681 wait_for_completion(&fcomp.comp);
2682 iocmd->status = fcomp.status;
2683 }
2684
2685 return 0;
2686 }
2687
2688 static int
2689 bfad_iocmd_fruvpd_read(struct bfad_s *bfad, void *cmd)
2690 {
2691 struct bfa_bsg_fruvpd_s *iocmd =
2692 (struct bfa_bsg_fruvpd_s *)cmd;
2693 struct bfad_hal_comp fcomp;
2694 unsigned long flags = 0;
2695
2696 init_completion(&fcomp.comp);
2697 spin_lock_irqsave(&bfad->bfad_lock, flags);
2698 iocmd->status = bfa_fruvpd_read(BFA_FRU(&bfad->bfa),
2699 &iocmd->data, iocmd->len, iocmd->offset,
2700 bfad_hcb_comp, &fcomp);
2701 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2702 if (iocmd->status == BFA_STATUS_OK) {
2703 wait_for_completion(&fcomp.comp);
2704 iocmd->status = fcomp.status;
2705 }
2706
2707 return 0;
2708 }
2709
2710 static int
2711 bfad_iocmd_fruvpd_update(struct bfad_s *bfad, void *cmd)
2712 {
2713 struct bfa_bsg_fruvpd_s *iocmd =
2714 (struct bfa_bsg_fruvpd_s *)cmd;
2715 struct bfad_hal_comp fcomp;
2716 unsigned long flags = 0;
2717
2718 init_completion(&fcomp.comp);
2719 spin_lock_irqsave(&bfad->bfad_lock, flags);
2720 iocmd->status = bfa_fruvpd_update(BFA_FRU(&bfad->bfa),
2721 &iocmd->data, iocmd->len, iocmd->offset,
2722 bfad_hcb_comp, &fcomp, iocmd->trfr_cmpl);
2723 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2724 if (iocmd->status == BFA_STATUS_OK) {
2725 wait_for_completion(&fcomp.comp);
2726 iocmd->status = fcomp.status;
2727 }
2728
2729 return 0;
2730 }
2731
2732 static int
2733 bfad_iocmd_fruvpd_get_max_size(struct bfad_s *bfad, void *cmd)
2734 {
2735 struct bfa_bsg_fruvpd_max_size_s *iocmd =
2736 (struct bfa_bsg_fruvpd_max_size_s *)cmd;
2737 unsigned long flags = 0;
2738
2739 spin_lock_irqsave(&bfad->bfad_lock, flags);
2740 iocmd->status = bfa_fruvpd_get_max_size(BFA_FRU(&bfad->bfa),
2741 &iocmd->max_size);
2742 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2743
2744 return 0;
2745 }
2746
2747 static int
2748 bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
2749 unsigned int payload_len)
2750 {
2751 int rc = -EINVAL;
2752
2753 switch (cmd) {
2754 case IOCMD_IOC_ENABLE:
2755 rc = bfad_iocmd_ioc_enable(bfad, iocmd);
2756 break;
2757 case IOCMD_IOC_DISABLE:
2758 rc = bfad_iocmd_ioc_disable(bfad, iocmd);
2759 break;
2760 case IOCMD_IOC_GET_INFO:
2761 rc = bfad_iocmd_ioc_get_info(bfad, iocmd);
2762 break;
2763 case IOCMD_IOC_GET_ATTR:
2764 rc = bfad_iocmd_ioc_get_attr(bfad, iocmd);
2765 break;
2766 case IOCMD_IOC_GET_STATS:
2767 rc = bfad_iocmd_ioc_get_stats(bfad, iocmd);
2768 break;
2769 case IOCMD_IOC_GET_FWSTATS:
2770 rc = bfad_iocmd_ioc_get_fwstats(bfad, iocmd, payload_len);
2771 break;
2772 case IOCMD_IOC_RESET_STATS:
2773 case IOCMD_IOC_RESET_FWSTATS:
2774 rc = bfad_iocmd_ioc_reset_stats(bfad, iocmd, cmd);
2775 break;
2776 case IOCMD_IOC_SET_ADAPTER_NAME:
2777 case IOCMD_IOC_SET_PORT_NAME:
2778 rc = bfad_iocmd_ioc_set_name(bfad, iocmd, cmd);
2779 break;
2780 case IOCMD_IOCFC_GET_ATTR:
2781 rc = bfad_iocmd_iocfc_get_attr(bfad, iocmd);
2782 break;
2783 case IOCMD_IOCFC_SET_INTR:
2784 rc = bfad_iocmd_iocfc_set_intr(bfad, iocmd);
2785 break;
2786 case IOCMD_PORT_ENABLE:
2787 rc = bfad_iocmd_port_enable(bfad, iocmd);
2788 break;
2789 case IOCMD_PORT_DISABLE:
2790 rc = bfad_iocmd_port_disable(bfad, iocmd);
2791 break;
2792 case IOCMD_PORT_GET_ATTR:
2793 rc = bfad_iocmd_port_get_attr(bfad, iocmd);
2794 break;
2795 case IOCMD_PORT_GET_STATS:
2796 rc = bfad_iocmd_port_get_stats(bfad, iocmd, payload_len);
2797 break;
2798 case IOCMD_PORT_RESET_STATS:
2799 rc = bfad_iocmd_port_reset_stats(bfad, iocmd);
2800 break;
2801 case IOCMD_PORT_CFG_TOPO:
2802 case IOCMD_PORT_CFG_SPEED:
2803 case IOCMD_PORT_CFG_ALPA:
2804 case IOCMD_PORT_CLR_ALPA:
2805 rc = bfad_iocmd_set_port_cfg(bfad, iocmd, cmd);
2806 break;
2807 case IOCMD_PORT_CFG_MAXFRSZ:
2808 rc = bfad_iocmd_port_cfg_maxfrsize(bfad, iocmd);
2809 break;
2810 case IOCMD_PORT_BBCR_ENABLE:
2811 case IOCMD_PORT_BBCR_DISABLE:
2812 rc = bfad_iocmd_port_cfg_bbcr(bfad, cmd, iocmd);
2813 break;
2814 case IOCMD_PORT_BBCR_GET_ATTR:
2815 rc = bfad_iocmd_port_get_bbcr_attr(bfad, iocmd);
2816 break;
2817 case IOCMD_LPORT_GET_ATTR:
2818 rc = bfad_iocmd_lport_get_attr(bfad, iocmd);
2819 break;
2820 case IOCMD_LPORT_GET_STATS:
2821 rc = bfad_iocmd_lport_get_stats(bfad, iocmd);
2822 break;
2823 case IOCMD_LPORT_RESET_STATS:
2824 rc = bfad_iocmd_lport_reset_stats(bfad, iocmd);
2825 break;
2826 case IOCMD_LPORT_GET_IOSTATS:
2827 rc = bfad_iocmd_lport_get_iostats(bfad, iocmd);
2828 break;
2829 case IOCMD_LPORT_GET_RPORTS:
2830 rc = bfad_iocmd_lport_get_rports(bfad, iocmd, payload_len);
2831 break;
2832 case IOCMD_RPORT_GET_ATTR:
2833 rc = bfad_iocmd_rport_get_attr(bfad, iocmd);
2834 break;
2835 case IOCMD_RPORT_GET_ADDR:
2836 rc = bfad_iocmd_rport_get_addr(bfad, iocmd);
2837 break;
2838 case IOCMD_RPORT_GET_STATS:
2839 rc = bfad_iocmd_rport_get_stats(bfad, iocmd);
2840 break;
2841 case IOCMD_RPORT_RESET_STATS:
2842 rc = bfad_iocmd_rport_clr_stats(bfad, iocmd);
2843 break;
2844 case IOCMD_RPORT_SET_SPEED:
2845 rc = bfad_iocmd_rport_set_speed(bfad, iocmd);
2846 break;
2847 case IOCMD_VPORT_GET_ATTR:
2848 rc = bfad_iocmd_vport_get_attr(bfad, iocmd);
2849 break;
2850 case IOCMD_VPORT_GET_STATS:
2851 rc = bfad_iocmd_vport_get_stats(bfad, iocmd);
2852 break;
2853 case IOCMD_VPORT_RESET_STATS:
2854 rc = bfad_iocmd_vport_clr_stats(bfad, iocmd);
2855 break;
2856 case IOCMD_FABRIC_GET_LPORTS:
2857 rc = bfad_iocmd_fabric_get_lports(bfad, iocmd, payload_len);
2858 break;
2859 case IOCMD_RATELIM_ENABLE:
2860 case IOCMD_RATELIM_DISABLE:
2861 rc = bfad_iocmd_ratelim(bfad, cmd, iocmd);
2862 break;
2863 case IOCMD_RATELIM_DEF_SPEED:
2864 rc = bfad_iocmd_ratelim_speed(bfad, cmd, iocmd);
2865 break;
2866 case IOCMD_FCPIM_FAILOVER:
2867 rc = bfad_iocmd_cfg_fcpim(bfad, iocmd);
2868 break;
2869 case IOCMD_FCPIM_MODSTATS:
2870 rc = bfad_iocmd_fcpim_get_modstats(bfad, iocmd);
2871 break;
2872 case IOCMD_FCPIM_MODSTATSCLR:
2873 rc = bfad_iocmd_fcpim_clr_modstats(bfad, iocmd);
2874 break;
2875 case IOCMD_FCPIM_DEL_ITN_STATS:
2876 rc = bfad_iocmd_fcpim_get_del_itn_stats(bfad, iocmd);
2877 break;
2878 case IOCMD_ITNIM_GET_ATTR:
2879 rc = bfad_iocmd_itnim_get_attr(bfad, iocmd);
2880 break;
2881 case IOCMD_ITNIM_GET_IOSTATS:
2882 rc = bfad_iocmd_itnim_get_iostats(bfad, iocmd);
2883 break;
2884 case IOCMD_ITNIM_RESET_STATS:
2885 rc = bfad_iocmd_itnim_reset_stats(bfad, iocmd);
2886 break;
2887 case IOCMD_ITNIM_GET_ITNSTATS:
2888 rc = bfad_iocmd_itnim_get_itnstats(bfad, iocmd);
2889 break;
2890 case IOCMD_FCPORT_ENABLE:
2891 rc = bfad_iocmd_fcport_enable(bfad, iocmd);
2892 break;
2893 case IOCMD_FCPORT_DISABLE:
2894 rc = bfad_iocmd_fcport_disable(bfad, iocmd);
2895 break;
2896 case IOCMD_IOC_PCIFN_CFG:
2897 rc = bfad_iocmd_ioc_get_pcifn_cfg(bfad, iocmd);
2898 break;
2899 case IOCMD_IOC_FW_SIG_INV:
2900 rc = bfad_iocmd_ioc_fw_sig_inv(bfad, iocmd);
2901 break;
2902 case IOCMD_PCIFN_CREATE:
2903 rc = bfad_iocmd_pcifn_create(bfad, iocmd);
2904 break;
2905 case IOCMD_PCIFN_DELETE:
2906 rc = bfad_iocmd_pcifn_delete(bfad, iocmd);
2907 break;
2908 case IOCMD_PCIFN_BW:
2909 rc = bfad_iocmd_pcifn_bw(bfad, iocmd);
2910 break;
2911 case IOCMD_ADAPTER_CFG_MODE:
2912 rc = bfad_iocmd_adapter_cfg_mode(bfad, iocmd);
2913 break;
2914 case IOCMD_PORT_CFG_MODE:
2915 rc = bfad_iocmd_port_cfg_mode(bfad, iocmd);
2916 break;
2917 case IOCMD_FLASH_ENABLE_OPTROM:
2918 case IOCMD_FLASH_DISABLE_OPTROM:
2919 rc = bfad_iocmd_ablk_optrom(bfad, cmd, iocmd);
2920 break;
2921 case IOCMD_FAA_QUERY:
2922 rc = bfad_iocmd_faa_query(bfad, iocmd);
2923 break;
2924 case IOCMD_CEE_GET_ATTR:
2925 rc = bfad_iocmd_cee_attr(bfad, iocmd, payload_len);
2926 break;
2927 case IOCMD_CEE_GET_STATS:
2928 rc = bfad_iocmd_cee_get_stats(bfad, iocmd, payload_len);
2929 break;
2930 case IOCMD_CEE_RESET_STATS:
2931 rc = bfad_iocmd_cee_reset_stats(bfad, iocmd);
2932 break;
2933 case IOCMD_SFP_MEDIA:
2934 rc = bfad_iocmd_sfp_media(bfad, iocmd);
2935 break;
2936 case IOCMD_SFP_SPEED:
2937 rc = bfad_iocmd_sfp_speed(bfad, iocmd);
2938 break;
2939 case IOCMD_FLASH_GET_ATTR:
2940 rc = bfad_iocmd_flash_get_attr(bfad, iocmd);
2941 break;
2942 case IOCMD_FLASH_ERASE_PART:
2943 rc = bfad_iocmd_flash_erase_part(bfad, iocmd);
2944 break;
2945 case IOCMD_FLASH_UPDATE_PART:
2946 rc = bfad_iocmd_flash_update_part(bfad, iocmd, payload_len);
2947 break;
2948 case IOCMD_FLASH_READ_PART:
2949 rc = bfad_iocmd_flash_read_part(bfad, iocmd, payload_len);
2950 break;
2951 case IOCMD_DIAG_TEMP:
2952 rc = bfad_iocmd_diag_temp(bfad, iocmd);
2953 break;
2954 case IOCMD_DIAG_MEMTEST:
2955 rc = bfad_iocmd_diag_memtest(bfad, iocmd);
2956 break;
2957 case IOCMD_DIAG_LOOPBACK:
2958 rc = bfad_iocmd_diag_loopback(bfad, iocmd);
2959 break;
2960 case IOCMD_DIAG_FWPING:
2961 rc = bfad_iocmd_diag_fwping(bfad, iocmd);
2962 break;
2963 case IOCMD_DIAG_QUEUETEST:
2964 rc = bfad_iocmd_diag_queuetest(bfad, iocmd);
2965 break;
2966 case IOCMD_DIAG_SFP:
2967 rc = bfad_iocmd_diag_sfp(bfad, iocmd);
2968 break;
2969 case IOCMD_DIAG_LED:
2970 rc = bfad_iocmd_diag_led(bfad, iocmd);
2971 break;
2972 case IOCMD_DIAG_BEACON_LPORT:
2973 rc = bfad_iocmd_diag_beacon_lport(bfad, iocmd);
2974 break;
2975 case IOCMD_DIAG_LB_STAT:
2976 rc = bfad_iocmd_diag_lb_stat(bfad, iocmd);
2977 break;
2978 case IOCMD_DIAG_DPORT_ENABLE:
2979 rc = bfad_iocmd_diag_dport_enable(bfad, iocmd);
2980 break;
2981 case IOCMD_DIAG_DPORT_DISABLE:
2982 rc = bfad_iocmd_diag_dport_disable(bfad, iocmd);
2983 break;
2984 case IOCMD_DIAG_DPORT_SHOW:
2985 rc = bfad_iocmd_diag_dport_show(bfad, iocmd);
2986 break;
2987 case IOCMD_DIAG_DPORT_START:
2988 rc = bfad_iocmd_diag_dport_start(bfad, iocmd);
2989 break;
2990 case IOCMD_PHY_GET_ATTR:
2991 rc = bfad_iocmd_phy_get_attr(bfad, iocmd);
2992 break;
2993 case IOCMD_PHY_GET_STATS:
2994 rc = bfad_iocmd_phy_get_stats(bfad, iocmd);
2995 break;
2996 case IOCMD_PHY_UPDATE_FW:
2997 rc = bfad_iocmd_phy_update(bfad, iocmd, payload_len);
2998 break;
2999 case IOCMD_PHY_READ_FW:
3000 rc = bfad_iocmd_phy_read(bfad, iocmd, payload_len);
3001 break;
3002 case IOCMD_VHBA_QUERY:
3003 rc = bfad_iocmd_vhba_query(bfad, iocmd);
3004 break;
3005 case IOCMD_DEBUG_PORTLOG:
3006 rc = bfad_iocmd_porglog_get(bfad, iocmd);
3007 break;
3008 case IOCMD_DEBUG_FW_CORE:
3009 rc = bfad_iocmd_debug_fw_core(bfad, iocmd, payload_len);
3010 break;
3011 case IOCMD_DEBUG_FW_STATE_CLR:
3012 case IOCMD_DEBUG_PORTLOG_CLR:
3013 case IOCMD_DEBUG_START_DTRC:
3014 case IOCMD_DEBUG_STOP_DTRC:
3015 rc = bfad_iocmd_debug_ctl(bfad, iocmd, cmd);
3016 break;
3017 case IOCMD_DEBUG_PORTLOG_CTL:
3018 rc = bfad_iocmd_porglog_ctl(bfad, iocmd);
3019 break;
3020 case IOCMD_FCPIM_PROFILE_ON:
3021 case IOCMD_FCPIM_PROFILE_OFF:
3022 rc = bfad_iocmd_fcpim_cfg_profile(bfad, iocmd, cmd);
3023 break;
3024 case IOCMD_ITNIM_GET_IOPROFILE:
3025 rc = bfad_iocmd_itnim_get_ioprofile(bfad, iocmd);
3026 break;
3027 case IOCMD_FCPORT_GET_STATS:
3028 rc = bfad_iocmd_fcport_get_stats(bfad, iocmd);
3029 break;
3030 case IOCMD_FCPORT_RESET_STATS:
3031 rc = bfad_iocmd_fcport_reset_stats(bfad, iocmd);
3032 break;
3033 case IOCMD_BOOT_CFG:
3034 rc = bfad_iocmd_boot_cfg(bfad, iocmd);
3035 break;
3036 case IOCMD_BOOT_QUERY:
3037 rc = bfad_iocmd_boot_query(bfad, iocmd);
3038 break;
3039 case IOCMD_PREBOOT_QUERY:
3040 rc = bfad_iocmd_preboot_query(bfad, iocmd);
3041 break;
3042 case IOCMD_ETHBOOT_CFG:
3043 rc = bfad_iocmd_ethboot_cfg(bfad, iocmd);
3044 break;
3045 case IOCMD_ETHBOOT_QUERY:
3046 rc = bfad_iocmd_ethboot_query(bfad, iocmd);
3047 break;
3048 case IOCMD_TRUNK_ENABLE:
3049 case IOCMD_TRUNK_DISABLE:
3050 rc = bfad_iocmd_cfg_trunk(bfad, iocmd, cmd);
3051 break;
3052 case IOCMD_TRUNK_GET_ATTR:
3053 rc = bfad_iocmd_trunk_get_attr(bfad, iocmd);
3054 break;
3055 case IOCMD_QOS_ENABLE:
3056 case IOCMD_QOS_DISABLE:
3057 rc = bfad_iocmd_qos(bfad, iocmd, cmd);
3058 break;
3059 case IOCMD_QOS_GET_ATTR:
3060 rc = bfad_iocmd_qos_get_attr(bfad, iocmd);
3061 break;
3062 case IOCMD_QOS_GET_VC_ATTR:
3063 rc = bfad_iocmd_qos_get_vc_attr(bfad, iocmd);
3064 break;
3065 case IOCMD_QOS_GET_STATS:
3066 rc = bfad_iocmd_qos_get_stats(bfad, iocmd);
3067 break;
3068 case IOCMD_QOS_RESET_STATS:
3069 rc = bfad_iocmd_qos_reset_stats(bfad, iocmd);
3070 break;
3071 case IOCMD_QOS_SET_BW:
3072 rc = bfad_iocmd_qos_set_bw(bfad, iocmd);
3073 break;
3074 case IOCMD_VF_GET_STATS:
3075 rc = bfad_iocmd_vf_get_stats(bfad, iocmd);
3076 break;
3077 case IOCMD_VF_RESET_STATS:
3078 rc = bfad_iocmd_vf_clr_stats(bfad, iocmd);
3079 break;
3080 case IOCMD_FCPIM_LUNMASK_ENABLE:
3081 case IOCMD_FCPIM_LUNMASK_DISABLE:
3082 case IOCMD_FCPIM_LUNMASK_CLEAR:
3083 rc = bfad_iocmd_lunmask(bfad, iocmd, cmd);
3084 break;
3085 case IOCMD_FCPIM_LUNMASK_QUERY:
3086 rc = bfad_iocmd_fcpim_lunmask_query(bfad, iocmd);
3087 break;
3088 case IOCMD_FCPIM_LUNMASK_ADD:
3089 case IOCMD_FCPIM_LUNMASK_DELETE:
3090 rc = bfad_iocmd_fcpim_cfg_lunmask(bfad, iocmd, cmd);
3091 break;
3092 case IOCMD_FCPIM_THROTTLE_QUERY:
3093 rc = bfad_iocmd_fcpim_throttle_query(bfad, iocmd);
3094 break;
3095 case IOCMD_FCPIM_THROTTLE_SET:
3096 rc = bfad_iocmd_fcpim_throttle_set(bfad, iocmd);
3097 break;
3098 /* TFRU */
3099 case IOCMD_TFRU_READ:
3100 rc = bfad_iocmd_tfru_read(bfad, iocmd);
3101 break;
3102 case IOCMD_TFRU_WRITE:
3103 rc = bfad_iocmd_tfru_write(bfad, iocmd);
3104 break;
3105 /* FRU */
3106 case IOCMD_FRUVPD_READ:
3107 rc = bfad_iocmd_fruvpd_read(bfad, iocmd);
3108 break;
3109 case IOCMD_FRUVPD_UPDATE:
3110 rc = bfad_iocmd_fruvpd_update(bfad, iocmd);
3111 break;
3112 case IOCMD_FRUVPD_GET_MAX_SIZE:
3113 rc = bfad_iocmd_fruvpd_get_max_size(bfad, iocmd);
3114 break;
3115 default:
3116 rc = -EINVAL;
3117 break;
3118 }
3119 return rc;
3120 }
3121
3122 static int
3123 bfad_im_bsg_vendor_request(struct bsg_job *job)
3124 {
3125 struct fc_bsg_request *bsg_request = job->request;
3126 struct fc_bsg_reply *bsg_reply = job->reply;
3127 uint32_t vendor_cmd = bsg_request->rqst_data.h_vendor.vendor_cmd[0];
3128 struct Scsi_Host *shost = fc_bsg_to_shost(job);
3129 struct bfad_im_port_s *im_port = bfad_get_im_port(shost);
3130 struct bfad_s *bfad = im_port->bfad;
3131 void *payload_kbuf;
3132 int rc = -EINVAL;
3133
3134 /* Allocate a temp buffer to hold the passed in user space command */
3135 payload_kbuf = kzalloc(job->request_payload.payload_len, GFP_KERNEL);
3136 if (!payload_kbuf) {
3137 rc = -ENOMEM;
3138 goto out;
3139 }
3140
3141 /* Copy the sg_list passed in to a linear buffer: holds the cmnd data */
3142 sg_copy_to_buffer(job->request_payload.sg_list,
3143 job->request_payload.sg_cnt, payload_kbuf,
3144 job->request_payload.payload_len);
3145
3146 /* Invoke IOCMD handler - to handle all the vendor command requests */
3147 rc = bfad_iocmd_handler(bfad, vendor_cmd, payload_kbuf,
3148 job->request_payload.payload_len);
3149 if (rc != BFA_STATUS_OK)
3150 goto error;
3151
3152 /* Copy the response data to the job->reply_payload sg_list */
3153 sg_copy_from_buffer(job->reply_payload.sg_list,
3154 job->reply_payload.sg_cnt,
3155 payload_kbuf,
3156 job->reply_payload.payload_len);
3157
3158 /* free the command buffer */
3159 kfree(payload_kbuf);
3160
3161 /* Fill the BSG job reply data */
3162 job->reply_len = job->reply_payload.payload_len;
3163 bsg_reply->reply_payload_rcv_len = job->reply_payload.payload_len;
3164 bsg_reply->result = rc;
3165
3166 bsg_job_done(job, bsg_reply->result,
3167 bsg_reply->reply_payload_rcv_len);
3168 return rc;
3169 error:
3170 /* free the command buffer */
3171 kfree(payload_kbuf);
3172 out:
3173 bsg_reply->result = rc;
3174 job->reply_len = sizeof(uint32_t);
3175 bsg_reply->reply_payload_rcv_len = 0;
3176 return rc;
3177 }
3178
3179 /* FC passthru call backs */
3180 static u64
3181 bfad_fcxp_get_req_sgaddr_cb(void *bfad_fcxp, int sgeid)
3182 {
3183 struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3184 struct bfa_sge_s *sge;
3185 u64 addr;
3186
3187 sge = drv_fcxp->req_sge + sgeid;
3188 addr = (u64)(size_t) sge->sg_addr;
3189 return addr;
3190 }
3191
3192 static u32
3193 bfad_fcxp_get_req_sglen_cb(void *bfad_fcxp, int sgeid)
3194 {
3195 struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3196 struct bfa_sge_s *sge;
3197
3198 sge = drv_fcxp->req_sge + sgeid;
3199 return sge->sg_len;
3200 }
3201
3202 static u64
3203 bfad_fcxp_get_rsp_sgaddr_cb(void *bfad_fcxp, int sgeid)
3204 {
3205 struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3206 struct bfa_sge_s *sge;
3207 u64 addr;
3208
3209 sge = drv_fcxp->rsp_sge + sgeid;
3210 addr = (u64)(size_t) sge->sg_addr;
3211 return addr;
3212 }
3213
3214 static u32
3215 bfad_fcxp_get_rsp_sglen_cb(void *bfad_fcxp, int sgeid)
3216 {
3217 struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3218 struct bfa_sge_s *sge;
3219
3220 sge = drv_fcxp->rsp_sge + sgeid;
3221 return sge->sg_len;
3222 }
3223
3224 static void
3225 bfad_send_fcpt_cb(void *bfad_fcxp, struct bfa_fcxp_s *fcxp, void *cbarg,
3226 bfa_status_t req_status, u32 rsp_len, u32 resid_len,
3227 struct fchs_s *rsp_fchs)
3228 {
3229 struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3230
3231 drv_fcxp->req_status = req_status;
3232 drv_fcxp->rsp_len = rsp_len;
3233
3234 /* bfa_fcxp will be automatically freed by BFA */
3235 drv_fcxp->bfa_fcxp = NULL;
3236 complete(&drv_fcxp->comp);
3237 }
3238
3239 static struct bfad_buf_info *
3240 bfad_fcxp_map_sg(struct bfad_s *bfad, void *payload_kbuf,
3241 uint32_t payload_len, uint32_t *num_sgles)
3242 {
3243 struct bfad_buf_info *buf_base, *buf_info;
3244 struct bfa_sge_s *sg_table;
3245 int sge_num = 1;
3246
3247 buf_base = kcalloc(sizeof(struct bfad_buf_info) +
3248 sizeof(struct bfa_sge_s),
3249 sge_num, GFP_KERNEL);
3250 if (!buf_base)
3251 return NULL;
3252
3253 sg_table = (struct bfa_sge_s *) (((uint8_t *)buf_base) +
3254 (sizeof(struct bfad_buf_info) * sge_num));
3255
3256 /* Allocate dma coherent memory */
3257 buf_info = buf_base;
3258 buf_info->size = payload_len;
3259 buf_info->virt = dma_alloc_coherent(&bfad->pcidev->dev,
3260 buf_info->size, &buf_info->phys,
3261 GFP_KERNEL);
3262 if (!buf_info->virt)
3263 goto out_free_mem;
3264
3265 /* copy the linear bsg buffer to buf_info */
3266 memcpy(buf_info->virt, payload_kbuf, buf_info->size);
3267
3268 /*
3269 * Setup SG table
3270 */
3271 sg_table->sg_len = buf_info->size;
3272 sg_table->sg_addr = (void *)(size_t) buf_info->phys;
3273
3274 *num_sgles = sge_num;
3275
3276 return buf_base;
3277
3278 out_free_mem:
3279 kfree(buf_base);
3280 return NULL;
3281 }
3282
3283 static void
3284 bfad_fcxp_free_mem(struct bfad_s *bfad, struct bfad_buf_info *buf_base,
3285 uint32_t num_sgles)
3286 {
3287 int i;
3288 struct bfad_buf_info *buf_info = buf_base;
3289
3290 if (buf_base) {
3291 for (i = 0; i < num_sgles; buf_info++, i++) {
3292 if (buf_info->virt != NULL)
3293 dma_free_coherent(&bfad->pcidev->dev,
3294 buf_info->size, buf_info->virt,
3295 buf_info->phys);
3296 }
3297 kfree(buf_base);
3298 }
3299 }
3300
3301 static int
3302 bfad_fcxp_bsg_send(struct bsg_job *job, struct bfad_fcxp *drv_fcxp,
3303 bfa_bsg_fcpt_t *bsg_fcpt)
3304 {
3305 struct bfa_fcxp_s *hal_fcxp;
3306 struct bfad_s *bfad = drv_fcxp->port->bfad;
3307 unsigned long flags;
3308 uint8_t lp_tag;
3309
3310 spin_lock_irqsave(&bfad->bfad_lock, flags);
3311
3312 /* Allocate bfa_fcxp structure */
3313 hal_fcxp = bfa_fcxp_req_rsp_alloc(drv_fcxp, &bfad->bfa,
3314 drv_fcxp->num_req_sgles,
3315 drv_fcxp->num_rsp_sgles,
3316 bfad_fcxp_get_req_sgaddr_cb,
3317 bfad_fcxp_get_req_sglen_cb,
3318 bfad_fcxp_get_rsp_sgaddr_cb,
3319 bfad_fcxp_get_rsp_sglen_cb, BFA_TRUE);
3320 if (!hal_fcxp) {
3321 bfa_trc(bfad, 0);
3322 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3323 return BFA_STATUS_ENOMEM;
3324 }
3325
3326 drv_fcxp->bfa_fcxp = hal_fcxp;
3327
3328 lp_tag = bfa_lps_get_tag_from_pid(&bfad->bfa, bsg_fcpt->fchs.s_id);
3329
3330 bfa_fcxp_send(hal_fcxp, drv_fcxp->bfa_rport, bsg_fcpt->vf_id, lp_tag,
3331 bsg_fcpt->cts, bsg_fcpt->cos,
3332 job->request_payload.payload_len,
3333 &bsg_fcpt->fchs, bfad_send_fcpt_cb, bfad,
3334 job->reply_payload.payload_len, bsg_fcpt->tsecs);
3335
3336 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3337
3338 return BFA_STATUS_OK;
3339 }
3340
3341 static int
3342 bfad_im_bsg_els_ct_request(struct bsg_job *job)
3343 {
3344 struct bfa_bsg_data *bsg_data;
3345 struct Scsi_Host *shost = fc_bsg_to_shost(job);
3346 struct bfad_im_port_s *im_port = bfad_get_im_port(shost);
3347 struct bfad_s *bfad = im_port->bfad;
3348 bfa_bsg_fcpt_t *bsg_fcpt;
3349 struct bfad_fcxp *drv_fcxp;
3350 struct bfa_fcs_lport_s *fcs_port;
3351 struct bfa_fcs_rport_s *fcs_rport;
3352 struct fc_bsg_request *bsg_request = job->request;
3353 struct fc_bsg_reply *bsg_reply = job->reply;
3354 uint32_t command_type = bsg_request->msgcode;
3355 unsigned long flags;
3356 struct bfad_buf_info *rsp_buf_info;
3357 void *req_kbuf = NULL, *rsp_kbuf = NULL;
3358 int rc = -EINVAL;
3359
3360 job->reply_len = sizeof(uint32_t); /* Atleast uint32_t reply_len */
3361 bsg_reply->reply_payload_rcv_len = 0;
3362
3363 /* Get the payload passed in from userspace */
3364 bsg_data = (struct bfa_bsg_data *) (((char *)bsg_request) +
3365 sizeof(struct fc_bsg_request));
3366 if (bsg_data == NULL)
3367 goto out;
3368
3369 /*
3370 * Allocate buffer for bsg_fcpt and do a copy_from_user op for payload
3371 * buffer of size bsg_data->payload_len
3372 */
3373 bsg_fcpt = kzalloc(bsg_data->payload_len, GFP_KERNEL);
3374 if (!bsg_fcpt) {
3375 rc = -ENOMEM;
3376 goto out;
3377 }
3378
3379 if (copy_from_user((uint8_t *)bsg_fcpt,
3380 (void *)(unsigned long)bsg_data->payload,
3381 bsg_data->payload_len)) {
3382 kfree(bsg_fcpt);
3383 rc = -EIO;
3384 goto out;
3385 }
3386
3387 drv_fcxp = kzalloc(sizeof(struct bfad_fcxp), GFP_KERNEL);
3388 if (drv_fcxp == NULL) {
3389 kfree(bsg_fcpt);
3390 rc = -ENOMEM;
3391 goto out;
3392 }
3393
3394 spin_lock_irqsave(&bfad->bfad_lock, flags);
3395 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs, bsg_fcpt->vf_id,
3396 bsg_fcpt->lpwwn);
3397 if (fcs_port == NULL) {
3398 bsg_fcpt->status = BFA_STATUS_UNKNOWN_LWWN;
3399 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3400 goto out_free_mem;
3401 }
3402
3403 /* Check if the port is online before sending FC Passthru cmd */
3404 if (!bfa_fcs_lport_is_online(fcs_port)) {
3405 bsg_fcpt->status = BFA_STATUS_PORT_OFFLINE;
3406 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3407 goto out_free_mem;
3408 }
3409
3410 drv_fcxp->port = fcs_port->bfad_port;
3411
3412 if (drv_fcxp->port->bfad == 0)
3413 drv_fcxp->port->bfad = bfad;
3414
3415 /* Fetch the bfa_rport - if nexus needed */
3416 if (command_type == FC_BSG_HST_ELS_NOLOGIN ||
3417 command_type == FC_BSG_HST_CT) {
3418 /* BSG HST commands: no nexus needed */
3419 drv_fcxp->bfa_rport = NULL;
3420
3421 } else if (command_type == FC_BSG_RPT_ELS ||
3422 command_type == FC_BSG_RPT_CT) {
3423 /* BSG RPT commands: nexus needed */
3424 fcs_rport = bfa_fcs_lport_get_rport_by_pwwn(fcs_port,
3425 bsg_fcpt->dpwwn);
3426 if (fcs_rport == NULL) {
3427 bsg_fcpt->status = BFA_STATUS_UNKNOWN_RWWN;
3428 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3429 goto out_free_mem;
3430 }
3431
3432 drv_fcxp->bfa_rport = fcs_rport->bfa_rport;
3433
3434 } else { /* Unknown BSG msgcode; return -EINVAL */
3435 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3436 goto out_free_mem;
3437 }
3438
3439 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3440
3441 /* allocate memory for req / rsp buffers */
3442 req_kbuf = kzalloc(job->request_payload.payload_len, GFP_KERNEL);
3443 if (!req_kbuf) {
3444 printk(KERN_INFO "bfa %s: fcpt request buffer alloc failed\n",
3445 bfad->pci_name);
3446 rc = -ENOMEM;
3447 goto out_free_mem;
3448 }
3449
3450 rsp_kbuf = kzalloc(job->reply_payload.payload_len, GFP_KERNEL);
3451 if (!rsp_kbuf) {
3452 printk(KERN_INFO "bfa %s: fcpt response buffer alloc failed\n",
3453 bfad->pci_name);
3454 rc = -ENOMEM;
3455 goto out_free_mem;
3456 }
3457
3458 /* map req sg - copy the sg_list passed in to the linear buffer */
3459 sg_copy_to_buffer(job->request_payload.sg_list,
3460 job->request_payload.sg_cnt, req_kbuf,
3461 job->request_payload.payload_len);
3462
3463 drv_fcxp->reqbuf_info = bfad_fcxp_map_sg(bfad, req_kbuf,
3464 job->request_payload.payload_len,
3465 &drv_fcxp->num_req_sgles);
3466 if (!drv_fcxp->reqbuf_info) {
3467 printk(KERN_INFO "bfa %s: fcpt request fcxp_map_sg failed\n",
3468 bfad->pci_name);
3469 rc = -ENOMEM;
3470 goto out_free_mem;
3471 }
3472
3473 drv_fcxp->req_sge = (struct bfa_sge_s *)
3474 (((uint8_t *)drv_fcxp->reqbuf_info) +
3475 (sizeof(struct bfad_buf_info) *
3476 drv_fcxp->num_req_sgles));
3477
3478 /* map rsp sg */
3479 drv_fcxp->rspbuf_info = bfad_fcxp_map_sg(bfad, rsp_kbuf,
3480 job->reply_payload.payload_len,
3481 &drv_fcxp->num_rsp_sgles);
3482 if (!drv_fcxp->rspbuf_info) {
3483 printk(KERN_INFO "bfa %s: fcpt response fcxp_map_sg failed\n",
3484 bfad->pci_name);
3485 rc = -ENOMEM;
3486 goto out_free_mem;
3487 }
3488
3489 rsp_buf_info = (struct bfad_buf_info *)drv_fcxp->rspbuf_info;
3490 drv_fcxp->rsp_sge = (struct bfa_sge_s *)
3491 (((uint8_t *)drv_fcxp->rspbuf_info) +
3492 (sizeof(struct bfad_buf_info) *
3493 drv_fcxp->num_rsp_sgles));
3494
3495 /* fcxp send */
3496 init_completion(&drv_fcxp->comp);
3497 rc = bfad_fcxp_bsg_send(job, drv_fcxp, bsg_fcpt);
3498 if (rc == BFA_STATUS_OK) {
3499 wait_for_completion(&drv_fcxp->comp);
3500 bsg_fcpt->status = drv_fcxp->req_status;
3501 } else {
3502 bsg_fcpt->status = rc;
3503 goto out_free_mem;
3504 }
3505
3506 /* fill the job->reply data */
3507 if (drv_fcxp->req_status == BFA_STATUS_OK) {
3508 job->reply_len = drv_fcxp->rsp_len;
3509 bsg_reply->reply_payload_rcv_len = drv_fcxp->rsp_len;
3510 bsg_reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
3511 } else {
3512 bsg_reply->reply_payload_rcv_len =
3513 sizeof(struct fc_bsg_ctels_reply);
3514 job->reply_len = sizeof(uint32_t);
3515 bsg_reply->reply_data.ctels_reply.status =
3516 FC_CTELS_STATUS_REJECT;
3517 }
3518
3519 /* Copy the response data to the reply_payload sg list */
3520 sg_copy_from_buffer(job->reply_payload.sg_list,
3521 job->reply_payload.sg_cnt,
3522 (uint8_t *)rsp_buf_info->virt,
3523 job->reply_payload.payload_len);
3524
3525 out_free_mem:
3526 bfad_fcxp_free_mem(bfad, drv_fcxp->rspbuf_info,
3527 drv_fcxp->num_rsp_sgles);
3528 bfad_fcxp_free_mem(bfad, drv_fcxp->reqbuf_info,
3529 drv_fcxp->num_req_sgles);
3530 kfree(req_kbuf);
3531 kfree(rsp_kbuf);
3532
3533 /* Need a copy to user op */
3534 if (copy_to_user((void *)(unsigned long)bsg_data->payload,
3535 (void *)bsg_fcpt, bsg_data->payload_len))
3536 rc = -EIO;
3537
3538 kfree(bsg_fcpt);
3539 kfree(drv_fcxp);
3540 out:
3541 bsg_reply->result = rc;
3542
3543 if (rc == BFA_STATUS_OK)
3544 bsg_job_done(job, bsg_reply->result,
3545 bsg_reply->reply_payload_rcv_len);
3546
3547 return rc;
3548 }
3549
3550 int
3551 bfad_im_bsg_request(struct bsg_job *job)
3552 {
3553 struct fc_bsg_request *bsg_request = job->request;
3554 struct fc_bsg_reply *bsg_reply = job->reply;
3555 uint32_t rc = BFA_STATUS_OK;
3556
3557 switch (bsg_request->msgcode) {
3558 case FC_BSG_HST_VENDOR:
3559 /* Process BSG HST Vendor requests */
3560 rc = bfad_im_bsg_vendor_request(job);
3561 break;
3562 case FC_BSG_HST_ELS_NOLOGIN:
3563 case FC_BSG_RPT_ELS:
3564 case FC_BSG_HST_CT:
3565 case FC_BSG_RPT_CT:
3566 /* Process BSG ELS/CT commands */
3567 rc = bfad_im_bsg_els_ct_request(job);
3568 break;
3569 default:
3570 bsg_reply->result = rc = -EINVAL;
3571 bsg_reply->reply_payload_rcv_len = 0;
3572 break;
3573 }
3574
3575 return rc;
3576 }
3577
3578 int
3579 bfad_im_bsg_timeout(struct bsg_job *job)
3580 {
3581 /* Don't complete the BSG job request - return -EAGAIN
3582 * to reset bsg job timeout : for ELS/CT pass thru we
3583 * already have timer to track the request.
3584 */
3585 return -EAGAIN;
3586 }
Linux with added FPC-III support