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