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