?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/virtio: Don't return error if virtio-gpu PCI dev is not found
[drm/drm-misc.git] / drivers / scsi / bfa / bfad_bsg.c
blob54bd11e6d593350f632b55af7deb3599c59adc9f
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 strscpy(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 strscpy(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_status(&cb_qe, bfad_hcb_comp, &fcomp, &iocmd->stats);
2139 spin_lock_irqsave(&bfad->bfad_lock, flags);
2140 iocmd->status = bfa_fcport_get_stats(&bfad->bfa, &cb_qe);
2141 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2142 if (iocmd->status != BFA_STATUS_OK) {
2143 bfa_trc(bfad, iocmd->status);
2144 goto out;
2145 }
2146 wait_for_completion(&fcomp.comp);
2147 iocmd->status = fcomp.status;
2148 out:
2149 return 0;
2150 }
2151
2152 static int
2153 bfad_iocmd_fcport_reset_stats(struct bfad_s *bfad, void *cmd)
2154 {
2155 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2156 struct bfad_hal_comp fcomp;
2157 unsigned long flags;
2158 struct bfa_cb_pending_q_s cb_qe;
2159
2160 init_completion(&fcomp.comp);
2161 bfa_pending_q_init_status(&cb_qe, bfad_hcb_comp, &fcomp, NULL);
2162
2163 spin_lock_irqsave(&bfad->bfad_lock, flags);
2164 iocmd->status = bfa_fcport_clear_stats(&bfad->bfa, &cb_qe);
2165 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2166 if (iocmd->status != BFA_STATUS_OK) {
2167 bfa_trc(bfad, iocmd->status);
2168 goto out;
2169 }
2170 wait_for_completion(&fcomp.comp);
2171 iocmd->status = fcomp.status;
2172 out:
2173 return 0;
2174 }
2175
2176 static int
2177 bfad_iocmd_boot_cfg(struct bfad_s *bfad, void *cmd)
2178 {
2179 struct bfa_bsg_boot_s *iocmd = (struct bfa_bsg_boot_s *)cmd;
2180 struct bfad_hal_comp fcomp;
2181 unsigned long flags;
2182
2183 init_completion(&fcomp.comp);
2184 spin_lock_irqsave(&bfad->bfad_lock, flags);
2185 iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
2186 BFA_FLASH_PART_BOOT, bfad->bfa.ioc.port_id,
2187 &iocmd->cfg, sizeof(struct bfa_boot_cfg_s), 0,
2188 bfad_hcb_comp, &fcomp);
2189 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2190 if (iocmd->status != BFA_STATUS_OK)
2191 goto out;
2192 wait_for_completion(&fcomp.comp);
2193 iocmd->status = fcomp.status;
2194 out:
2195 return 0;
2196 }
2197
2198 static int
2199 bfad_iocmd_boot_query(struct bfad_s *bfad, void *cmd)
2200 {
2201 struct bfa_bsg_boot_s *iocmd = (struct bfa_bsg_boot_s *)cmd;
2202 struct bfad_hal_comp fcomp;
2203 unsigned long flags;
2204
2205 init_completion(&fcomp.comp);
2206 spin_lock_irqsave(&bfad->bfad_lock, flags);
2207 iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa),
2208 BFA_FLASH_PART_BOOT, bfad->bfa.ioc.port_id,
2209 &iocmd->cfg, sizeof(struct bfa_boot_cfg_s), 0,
2210 bfad_hcb_comp, &fcomp);
2211 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2212 if (iocmd->status != BFA_STATUS_OK)
2213 goto out;
2214 wait_for_completion(&fcomp.comp);
2215 iocmd->status = fcomp.status;
2216 out:
2217 return 0;
2218 }
2219
2220 static int
2221 bfad_iocmd_preboot_query(struct bfad_s *bfad, void *cmd)
2222 {
2223 struct bfa_bsg_preboot_s *iocmd = (struct bfa_bsg_preboot_s *)cmd;
2224 struct bfi_iocfc_cfgrsp_s *cfgrsp = bfad->bfa.iocfc.cfgrsp;
2225 struct bfa_boot_pbc_s *pbcfg = &iocmd->cfg;
2226 unsigned long flags;
2227
2228 spin_lock_irqsave(&bfad->bfad_lock, flags);
2229 pbcfg->enable = cfgrsp->pbc_cfg.boot_enabled;
2230 pbcfg->nbluns = cfgrsp->pbc_cfg.nbluns;
2231 pbcfg->speed = cfgrsp->pbc_cfg.port_speed;
2232 memcpy(pbcfg->pblun, cfgrsp->pbc_cfg.blun, sizeof(pbcfg->pblun));
2233 iocmd->status = BFA_STATUS_OK;
2234 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2235
2236 return 0;
2237 }
2238
2239 static int
2240 bfad_iocmd_ethboot_cfg(struct bfad_s *bfad, void *cmd)
2241 {
2242 struct bfa_bsg_ethboot_s *iocmd = (struct bfa_bsg_ethboot_s *)cmd;
2243 struct bfad_hal_comp fcomp;
2244 unsigned long flags;
2245
2246 init_completion(&fcomp.comp);
2247 spin_lock_irqsave(&bfad->bfad_lock, flags);
2248 iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
2249 BFA_FLASH_PART_PXECFG,
2250 bfad->bfa.ioc.port_id, &iocmd->cfg,
2251 sizeof(struct bfa_ethboot_cfg_s), 0,
2252 bfad_hcb_comp, &fcomp);
2253 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2254 if (iocmd->status != BFA_STATUS_OK)
2255 goto out;
2256 wait_for_completion(&fcomp.comp);
2257 iocmd->status = fcomp.status;
2258 out:
2259 return 0;
2260 }
2261
2262 static int
2263 bfad_iocmd_ethboot_query(struct bfad_s *bfad, void *cmd)
2264 {
2265 struct bfa_bsg_ethboot_s *iocmd = (struct bfa_bsg_ethboot_s *)cmd;
2266 struct bfad_hal_comp fcomp;
2267 unsigned long flags;
2268
2269 init_completion(&fcomp.comp);
2270 spin_lock_irqsave(&bfad->bfad_lock, flags);
2271 iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa),
2272 BFA_FLASH_PART_PXECFG,
2273 bfad->bfa.ioc.port_id, &iocmd->cfg,
2274 sizeof(struct bfa_ethboot_cfg_s), 0,
2275 bfad_hcb_comp, &fcomp);
2276 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2277 if (iocmd->status != BFA_STATUS_OK)
2278 goto out;
2279 wait_for_completion(&fcomp.comp);
2280 iocmd->status = fcomp.status;
2281 out:
2282 return 0;
2283 }
2284
2285 static int
2286 bfad_iocmd_cfg_trunk(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2287 {
2288 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2289 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2290 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
2291 unsigned long flags;
2292
2293 spin_lock_irqsave(&bfad->bfad_lock, flags);
2294
2295 if (bfa_fcport_is_dport(&bfad->bfa)) {
2296 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2297 return BFA_STATUS_DPORT_ERR;
2298 }
2299
2300 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) ||
2301 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2302 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2303 else {
2304 if (v_cmd == IOCMD_TRUNK_ENABLE) {
2305 trunk->attr.state = BFA_TRUNK_OFFLINE;
2306 bfa_fcport_disable(&bfad->bfa);
2307 fcport->cfg.trunked = BFA_TRUE;
2308 } else if (v_cmd == IOCMD_TRUNK_DISABLE) {
2309 trunk->attr.state = BFA_TRUNK_DISABLED;
2310 bfa_fcport_disable(&bfad->bfa);
2311 fcport->cfg.trunked = BFA_FALSE;
2312 }
2313
2314 if (!bfa_fcport_is_disabled(&bfad->bfa))
2315 bfa_fcport_enable(&bfad->bfa);
2316
2317 iocmd->status = BFA_STATUS_OK;
2318 }
2319
2320 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2321
2322 return 0;
2323 }
2324
2325 static int
2326 bfad_iocmd_trunk_get_attr(struct bfad_s *bfad, void *cmd)
2327 {
2328 struct bfa_bsg_trunk_attr_s *iocmd = (struct bfa_bsg_trunk_attr_s *)cmd;
2329 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2330 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
2331 unsigned long flags;
2332
2333 spin_lock_irqsave(&bfad->bfad_lock, flags);
2334 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) ||
2335 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2336 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2337 else {
2338 memcpy((void *)&iocmd->attr, (void *)&trunk->attr,
2339 sizeof(struct bfa_trunk_attr_s));
2340 iocmd->attr.port_id = bfa_lps_get_base_pid(&bfad->bfa);
2341 iocmd->status = BFA_STATUS_OK;
2342 }
2343 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2344
2345 return 0;
2346 }
2347
2348 static int
2349 bfad_iocmd_qos(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2350 {
2351 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2352 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2353 unsigned long flags;
2354
2355 spin_lock_irqsave(&bfad->bfad_lock, flags);
2356 if (bfa_ioc_get_type(&bfad->bfa.ioc) == BFA_IOC_TYPE_FC) {
2357 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2358 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2359 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2360 else {
2361 if (v_cmd == IOCMD_QOS_ENABLE)
2362 fcport->cfg.qos_enabled = BFA_TRUE;
2363 else if (v_cmd == IOCMD_QOS_DISABLE) {
2364 fcport->cfg.qos_enabled = BFA_FALSE;
2365 fcport->cfg.qos_bw.high = BFA_QOS_BW_HIGH;
2366 fcport->cfg.qos_bw.med = BFA_QOS_BW_MED;
2367 fcport->cfg.qos_bw.low = BFA_QOS_BW_LOW;
2368 }
2369 }
2370 }
2371 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2372
2373 return 0;
2374 }
2375
2376 static int
2377 bfad_iocmd_qos_get_attr(struct bfad_s *bfad, void *cmd)
2378 {
2379 struct bfa_bsg_qos_attr_s *iocmd = (struct bfa_bsg_qos_attr_s *)cmd;
2380 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2381 unsigned long flags;
2382
2383 spin_lock_irqsave(&bfad->bfad_lock, flags);
2384 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2385 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2386 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2387 else {
2388 iocmd->attr.state = fcport->qos_attr.state;
2389 iocmd->attr.total_bb_cr =
2390 be32_to_cpu(fcport->qos_attr.total_bb_cr);
2391 iocmd->attr.qos_bw.high = fcport->cfg.qos_bw.high;
2392 iocmd->attr.qos_bw.med = fcport->cfg.qos_bw.med;
2393 iocmd->attr.qos_bw.low = fcport->cfg.qos_bw.low;
2394 iocmd->attr.qos_bw_op = fcport->qos_attr.qos_bw_op;
2395 iocmd->status = BFA_STATUS_OK;
2396 }
2397 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2398
2399 return 0;
2400 }
2401
2402 static int
2403 bfad_iocmd_qos_get_vc_attr(struct bfad_s *bfad, void *cmd)
2404 {
2405 struct bfa_bsg_qos_vc_attr_s *iocmd =
2406 (struct bfa_bsg_qos_vc_attr_s *)cmd;
2407 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2408 struct bfa_qos_vc_attr_s *bfa_vc_attr = &fcport->qos_vc_attr;
2409 unsigned long flags;
2410 u32 i = 0;
2411
2412 spin_lock_irqsave(&bfad->bfad_lock, flags);
2413 iocmd->attr.total_vc_count = be16_to_cpu(bfa_vc_attr->total_vc_count);
2414 iocmd->attr.shared_credit = be16_to_cpu(bfa_vc_attr->shared_credit);
2415 iocmd->attr.elp_opmode_flags =
2416 be32_to_cpu(bfa_vc_attr->elp_opmode_flags);
2417
2418 /* Individual VC info */
2419 while (i < iocmd->attr.total_vc_count) {
2420 iocmd->attr.vc_info[i].vc_credit =
2421 bfa_vc_attr->vc_info[i].vc_credit;
2422 iocmd->attr.vc_info[i].borrow_credit =
2423 bfa_vc_attr->vc_info[i].borrow_credit;
2424 iocmd->attr.vc_info[i].priority =
2425 bfa_vc_attr->vc_info[i].priority;
2426 i++;
2427 }
2428 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2429
2430 iocmd->status = BFA_STATUS_OK;
2431 return 0;
2432 }
2433
2434 static int
2435 bfad_iocmd_qos_get_stats(struct bfad_s *bfad, void *cmd)
2436 {
2437 struct bfa_bsg_fcport_stats_s *iocmd =
2438 (struct bfa_bsg_fcport_stats_s *)cmd;
2439 struct bfad_hal_comp fcomp;
2440 unsigned long flags;
2441 struct bfa_cb_pending_q_s cb_qe;
2442 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2443
2444 init_completion(&fcomp.comp);
2445 bfa_pending_q_init_status(&cb_qe, bfad_hcb_comp, &fcomp, &iocmd->stats);
2446
2447 spin_lock_irqsave(&bfad->bfad_lock, flags);
2448 WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc));
2449 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2450 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2451 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2452 else
2453 iocmd->status = bfa_fcport_get_stats(&bfad->bfa, &cb_qe);
2454 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2455 if (iocmd->status != BFA_STATUS_OK) {
2456 bfa_trc(bfad, iocmd->status);
2457 goto out;
2458 }
2459 wait_for_completion(&fcomp.comp);
2460 iocmd->status = fcomp.status;
2461 out:
2462 return 0;
2463 }
2464
2465 static int
2466 bfad_iocmd_qos_reset_stats(struct bfad_s *bfad, void *cmd)
2467 {
2468 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2469 struct bfad_hal_comp fcomp;
2470 unsigned long flags;
2471 struct bfa_cb_pending_q_s cb_qe;
2472 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2473
2474 init_completion(&fcomp.comp);
2475 bfa_pending_q_init_status(&cb_qe, bfad_hcb_comp, &fcomp, NULL);
2476
2477 spin_lock_irqsave(&bfad->bfad_lock, flags);
2478 WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc));
2479 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2480 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2481 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2482 else
2483 iocmd->status = bfa_fcport_clear_stats(&bfad->bfa, &cb_qe);
2484 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2485 if (iocmd->status != BFA_STATUS_OK) {
2486 bfa_trc(bfad, iocmd->status);
2487 goto out;
2488 }
2489 wait_for_completion(&fcomp.comp);
2490 iocmd->status = fcomp.status;
2491 out:
2492 return 0;
2493 }
2494
2495 static int
2496 bfad_iocmd_vf_get_stats(struct bfad_s *bfad, void *cmd)
2497 {
2498 struct bfa_bsg_vf_stats_s *iocmd =
2499 (struct bfa_bsg_vf_stats_s *)cmd;
2500 struct bfa_fcs_fabric_s *fcs_vf;
2501 unsigned long flags;
2502
2503 spin_lock_irqsave(&bfad->bfad_lock, flags);
2504 fcs_vf = bfa_fcs_vf_lookup(&bfad->bfa_fcs, iocmd->vf_id);
2505 if (fcs_vf == NULL) {
2506 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2507 iocmd->status = BFA_STATUS_UNKNOWN_VFID;
2508 goto out;
2509 }
2510 memcpy((void *)&iocmd->stats, (void *)&fcs_vf->stats,
2511 sizeof(struct bfa_vf_stats_s));
2512 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2513 iocmd->status = BFA_STATUS_OK;
2514 out:
2515 return 0;
2516 }
2517
2518 static int
2519 bfad_iocmd_vf_clr_stats(struct bfad_s *bfad, void *cmd)
2520 {
2521 struct bfa_bsg_vf_reset_stats_s *iocmd =
2522 (struct bfa_bsg_vf_reset_stats_s *)cmd;
2523 struct bfa_fcs_fabric_s *fcs_vf;
2524 unsigned long flags;
2525
2526 spin_lock_irqsave(&bfad->bfad_lock, flags);
2527 fcs_vf = bfa_fcs_vf_lookup(&bfad->bfa_fcs, iocmd->vf_id);
2528 if (fcs_vf == NULL) {
2529 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2530 iocmd->status = BFA_STATUS_UNKNOWN_VFID;
2531 goto out;
2532 }
2533 memset((void *)&fcs_vf->stats, 0, sizeof(struct bfa_vf_stats_s));
2534 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2535 iocmd->status = BFA_STATUS_OK;
2536 out:
2537 return 0;
2538 }
2539
2540 /*
2541 * Set the SCSI device sdev_bflags - sdev_bflags are used by the
2542 * SCSI mid-layer to choose LUN Scanning mode REPORT_LUNS vs. Sequential Scan
2543 *
2544 * Internally iterates over all the ITNIM's part of the im_port & sets the
2545 * sdev_bflags for the scsi_device associated with LUN #0.
2546 */
2547 static void bfad_reset_sdev_bflags(struct bfad_im_port_s *im_port,
2548 int lunmask_cfg)
2549 {
2550 const blist_flags_t scan_flags = BLIST_NOREPORTLUN | BLIST_SPARSELUN;
2551 struct bfad_itnim_s *itnim;
2552 struct scsi_device *sdev;
2553 unsigned long flags;
2554
2555 spin_lock_irqsave(im_port->shost->host_lock, flags);
2556 list_for_each_entry(itnim, &im_port->itnim_mapped_list, list_entry) {
2557 sdev = __scsi_device_lookup(im_port->shost, itnim->channel,
2558 itnim->scsi_tgt_id, 0);
2559 if (sdev) {
2560 if (lunmask_cfg == BFA_TRUE)
2561 sdev->sdev_bflags |= scan_flags;
2562 else
2563 sdev->sdev_bflags &= ~scan_flags;
2564 }
2565 }
2566 spin_unlock_irqrestore(im_port->shost->host_lock, flags);
2567 }
2568
2569 /* Function to reset the LUN SCAN mode */
2570 static void
2571 bfad_iocmd_lunmask_reset_lunscan_mode(struct bfad_s *bfad, int lunmask_cfg)
2572 {
2573 struct bfad_im_port_s *pport_im = bfad->pport.im_port;
2574 struct bfad_vport_s *vport = NULL;
2575
2576 /* Set the scsi device LUN SCAN flags for base port */
2577 bfad_reset_sdev_bflags(pport_im, lunmask_cfg);
2578
2579 /* Set the scsi device LUN SCAN flags for the vports */
2580 list_for_each_entry(vport, &bfad->vport_list, list_entry)
2581 bfad_reset_sdev_bflags(vport->drv_port.im_port, lunmask_cfg);
2582 }
2583
2584 static int
2585 bfad_iocmd_lunmask(struct bfad_s *bfad, void *pcmd, unsigned int v_cmd)
2586 {
2587 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
2588 unsigned long flags;
2589
2590 spin_lock_irqsave(&bfad->bfad_lock, flags);
2591 if (v_cmd == IOCMD_FCPIM_LUNMASK_ENABLE) {
2592 iocmd->status = bfa_fcpim_lunmask_update(&bfad->bfa, BFA_TRUE);
2593 /* Set the LUN Scanning mode to be Sequential scan */
2594 if (iocmd->status == BFA_STATUS_OK)
2595 bfad_iocmd_lunmask_reset_lunscan_mode(bfad, BFA_TRUE);
2596 } else if (v_cmd == IOCMD_FCPIM_LUNMASK_DISABLE) {
2597 iocmd->status = bfa_fcpim_lunmask_update(&bfad->bfa, BFA_FALSE);
2598 /* Set the LUN Scanning mode to default REPORT_LUNS scan */
2599 if (iocmd->status == BFA_STATUS_OK)
2600 bfad_iocmd_lunmask_reset_lunscan_mode(bfad, BFA_FALSE);
2601 } else if (v_cmd == IOCMD_FCPIM_LUNMASK_CLEAR)
2602 iocmd->status = bfa_fcpim_lunmask_clear(&bfad->bfa);
2603 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2604 return 0;
2605 }
2606
2607 static int
2608 bfad_iocmd_fcpim_lunmask_query(struct bfad_s *bfad, void *cmd)
2609 {
2610 struct bfa_bsg_fcpim_lunmask_query_s *iocmd =
2611 (struct bfa_bsg_fcpim_lunmask_query_s *)cmd;
2612 struct bfa_lunmask_cfg_s *lun_mask = &iocmd->lun_mask;
2613 unsigned long flags;
2614
2615 spin_lock_irqsave(&bfad->bfad_lock, flags);
2616 iocmd->status = bfa_fcpim_lunmask_query(&bfad->bfa, lun_mask);
2617 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2618 return 0;
2619 }
2620
2621 static int
2622 bfad_iocmd_fcpim_cfg_lunmask(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2623 {
2624 struct bfa_bsg_fcpim_lunmask_s *iocmd =
2625 (struct bfa_bsg_fcpim_lunmask_s *)cmd;
2626 unsigned long flags;
2627
2628 spin_lock_irqsave(&bfad->bfad_lock, flags);
2629 if (v_cmd == IOCMD_FCPIM_LUNMASK_ADD)
2630 iocmd->status = bfa_fcpim_lunmask_add(&bfad->bfa, iocmd->vf_id,
2631 &iocmd->pwwn, iocmd->rpwwn, iocmd->lun);
2632 else if (v_cmd == IOCMD_FCPIM_LUNMASK_DELETE)
2633 iocmd->status = bfa_fcpim_lunmask_delete(&bfad->bfa,
2634 iocmd->vf_id, &iocmd->pwwn,
2635 iocmd->rpwwn, iocmd->lun);
2636 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2637 return 0;
2638 }
2639
2640 static int
2641 bfad_iocmd_fcpim_throttle_query(struct bfad_s *bfad, void *cmd)
2642 {
2643 struct bfa_bsg_fcpim_throttle_s *iocmd =
2644 (struct bfa_bsg_fcpim_throttle_s *)cmd;
2645 unsigned long flags;
2646
2647 spin_lock_irqsave(&bfad->bfad_lock, flags);
2648 iocmd->status = bfa_fcpim_throttle_get(&bfad->bfa,
2649 (void *)&iocmd->throttle);
2650 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2651
2652 return 0;
2653 }
2654
2655 static int
2656 bfad_iocmd_fcpim_throttle_set(struct bfad_s *bfad, void *cmd)
2657 {
2658 struct bfa_bsg_fcpim_throttle_s *iocmd =
2659 (struct bfa_bsg_fcpim_throttle_s *)cmd;
2660 unsigned long flags;
2661
2662 spin_lock_irqsave(&bfad->bfad_lock, flags);
2663 iocmd->status = bfa_fcpim_throttle_set(&bfad->bfa,
2664 iocmd->throttle.cfg_value);
2665 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2666
2667 return 0;
2668 }
2669
2670 static int
2671 bfad_iocmd_tfru_read(struct bfad_s *bfad, void *cmd)
2672 {
2673 struct bfa_bsg_tfru_s *iocmd =
2674 (struct bfa_bsg_tfru_s *)cmd;
2675 struct bfad_hal_comp fcomp;
2676 unsigned long flags = 0;
2677
2678 init_completion(&fcomp.comp);
2679 spin_lock_irqsave(&bfad->bfad_lock, flags);
2680 iocmd->status = bfa_tfru_read(BFA_FRU(&bfad->bfa),
2681 &iocmd->data, iocmd->len, iocmd->offset,
2682 bfad_hcb_comp, &fcomp);
2683 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2684 if (iocmd->status == BFA_STATUS_OK) {
2685 wait_for_completion(&fcomp.comp);
2686 iocmd->status = fcomp.status;
2687 }
2688
2689 return 0;
2690 }
2691
2692 static int
2693 bfad_iocmd_tfru_write(struct bfad_s *bfad, void *cmd)
2694 {
2695 struct bfa_bsg_tfru_s *iocmd =
2696 (struct bfa_bsg_tfru_s *)cmd;
2697 struct bfad_hal_comp fcomp;
2698 unsigned long flags = 0;
2699
2700 init_completion(&fcomp.comp);
2701 spin_lock_irqsave(&bfad->bfad_lock, flags);
2702 iocmd->status = bfa_tfru_write(BFA_FRU(&bfad->bfa),
2703 &iocmd->data, iocmd->len, iocmd->offset,
2704 bfad_hcb_comp, &fcomp);
2705 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2706 if (iocmd->status == BFA_STATUS_OK) {
2707 wait_for_completion(&fcomp.comp);
2708 iocmd->status = fcomp.status;
2709 }
2710
2711 return 0;
2712 }
2713
2714 static int
2715 bfad_iocmd_fruvpd_read(struct bfad_s *bfad, void *cmd)
2716 {
2717 struct bfa_bsg_fruvpd_s *iocmd =
2718 (struct bfa_bsg_fruvpd_s *)cmd;
2719 struct bfad_hal_comp fcomp;
2720 unsigned long flags = 0;
2721
2722 init_completion(&fcomp.comp);
2723 spin_lock_irqsave(&bfad->bfad_lock, flags);
2724 iocmd->status = bfa_fruvpd_read(BFA_FRU(&bfad->bfa),
2725 &iocmd->data, iocmd->len, iocmd->offset,
2726 bfad_hcb_comp, &fcomp);
2727 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2728 if (iocmd->status == BFA_STATUS_OK) {
2729 wait_for_completion(&fcomp.comp);
2730 iocmd->status = fcomp.status;
2731 }
2732
2733 return 0;
2734 }
2735
2736 static int
2737 bfad_iocmd_fruvpd_update(struct bfad_s *bfad, void *cmd)
2738 {
2739 struct bfa_bsg_fruvpd_s *iocmd =
2740 (struct bfa_bsg_fruvpd_s *)cmd;
2741 struct bfad_hal_comp fcomp;
2742 unsigned long flags = 0;
2743
2744 init_completion(&fcomp.comp);
2745 spin_lock_irqsave(&bfad->bfad_lock, flags);
2746 iocmd->status = bfa_fruvpd_update(BFA_FRU(&bfad->bfa),
2747 &iocmd->data, iocmd->len, iocmd->offset,
2748 bfad_hcb_comp, &fcomp, iocmd->trfr_cmpl);
2749 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2750 if (iocmd->status == BFA_STATUS_OK) {
2751 wait_for_completion(&fcomp.comp);
2752 iocmd->status = fcomp.status;
2753 }
2754
2755 return 0;
2756 }
2757
2758 static int
2759 bfad_iocmd_fruvpd_get_max_size(struct bfad_s *bfad, void *cmd)
2760 {
2761 struct bfa_bsg_fruvpd_max_size_s *iocmd =
2762 (struct bfa_bsg_fruvpd_max_size_s *)cmd;
2763 unsigned long flags = 0;
2764
2765 spin_lock_irqsave(&bfad->bfad_lock, flags);
2766 iocmd->status = bfa_fruvpd_get_max_size(BFA_FRU(&bfad->bfa),
2767 &iocmd->max_size);
2768 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2769
2770 return 0;
2771 }
2772
2773 static int
2774 bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
2775 unsigned int payload_len)
2776 {
2777 int rc = -EINVAL;
2778
2779 switch (cmd) {
2780 case IOCMD_IOC_ENABLE:
2781 rc = bfad_iocmd_ioc_enable(bfad, iocmd);
2782 break;
2783 case IOCMD_IOC_DISABLE:
2784 rc = bfad_iocmd_ioc_disable(bfad, iocmd);
2785 break;
2786 case IOCMD_IOC_GET_INFO:
2787 rc = bfad_iocmd_ioc_get_info(bfad, iocmd);
2788 break;
2789 case IOCMD_IOC_GET_ATTR:
2790 rc = bfad_iocmd_ioc_get_attr(bfad, iocmd);
2791 break;
2792 case IOCMD_IOC_GET_STATS:
2793 rc = bfad_iocmd_ioc_get_stats(bfad, iocmd);
2794 break;
2795 case IOCMD_IOC_GET_FWSTATS:
2796 rc = bfad_iocmd_ioc_get_fwstats(bfad, iocmd, payload_len);
2797 break;
2798 case IOCMD_IOC_RESET_STATS:
2799 case IOCMD_IOC_RESET_FWSTATS:
2800 rc = bfad_iocmd_ioc_reset_stats(bfad, iocmd, cmd);
2801 break;
2802 case IOCMD_IOC_SET_ADAPTER_NAME:
2803 case IOCMD_IOC_SET_PORT_NAME:
2804 rc = bfad_iocmd_ioc_set_name(bfad, iocmd, cmd);
2805 break;
2806 case IOCMD_IOCFC_GET_ATTR:
2807 rc = bfad_iocmd_iocfc_get_attr(bfad, iocmd);
2808 break;
2809 case IOCMD_IOCFC_SET_INTR:
2810 rc = bfad_iocmd_iocfc_set_intr(bfad, iocmd);
2811 break;
2812 case IOCMD_PORT_ENABLE:
2813 rc = bfad_iocmd_port_enable(bfad, iocmd);
2814 break;
2815 case IOCMD_PORT_DISABLE:
2816 rc = bfad_iocmd_port_disable(bfad, iocmd);
2817 break;
2818 case IOCMD_PORT_GET_ATTR:
2819 rc = bfad_iocmd_port_get_attr(bfad, iocmd);
2820 break;
2821 case IOCMD_PORT_GET_STATS:
2822 rc = bfad_iocmd_port_get_stats(bfad, iocmd, payload_len);
2823 break;
2824 case IOCMD_PORT_RESET_STATS:
2825 rc = bfad_iocmd_port_reset_stats(bfad, iocmd);
2826 break;
2827 case IOCMD_PORT_CFG_TOPO:
2828 case IOCMD_PORT_CFG_SPEED:
2829 case IOCMD_PORT_CFG_ALPA:
2830 case IOCMD_PORT_CLR_ALPA:
2831 rc = bfad_iocmd_set_port_cfg(bfad, iocmd, cmd);
2832 break;
2833 case IOCMD_PORT_CFG_MAXFRSZ:
2834 rc = bfad_iocmd_port_cfg_maxfrsize(bfad, iocmd);
2835 break;
2836 case IOCMD_PORT_BBCR_ENABLE:
2837 case IOCMD_PORT_BBCR_DISABLE:
2838 rc = bfad_iocmd_port_cfg_bbcr(bfad, cmd, iocmd);
2839 break;
2840 case IOCMD_PORT_BBCR_GET_ATTR:
2841 rc = bfad_iocmd_port_get_bbcr_attr(bfad, iocmd);
2842 break;
2843 case IOCMD_LPORT_GET_ATTR:
2844 rc = bfad_iocmd_lport_get_attr(bfad, iocmd);
2845 break;
2846 case IOCMD_LPORT_GET_STATS:
2847 rc = bfad_iocmd_lport_get_stats(bfad, iocmd);
2848 break;
2849 case IOCMD_LPORT_RESET_STATS:
2850 rc = bfad_iocmd_lport_reset_stats(bfad, iocmd);
2851 break;
2852 case IOCMD_LPORT_GET_IOSTATS:
2853 rc = bfad_iocmd_lport_get_iostats(bfad, iocmd);
2854 break;
2855 case IOCMD_LPORT_GET_RPORTS:
2856 rc = bfad_iocmd_lport_get_rports(bfad, iocmd, payload_len);
2857 break;
2858 case IOCMD_RPORT_GET_ATTR:
2859 rc = bfad_iocmd_rport_get_attr(bfad, iocmd);
2860 break;
2861 case IOCMD_RPORT_GET_ADDR:
2862 rc = bfad_iocmd_rport_get_addr(bfad, iocmd);
2863 break;
2864 case IOCMD_RPORT_GET_STATS:
2865 rc = bfad_iocmd_rport_get_stats(bfad, iocmd);
2866 break;
2867 case IOCMD_RPORT_RESET_STATS:
2868 rc = bfad_iocmd_rport_clr_stats(bfad, iocmd);
2869 break;
2870 case IOCMD_RPORT_SET_SPEED:
2871 rc = bfad_iocmd_rport_set_speed(bfad, iocmd);
2872 break;
2873 case IOCMD_VPORT_GET_ATTR:
2874 rc = bfad_iocmd_vport_get_attr(bfad, iocmd);
2875 break;
2876 case IOCMD_VPORT_GET_STATS:
2877 rc = bfad_iocmd_vport_get_stats(bfad, iocmd);
2878 break;
2879 case IOCMD_VPORT_RESET_STATS:
2880 rc = bfad_iocmd_vport_clr_stats(bfad, iocmd);
2881 break;
2882 case IOCMD_FABRIC_GET_LPORTS:
2883 rc = bfad_iocmd_fabric_get_lports(bfad, iocmd, payload_len);
2884 break;
2885 case IOCMD_RATELIM_ENABLE:
2886 case IOCMD_RATELIM_DISABLE:
2887 rc = bfad_iocmd_ratelim(bfad, cmd, iocmd);
2888 break;
2889 case IOCMD_RATELIM_DEF_SPEED:
2890 rc = bfad_iocmd_ratelim_speed(bfad, cmd, iocmd);
2891 break;
2892 case IOCMD_FCPIM_FAILOVER:
2893 rc = bfad_iocmd_cfg_fcpim(bfad, iocmd);
2894 break;
2895 case IOCMD_FCPIM_MODSTATS:
2896 rc = bfad_iocmd_fcpim_get_modstats(bfad, iocmd);
2897 break;
2898 case IOCMD_FCPIM_MODSTATSCLR:
2899 rc = bfad_iocmd_fcpim_clr_modstats(bfad, iocmd);
2900 break;
2901 case IOCMD_FCPIM_DEL_ITN_STATS:
2902 rc = bfad_iocmd_fcpim_get_del_itn_stats(bfad, iocmd);
2903 break;
2904 case IOCMD_ITNIM_GET_ATTR:
2905 rc = bfad_iocmd_itnim_get_attr(bfad, iocmd);
2906 break;
2907 case IOCMD_ITNIM_GET_IOSTATS:
2908 rc = bfad_iocmd_itnim_get_iostats(bfad, iocmd);
2909 break;
2910 case IOCMD_ITNIM_RESET_STATS:
2911 rc = bfad_iocmd_itnim_reset_stats(bfad, iocmd);
2912 break;
2913 case IOCMD_ITNIM_GET_ITNSTATS:
2914 rc = bfad_iocmd_itnim_get_itnstats(bfad, iocmd);
2915 break;
2916 case IOCMD_FCPORT_ENABLE:
2917 rc = bfad_iocmd_fcport_enable(bfad, iocmd);
2918 break;
2919 case IOCMD_FCPORT_DISABLE:
2920 rc = bfad_iocmd_fcport_disable(bfad, iocmd);
2921 break;
2922 case IOCMD_IOC_PCIFN_CFG:
2923 rc = bfad_iocmd_ioc_get_pcifn_cfg(bfad, iocmd);
2924 break;
2925 case IOCMD_IOC_FW_SIG_INV:
2926 rc = bfad_iocmd_ioc_fw_sig_inv(bfad, iocmd);
2927 break;
2928 case IOCMD_PCIFN_CREATE:
2929 rc = bfad_iocmd_pcifn_create(bfad, iocmd);
2930 break;
2931 case IOCMD_PCIFN_DELETE:
2932 rc = bfad_iocmd_pcifn_delete(bfad, iocmd);
2933 break;
2934 case IOCMD_PCIFN_BW:
2935 rc = bfad_iocmd_pcifn_bw(bfad, iocmd);
2936 break;
2937 case IOCMD_ADAPTER_CFG_MODE:
2938 rc = bfad_iocmd_adapter_cfg_mode(bfad, iocmd);
2939 break;
2940 case IOCMD_PORT_CFG_MODE:
2941 rc = bfad_iocmd_port_cfg_mode(bfad, iocmd);
2942 break;
2943 case IOCMD_FLASH_ENABLE_OPTROM:
2944 case IOCMD_FLASH_DISABLE_OPTROM:
2945 rc = bfad_iocmd_ablk_optrom(bfad, cmd, iocmd);
2946 break;
2947 case IOCMD_FAA_QUERY:
2948 rc = bfad_iocmd_faa_query(bfad, iocmd);
2949 break;
2950 case IOCMD_CEE_GET_ATTR:
2951 rc = bfad_iocmd_cee_attr(bfad, iocmd, payload_len);
2952 break;
2953 case IOCMD_CEE_GET_STATS:
2954 rc = bfad_iocmd_cee_get_stats(bfad, iocmd, payload_len);
2955 break;
2956 case IOCMD_CEE_RESET_STATS:
2957 rc = bfad_iocmd_cee_reset_stats(bfad, iocmd);
2958 break;
2959 case IOCMD_SFP_MEDIA:
2960 rc = bfad_iocmd_sfp_media(bfad, iocmd);
2961 break;
2962 case IOCMD_SFP_SPEED:
2963 rc = bfad_iocmd_sfp_speed(bfad, iocmd);
2964 break;
2965 case IOCMD_FLASH_GET_ATTR:
2966 rc = bfad_iocmd_flash_get_attr(bfad, iocmd);
2967 break;
2968 case IOCMD_FLASH_ERASE_PART:
2969 rc = bfad_iocmd_flash_erase_part(bfad, iocmd);
2970 break;
2971 case IOCMD_FLASH_UPDATE_PART:
2972 rc = bfad_iocmd_flash_update_part(bfad, iocmd, payload_len);
2973 break;
2974 case IOCMD_FLASH_READ_PART:
2975 rc = bfad_iocmd_flash_read_part(bfad, iocmd, payload_len);
2976 break;
2977 case IOCMD_DIAG_TEMP:
2978 rc = bfad_iocmd_diag_temp(bfad, iocmd);
2979 break;
2980 case IOCMD_DIAG_MEMTEST:
2981 rc = bfad_iocmd_diag_memtest(bfad, iocmd);
2982 break;
2983 case IOCMD_DIAG_LOOPBACK:
2984 rc = bfad_iocmd_diag_loopback(bfad, iocmd);
2985 break;
2986 case IOCMD_DIAG_FWPING:
2987 rc = bfad_iocmd_diag_fwping(bfad, iocmd);
2988 break;
2989 case IOCMD_DIAG_QUEUETEST:
2990 rc = bfad_iocmd_diag_queuetest(bfad, iocmd);
2991 break;
2992 case IOCMD_DIAG_SFP:
2993 rc = bfad_iocmd_diag_sfp(bfad, iocmd);
2994 break;
2995 case IOCMD_DIAG_LED:
2996 rc = bfad_iocmd_diag_led(bfad, iocmd);
2997 break;
2998 case IOCMD_DIAG_BEACON_LPORT:
2999 rc = bfad_iocmd_diag_beacon_lport(bfad, iocmd);
3000 break;
3001 case IOCMD_DIAG_LB_STAT:
3002 rc = bfad_iocmd_diag_lb_stat(bfad, iocmd);
3003 break;
3004 case IOCMD_DIAG_DPORT_ENABLE:
3005 rc = bfad_iocmd_diag_dport_enable(bfad, iocmd);
3006 break;
3007 case IOCMD_DIAG_DPORT_DISABLE:
3008 rc = bfad_iocmd_diag_dport_disable(bfad, iocmd);
3009 break;
3010 case IOCMD_DIAG_DPORT_SHOW:
3011 rc = bfad_iocmd_diag_dport_show(bfad, iocmd);
3012 break;
3013 case IOCMD_DIAG_DPORT_START:
3014 rc = bfad_iocmd_diag_dport_start(bfad, iocmd);
3015 break;
3016 case IOCMD_PHY_GET_ATTR:
3017 rc = bfad_iocmd_phy_get_attr(bfad, iocmd);
3018 break;
3019 case IOCMD_PHY_GET_STATS:
3020 rc = bfad_iocmd_phy_get_stats(bfad, iocmd);
3021 break;
3022 case IOCMD_PHY_UPDATE_FW:
3023 rc = bfad_iocmd_phy_update(bfad, iocmd, payload_len);
3024 break;
3025 case IOCMD_PHY_READ_FW:
3026 rc = bfad_iocmd_phy_read(bfad, iocmd, payload_len);
3027 break;
3028 case IOCMD_VHBA_QUERY:
3029 rc = bfad_iocmd_vhba_query(bfad, iocmd);
3030 break;
3031 case IOCMD_DEBUG_PORTLOG:
3032 rc = bfad_iocmd_porglog_get(bfad, iocmd);
3033 break;
3034 case IOCMD_DEBUG_FW_CORE:
3035 rc = bfad_iocmd_debug_fw_core(bfad, iocmd, payload_len);
3036 break;
3037 case IOCMD_DEBUG_FW_STATE_CLR:
3038 case IOCMD_DEBUG_PORTLOG_CLR:
3039 case IOCMD_DEBUG_START_DTRC:
3040 case IOCMD_DEBUG_STOP_DTRC:
3041 rc = bfad_iocmd_debug_ctl(bfad, iocmd, cmd);
3042 break;
3043 case IOCMD_DEBUG_PORTLOG_CTL:
3044 rc = bfad_iocmd_porglog_ctl(bfad, iocmd);
3045 break;
3046 case IOCMD_FCPIM_PROFILE_ON:
3047 case IOCMD_FCPIM_PROFILE_OFF:
3048 rc = bfad_iocmd_fcpim_cfg_profile(bfad, iocmd, cmd);
3049 break;
3050 case IOCMD_ITNIM_GET_IOPROFILE:
3051 rc = bfad_iocmd_itnim_get_ioprofile(bfad, iocmd);
3052 break;
3053 case IOCMD_FCPORT_GET_STATS:
3054 rc = bfad_iocmd_fcport_get_stats(bfad, iocmd);
3055 break;
3056 case IOCMD_FCPORT_RESET_STATS:
3057 rc = bfad_iocmd_fcport_reset_stats(bfad, iocmd);
3058 break;
3059 case IOCMD_BOOT_CFG:
3060 rc = bfad_iocmd_boot_cfg(bfad, iocmd);
3061 break;
3062 case IOCMD_BOOT_QUERY:
3063 rc = bfad_iocmd_boot_query(bfad, iocmd);
3064 break;
3065 case IOCMD_PREBOOT_QUERY:
3066 rc = bfad_iocmd_preboot_query(bfad, iocmd);
3067 break;
3068 case IOCMD_ETHBOOT_CFG:
3069 rc = bfad_iocmd_ethboot_cfg(bfad, iocmd);
3070 break;
3071 case IOCMD_ETHBOOT_QUERY:
3072 rc = bfad_iocmd_ethboot_query(bfad, iocmd);
3073 break;
3074 case IOCMD_TRUNK_ENABLE:
3075 case IOCMD_TRUNK_DISABLE:
3076 rc = bfad_iocmd_cfg_trunk(bfad, iocmd, cmd);
3077 break;
3078 case IOCMD_TRUNK_GET_ATTR:
3079 rc = bfad_iocmd_trunk_get_attr(bfad, iocmd);
3080 break;
3081 case IOCMD_QOS_ENABLE:
3082 case IOCMD_QOS_DISABLE:
3083 rc = bfad_iocmd_qos(bfad, iocmd, cmd);
3084 break;
3085 case IOCMD_QOS_GET_ATTR:
3086 rc = bfad_iocmd_qos_get_attr(bfad, iocmd);
3087 break;
3088 case IOCMD_QOS_GET_VC_ATTR:
3089 rc = bfad_iocmd_qos_get_vc_attr(bfad, iocmd);
3090 break;
3091 case IOCMD_QOS_GET_STATS:
3092 rc = bfad_iocmd_qos_get_stats(bfad, iocmd);
3093 break;
3094 case IOCMD_QOS_RESET_STATS:
3095 rc = bfad_iocmd_qos_reset_stats(bfad, iocmd);
3096 break;
3097 case IOCMD_QOS_SET_BW:
3098 rc = bfad_iocmd_qos_set_bw(bfad, iocmd);
3099 break;
3100 case IOCMD_VF_GET_STATS:
3101 rc = bfad_iocmd_vf_get_stats(bfad, iocmd);
3102 break;
3103 case IOCMD_VF_RESET_STATS:
3104 rc = bfad_iocmd_vf_clr_stats(bfad, iocmd);
3105 break;
3106 case IOCMD_FCPIM_LUNMASK_ENABLE:
3107 case IOCMD_FCPIM_LUNMASK_DISABLE:
3108 case IOCMD_FCPIM_LUNMASK_CLEAR:
3109 rc = bfad_iocmd_lunmask(bfad, iocmd, cmd);
3110 break;
3111 case IOCMD_FCPIM_LUNMASK_QUERY:
3112 rc = bfad_iocmd_fcpim_lunmask_query(bfad, iocmd);
3113 break;
3114 case IOCMD_FCPIM_LUNMASK_ADD:
3115 case IOCMD_FCPIM_LUNMASK_DELETE:
3116 rc = bfad_iocmd_fcpim_cfg_lunmask(bfad, iocmd, cmd);
3117 break;
3118 case IOCMD_FCPIM_THROTTLE_QUERY:
3119 rc = bfad_iocmd_fcpim_throttle_query(bfad, iocmd);
3120 break;
3121 case IOCMD_FCPIM_THROTTLE_SET:
3122 rc = bfad_iocmd_fcpim_throttle_set(bfad, iocmd);
3123 break;
3124 /* TFRU */
3125 case IOCMD_TFRU_READ:
3126 rc = bfad_iocmd_tfru_read(bfad, iocmd);
3127 break;
3128 case IOCMD_TFRU_WRITE:
3129 rc = bfad_iocmd_tfru_write(bfad, iocmd);
3130 break;
3131 /* FRU */
3132 case IOCMD_FRUVPD_READ:
3133 rc = bfad_iocmd_fruvpd_read(bfad, iocmd);
3134 break;
3135 case IOCMD_FRUVPD_UPDATE:
3136 rc = bfad_iocmd_fruvpd_update(bfad, iocmd);
3137 break;
3138 case IOCMD_FRUVPD_GET_MAX_SIZE:
3139 rc = bfad_iocmd_fruvpd_get_max_size(bfad, iocmd);
3140 break;
3141 default:
3142 rc = -EINVAL;
3143 break;
3144 }
3145 return rc;
3146 }
3147
3148 static int
3149 bfad_im_bsg_vendor_request(struct bsg_job *job)
3150 {
3151 struct fc_bsg_request *bsg_request = job->request;
3152 struct fc_bsg_reply *bsg_reply = job->reply;
3153 uint32_t vendor_cmd = bsg_request->rqst_data.h_vendor.vendor_cmd[0];
3154 struct Scsi_Host *shost = fc_bsg_to_shost(job);
3155 struct bfad_im_port_s *im_port = bfad_get_im_port(shost);
3156 struct bfad_s *bfad = im_port->bfad;
3157 void *payload_kbuf;
3158 int rc = -EINVAL;
3159
3160 /* Allocate a temp buffer to hold the passed in user space command */
3161 payload_kbuf = kzalloc(job->request_payload.payload_len, GFP_KERNEL);
3162 if (!payload_kbuf) {
3163 rc = -ENOMEM;
3164 goto out;
3165 }
3166
3167 /* Copy the sg_list passed in to a linear buffer: holds the cmnd data */
3168 sg_copy_to_buffer(job->request_payload.sg_list,
3169 job->request_payload.sg_cnt, payload_kbuf,
3170 job->request_payload.payload_len);
3171
3172 /* Invoke IOCMD handler - to handle all the vendor command requests */
3173 rc = bfad_iocmd_handler(bfad, vendor_cmd, payload_kbuf,
3174 job->request_payload.payload_len);
3175 if (rc != BFA_STATUS_OK)
3176 goto error;
3177
3178 /* Copy the response data to the job->reply_payload sg_list */
3179 sg_copy_from_buffer(job->reply_payload.sg_list,
3180 job->reply_payload.sg_cnt,
3181 payload_kbuf,
3182 job->reply_payload.payload_len);
3183
3184 /* free the command buffer */
3185 kfree(payload_kbuf);
3186
3187 /* Fill the BSG job reply data */
3188 job->reply_len = job->reply_payload.payload_len;
3189 bsg_reply->reply_payload_rcv_len = job->reply_payload.payload_len;
3190 bsg_reply->result = rc;
3191
3192 bsg_job_done(job, bsg_reply->result,
3193 bsg_reply->reply_payload_rcv_len);
3194 return rc;
3195 error:
3196 /* free the command buffer */
3197 kfree(payload_kbuf);
3198 out:
3199 bsg_reply->result = rc;
3200 job->reply_len = sizeof(uint32_t);
3201 bsg_reply->reply_payload_rcv_len = 0;
3202 return rc;
3203 }
3204
3205 /* FC passthru call backs */
3206 static u64
3207 bfad_fcxp_get_req_sgaddr_cb(void *bfad_fcxp, int sgeid)
3208 {
3209 struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3210 struct bfa_sge_s *sge;
3211 u64 addr;
3212
3213 sge = drv_fcxp->req_sge + sgeid;
3214 addr = (u64)(size_t) sge->sg_addr;
3215 return addr;
3216 }
3217
3218 static u32
3219 bfad_fcxp_get_req_sglen_cb(void *bfad_fcxp, int sgeid)
3220 {
3221 struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3222 struct bfa_sge_s *sge;
3223
3224 sge = drv_fcxp->req_sge + sgeid;
3225 return sge->sg_len;
3226 }
3227
3228 static u64
3229 bfad_fcxp_get_rsp_sgaddr_cb(void *bfad_fcxp, int sgeid)
3230 {
3231 struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3232 struct bfa_sge_s *sge;
3233 u64 addr;
3234
3235 sge = drv_fcxp->rsp_sge + sgeid;
3236 addr = (u64)(size_t) sge->sg_addr;
3237 return addr;
3238 }
3239
3240 static u32
3241 bfad_fcxp_get_rsp_sglen_cb(void *bfad_fcxp, int sgeid)
3242 {
3243 struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3244 struct bfa_sge_s *sge;
3245
3246 sge = drv_fcxp->rsp_sge + sgeid;
3247 return sge->sg_len;
3248 }
3249
3250 static void
3251 bfad_send_fcpt_cb(void *bfad_fcxp, struct bfa_fcxp_s *fcxp, void *cbarg,
3252 bfa_status_t req_status, u32 rsp_len, u32 resid_len,
3253 struct fchs_s *rsp_fchs)
3254 {
3255 struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3256
3257 drv_fcxp->req_status = req_status;
3258 drv_fcxp->rsp_len = rsp_len;
3259
3260 /* bfa_fcxp will be automatically freed by BFA */
3261 drv_fcxp->bfa_fcxp = NULL;
3262 complete(&drv_fcxp->comp);
3263 }
3264
3265 static struct bfad_buf_info *
3266 bfad_fcxp_map_sg(struct bfad_s *bfad, void *payload_kbuf,
3267 uint32_t payload_len, uint32_t *num_sgles)
3268 {
3269 struct bfad_buf_info *buf_base, *buf_info;
3270 struct bfa_sge_s *sg_table;
3271 int sge_num = 1;
3272
3273 buf_base = kcalloc(sizeof(struct bfad_buf_info) +
3274 sizeof(struct bfa_sge_s),
3275 sge_num, GFP_KERNEL);
3276 if (!buf_base)
3277 return NULL;
3278
3279 sg_table = (struct bfa_sge_s *) (((uint8_t *)buf_base) +
3280 (sizeof(struct bfad_buf_info) * sge_num));
3281
3282 /* Allocate dma coherent memory */
3283 buf_info = buf_base;
3284 buf_info->size = payload_len;
3285 buf_info->virt = dma_alloc_coherent(&bfad->pcidev->dev,
3286 buf_info->size, &buf_info->phys,
3287 GFP_KERNEL);
3288 if (!buf_info->virt)
3289 goto out_free_mem;
3290
3291 /* copy the linear bsg buffer to buf_info */
3292 memcpy(buf_info->virt, payload_kbuf, buf_info->size);
3293
3294 /*
3295 * Setup SG table
3296 */
3297 sg_table->sg_len = buf_info->size;
3298 sg_table->sg_addr = (void *)(size_t) buf_info->phys;
3299
3300 *num_sgles = sge_num;
3301
3302 return buf_base;
3303
3304 out_free_mem:
3305 kfree(buf_base);
3306 return NULL;
3307 }
3308
3309 static void
3310 bfad_fcxp_free_mem(struct bfad_s *bfad, struct bfad_buf_info *buf_base,
3311 uint32_t num_sgles)
3312 {
3313 int i;
3314 struct bfad_buf_info *buf_info = buf_base;
3315
3316 if (buf_base) {
3317 for (i = 0; i < num_sgles; buf_info++, i++) {
3318 if (buf_info->virt != NULL)
3319 dma_free_coherent(&bfad->pcidev->dev,
3320 buf_info->size, buf_info->virt,
3321 buf_info->phys);
3322 }
3323 kfree(buf_base);
3324 }
3325 }
3326
3327 static int
3328 bfad_fcxp_bsg_send(struct bsg_job *job, struct bfad_fcxp *drv_fcxp,
3329 bfa_bsg_fcpt_t *bsg_fcpt)
3330 {
3331 struct bfa_fcxp_s *hal_fcxp;
3332 struct bfad_s *bfad = drv_fcxp->port->bfad;
3333 unsigned long flags;
3334 uint8_t lp_tag;
3335
3336 spin_lock_irqsave(&bfad->bfad_lock, flags);
3337
3338 /* Allocate bfa_fcxp structure */
3339 hal_fcxp = bfa_fcxp_req_rsp_alloc(drv_fcxp, &bfad->bfa,
3340 drv_fcxp->num_req_sgles,
3341 drv_fcxp->num_rsp_sgles,
3342 bfad_fcxp_get_req_sgaddr_cb,
3343 bfad_fcxp_get_req_sglen_cb,
3344 bfad_fcxp_get_rsp_sgaddr_cb,
3345 bfad_fcxp_get_rsp_sglen_cb, BFA_TRUE);
3346 if (!hal_fcxp) {
3347 bfa_trc(bfad, 0);
3348 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3349 return BFA_STATUS_ENOMEM;
3350 }
3351
3352 drv_fcxp->bfa_fcxp = hal_fcxp;
3353
3354 lp_tag = bfa_lps_get_tag_from_pid(&bfad->bfa, bsg_fcpt->fchs.s_id);
3355
3356 bfa_fcxp_send(hal_fcxp, drv_fcxp->bfa_rport, bsg_fcpt->vf_id, lp_tag,
3357 bsg_fcpt->cts, bsg_fcpt->cos,
3358 job->request_payload.payload_len,
3359 &bsg_fcpt->fchs, bfad_send_fcpt_cb, bfad,
3360 job->reply_payload.payload_len, bsg_fcpt->tsecs);
3361
3362 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3363
3364 return BFA_STATUS_OK;
3365 }
3366
3367 static int
3368 bfad_im_bsg_els_ct_request(struct bsg_job *job)
3369 {
3370 struct bfa_bsg_data *bsg_data;
3371 struct Scsi_Host *shost = fc_bsg_to_shost(job);
3372 struct bfad_im_port_s *im_port = bfad_get_im_port(shost);
3373 struct bfad_s *bfad = im_port->bfad;
3374 bfa_bsg_fcpt_t *bsg_fcpt;
3375 struct bfad_fcxp *drv_fcxp;
3376 struct bfa_fcs_lport_s *fcs_port;
3377 struct bfa_fcs_rport_s *fcs_rport;
3378 struct fc_bsg_request *bsg_request = job->request;
3379 struct fc_bsg_reply *bsg_reply = job->reply;
3380 uint32_t command_type = bsg_request->msgcode;
3381 unsigned long flags;
3382 struct bfad_buf_info *rsp_buf_info;
3383 void *req_kbuf = NULL, *rsp_kbuf = NULL;
3384 int rc = -EINVAL;
3385
3386 job->reply_len = sizeof(uint32_t); /* Atleast uint32_t reply_len */
3387 bsg_reply->reply_payload_rcv_len = 0;
3388
3389 /* Get the payload passed in from userspace */
3390 bsg_data = (struct bfa_bsg_data *) (((char *)bsg_request) +
3391 sizeof(struct fc_bsg_request));
3392 if (bsg_data == NULL)
3393 goto out;
3394
3395 /*
3396 * Allocate buffer for bsg_fcpt and do a copy_from_user op for payload
3397 * buffer of size bsg_data->payload_len
3398 */
3399 bsg_fcpt = kzalloc(bsg_data->payload_len, GFP_KERNEL);
3400 if (!bsg_fcpt) {
3401 rc = -ENOMEM;
3402 goto out;
3403 }
3404
3405 if (copy_from_user((uint8_t *)bsg_fcpt,
3406 (void *)(unsigned long)bsg_data->payload,
3407 bsg_data->payload_len)) {
3408 kfree(bsg_fcpt);
3409 rc = -EIO;
3410 goto out;
3411 }
3412
3413 drv_fcxp = kzalloc(sizeof(struct bfad_fcxp), GFP_KERNEL);
3414 if (drv_fcxp == NULL) {
3415 kfree(bsg_fcpt);
3416 rc = -ENOMEM;
3417 goto out;
3418 }
3419
3420 spin_lock_irqsave(&bfad->bfad_lock, flags);
3421 fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs, bsg_fcpt->vf_id,
3422 bsg_fcpt->lpwwn);
3423 if (fcs_port == NULL) {
3424 bsg_fcpt->status = BFA_STATUS_UNKNOWN_LWWN;
3425 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3426 goto out_free_mem;
3427 }
3428
3429 /* Check if the port is online before sending FC Passthru cmd */
3430 if (!bfa_fcs_lport_is_online(fcs_port)) {
3431 bsg_fcpt->status = BFA_STATUS_PORT_OFFLINE;
3432 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3433 goto out_free_mem;
3434 }
3435
3436 drv_fcxp->port = fcs_port->bfad_port;
3437
3438 if (!drv_fcxp->port->bfad)
3439 drv_fcxp->port->bfad = bfad;
3440
3441 /* Fetch the bfa_rport - if nexus needed */
3442 if (command_type == FC_BSG_HST_ELS_NOLOGIN ||
3443 command_type == FC_BSG_HST_CT) {
3444 /* BSG HST commands: no nexus needed */
3445 drv_fcxp->bfa_rport = NULL;
3446
3447 } else if (command_type == FC_BSG_RPT_ELS ||
3448 command_type == FC_BSG_RPT_CT) {
3449 /* BSG RPT commands: nexus needed */
3450 fcs_rport = bfa_fcs_lport_get_rport_by_pwwn(fcs_port,
3451 bsg_fcpt->dpwwn);
3452 if (fcs_rport == NULL) {
3453 bsg_fcpt->status = BFA_STATUS_UNKNOWN_RWWN;
3454 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3455 goto out_free_mem;
3456 }
3457
3458 drv_fcxp->bfa_rport = fcs_rport->bfa_rport;
3459
3460 } else { /* Unknown BSG msgcode; return -EINVAL */
3461 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3462 goto out_free_mem;
3463 }
3464
3465 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3466
3467 /* allocate memory for req / rsp buffers */
3468 req_kbuf = kzalloc(job->request_payload.payload_len, GFP_KERNEL);
3469 if (!req_kbuf) {
3470 printk(KERN_INFO "bfa %s: fcpt request buffer alloc failed\n",
3471 bfad->pci_name);
3472 rc = -ENOMEM;
3473 goto out_free_mem;
3474 }
3475
3476 rsp_kbuf = kzalloc(job->reply_payload.payload_len, GFP_KERNEL);
3477 if (!rsp_kbuf) {
3478 printk(KERN_INFO "bfa %s: fcpt response buffer alloc failed\n",
3479 bfad->pci_name);
3480 rc = -ENOMEM;
3481 goto out_free_mem;
3482 }
3483
3484 /* map req sg - copy the sg_list passed in to the linear buffer */
3485 sg_copy_to_buffer(job->request_payload.sg_list,
3486 job->request_payload.sg_cnt, req_kbuf,
3487 job->request_payload.payload_len);
3488
3489 drv_fcxp->reqbuf_info = bfad_fcxp_map_sg(bfad, req_kbuf,
3490 job->request_payload.payload_len,
3491 &drv_fcxp->num_req_sgles);
3492 if (!drv_fcxp->reqbuf_info) {
3493 printk(KERN_INFO "bfa %s: fcpt request fcxp_map_sg failed\n",
3494 bfad->pci_name);
3495 rc = -ENOMEM;
3496 goto out_free_mem;
3497 }
3498
3499 drv_fcxp->req_sge = (struct bfa_sge_s *)
3500 (((uint8_t *)drv_fcxp->reqbuf_info) +
3501 (sizeof(struct bfad_buf_info) *
3502 drv_fcxp->num_req_sgles));
3503
3504 /* map rsp sg */
3505 drv_fcxp->rspbuf_info = bfad_fcxp_map_sg(bfad, rsp_kbuf,
3506 job->reply_payload.payload_len,
3507 &drv_fcxp->num_rsp_sgles);
3508 if (!drv_fcxp->rspbuf_info) {
3509 printk(KERN_INFO "bfa %s: fcpt response fcxp_map_sg failed\n",
3510 bfad->pci_name);
3511 rc = -ENOMEM;
3512 goto out_free_mem;
3513 }
3514
3515 rsp_buf_info = (struct bfad_buf_info *)drv_fcxp->rspbuf_info;
3516 drv_fcxp->rsp_sge = (struct bfa_sge_s *)
3517 (((uint8_t *)drv_fcxp->rspbuf_info) +
3518 (sizeof(struct bfad_buf_info) *
3519 drv_fcxp->num_rsp_sgles));
3520
3521 /* fcxp send */
3522 init_completion(&drv_fcxp->comp);
3523 rc = bfad_fcxp_bsg_send(job, drv_fcxp, bsg_fcpt);
3524 if (rc == BFA_STATUS_OK) {
3525 wait_for_completion(&drv_fcxp->comp);
3526 bsg_fcpt->status = drv_fcxp->req_status;
3527 } else {
3528 bsg_fcpt->status = rc;
3529 goto out_free_mem;
3530 }
3531
3532 /* fill the job->reply data */
3533 if (drv_fcxp->req_status == BFA_STATUS_OK) {
3534 job->reply_len = drv_fcxp->rsp_len;
3535 bsg_reply->reply_payload_rcv_len = drv_fcxp->rsp_len;
3536 bsg_reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
3537 } else {
3538 bsg_reply->reply_payload_rcv_len =
3539 sizeof(struct fc_bsg_ctels_reply);
3540 job->reply_len = sizeof(uint32_t);
3541 bsg_reply->reply_data.ctels_reply.status =
3542 FC_CTELS_STATUS_REJECT;
3543 }
3544
3545 /* Copy the response data to the reply_payload sg list */
3546 sg_copy_from_buffer(job->reply_payload.sg_list,
3547 job->reply_payload.sg_cnt,
3548 (uint8_t *)rsp_buf_info->virt,
3549 job->reply_payload.payload_len);
3550
3551 out_free_mem:
3552 bfad_fcxp_free_mem(bfad, drv_fcxp->rspbuf_info,
3553 drv_fcxp->num_rsp_sgles);
3554 bfad_fcxp_free_mem(bfad, drv_fcxp->reqbuf_info,
3555 drv_fcxp->num_req_sgles);
3556 kfree(req_kbuf);
3557 kfree(rsp_kbuf);
3558
3559 /* Need a copy to user op */
3560 if (copy_to_user((void *)(unsigned long)bsg_data->payload,
3561 (void *)bsg_fcpt, bsg_data->payload_len))
3562 rc = -EIO;
3563
3564 kfree(bsg_fcpt);
3565 kfree(drv_fcxp);
3566 out:
3567 bsg_reply->result = rc;
3568
3569 if (rc == BFA_STATUS_OK)
3570 bsg_job_done(job, bsg_reply->result,
3571 bsg_reply->reply_payload_rcv_len);
3572
3573 return rc;
3574 }
3575
3576 int
3577 bfad_im_bsg_request(struct bsg_job *job)
3578 {
3579 struct fc_bsg_request *bsg_request = job->request;
3580 struct fc_bsg_reply *bsg_reply = job->reply;
3581 uint32_t rc = BFA_STATUS_OK;
3582
3583 switch (bsg_request->msgcode) {
3584 case FC_BSG_HST_VENDOR:
3585 /* Process BSG HST Vendor requests */
3586 rc = bfad_im_bsg_vendor_request(job);
3587 break;
3588 case FC_BSG_HST_ELS_NOLOGIN:
3589 case FC_BSG_RPT_ELS:
3590 case FC_BSG_HST_CT:
3591 case FC_BSG_RPT_CT:
3592 /* Process BSG ELS/CT commands */
3593 rc = bfad_im_bsg_els_ct_request(job);
3594 break;
3595 default:
3596 bsg_reply->result = rc = -EINVAL;
3597 bsg_reply->reply_payload_rcv_len = 0;
3598 break;
3599 }
3600
3601 return rc;
3602 }
3603
3604 int
3605 bfad_im_bsg_timeout(struct bsg_job *job)
3606 {
3607 /* Don't complete the BSG job request - return -EAGAIN
3608 * to reset bsg job timeout : for ELS/CT pass thru we
3609 * already have timer to track the request.
3610 */
3611 return -EAGAIN;
3612 }
Kernel DRM miscellaneous fixes and cross-tree changes