?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SCSI] bfa: remove unused and empty functions
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / scsi / bfa / bfa_svc.c
blob3a2bee4d42ddef7c92753c1dbd524216887b63ff
1 /*
2 * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
3 * All rights reserved
4 * www.brocade.com
5 *
6 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License (GPL) Version 2 as
10 * published by the Free Software Foundation
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 */
17
18 #include "bfa_os_inc.h"
19 #include "bfa_plog.h"
20 #include "bfa_cs.h"
21 #include "bfa_modules.h"
22 #include "bfad_drv.h"
23
24 BFA_TRC_FILE(HAL, FCXP);
25 BFA_MODULE(fcxp);
26 BFA_MODULE(sgpg);
27 BFA_MODULE(lps);
28 BFA_MODULE(fcport);
29 BFA_MODULE(rport);
30 BFA_MODULE(uf);
31
32 /*
33 * LPS related definitions
34 */
35 #define BFA_LPS_MIN_LPORTS (1)
36 #define BFA_LPS_MAX_LPORTS (256)
37
38 /*
39 * Maximum Vports supported per physical port or vf.
40 */
41 #define BFA_LPS_MAX_VPORTS_SUPP_CB 255
42 #define BFA_LPS_MAX_VPORTS_SUPP_CT 190
43
44 /*
45 * lps_pvt BFA LPS private functions
46 */
47
48 enum bfa_lps_event {
49 BFA_LPS_SM_LOGIN = 1, /* login request from user */
50 BFA_LPS_SM_LOGOUT = 2, /* logout request from user */
51 BFA_LPS_SM_FWRSP = 3, /* f/w response to login/logout */
52 BFA_LPS_SM_RESUME = 4, /* space present in reqq queue */
53 BFA_LPS_SM_DELETE = 5, /* lps delete from user */
54 BFA_LPS_SM_OFFLINE = 6, /* Link is offline */
55 BFA_LPS_SM_RX_CVL = 7, /* Rx clear virtual link */
56 };
57
58 /*
59 * FC PORT related definitions
60 */
61 /*
62 * The port is considered disabled if corresponding physical port or IOC are
63 * disabled explicitly
64 */
65 #define BFA_PORT_IS_DISABLED(bfa) \
66 ((bfa_fcport_is_disabled(bfa) == BFA_TRUE) || \
67 (bfa_ioc_is_disabled(&bfa->ioc) == BFA_TRUE))
68
69
70 /*
71 * BFA port state machine events
72 */
73 enum bfa_fcport_sm_event {
74 BFA_FCPORT_SM_START = 1, /* start port state machine */
75 BFA_FCPORT_SM_STOP = 2, /* stop port state machine */
76 BFA_FCPORT_SM_ENABLE = 3, /* enable port */
77 BFA_FCPORT_SM_DISABLE = 4, /* disable port state machine */
78 BFA_FCPORT_SM_FWRSP = 5, /* firmware enable/disable rsp */
79 BFA_FCPORT_SM_LINKUP = 6, /* firmware linkup event */
80 BFA_FCPORT_SM_LINKDOWN = 7, /* firmware linkup down */
81 BFA_FCPORT_SM_QRESUME = 8, /* CQ space available */
82 BFA_FCPORT_SM_HWFAIL = 9, /* IOC h/w failure */
83 };
84
85 /*
86 * BFA port link notification state machine events
87 */
88
89 enum bfa_fcport_ln_sm_event {
90 BFA_FCPORT_LN_SM_LINKUP = 1, /* linkup event */
91 BFA_FCPORT_LN_SM_LINKDOWN = 2, /* linkdown event */
92 BFA_FCPORT_LN_SM_NOTIFICATION = 3 /* done notification */
93 };
94
95 /*
96 * RPORT related definitions
97 */
98 #define bfa_rport_offline_cb(__rp) do { \
99 if ((__rp)->bfa->fcs) \
100 bfa_cb_rport_offline((__rp)->rport_drv); \
101 else { \
102 bfa_cb_queue((__rp)->bfa, &(__rp)->hcb_qe, \
103 __bfa_cb_rport_offline, (__rp)); \
104 } \
105 } while (0)
106
107 #define bfa_rport_online_cb(__rp) do { \
108 if ((__rp)->bfa->fcs) \
109 bfa_cb_rport_online((__rp)->rport_drv); \
110 else { \
111 bfa_cb_queue((__rp)->bfa, &(__rp)->hcb_qe, \
112 __bfa_cb_rport_online, (__rp)); \
113 } \
114 } while (0)
115
116
117 enum bfa_rport_event {
118 BFA_RPORT_SM_CREATE = 1, /* rport create event */
119 BFA_RPORT_SM_DELETE = 2, /* deleting an existing rport */
120 BFA_RPORT_SM_ONLINE = 3, /* rport is online */
121 BFA_RPORT_SM_OFFLINE = 4, /* rport is offline */
122 BFA_RPORT_SM_FWRSP = 5, /* firmware response */
123 BFA_RPORT_SM_HWFAIL = 6, /* IOC h/w failure */
124 BFA_RPORT_SM_QOS_SCN = 7, /* QoS SCN from firmware */
125 BFA_RPORT_SM_SET_SPEED = 8, /* Set Rport Speed */
126 BFA_RPORT_SM_QRESUME = 9, /* space in requeue queue */
127 };
128
129 /*
130 * forward declarations FCXP related functions
131 */
132 static void __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete);
133 static void hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
134 struct bfi_fcxp_send_rsp_s *fcxp_rsp);
135 static void hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen,
136 struct bfa_fcxp_s *fcxp, struct fchs_s *fchs);
137 static void bfa_fcxp_qresume(void *cbarg);
138 static void bfa_fcxp_queue(struct bfa_fcxp_s *fcxp,
139 struct bfi_fcxp_send_req_s *send_req);
140
141 /*
142 * forward declarations for LPS functions
143 */
144 static void bfa_lps_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
145 u32 *dm_len);
146 static void bfa_lps_attach(struct bfa_s *bfa, void *bfad,
147 struct bfa_iocfc_cfg_s *cfg,
148 struct bfa_meminfo_s *meminfo,
149 struct bfa_pcidev_s *pcidev);
150 static void bfa_lps_detach(struct bfa_s *bfa);
151 static void bfa_lps_start(struct bfa_s *bfa);
152 static void bfa_lps_stop(struct bfa_s *bfa);
153 static void bfa_lps_iocdisable(struct bfa_s *bfa);
154 static void bfa_lps_login_rsp(struct bfa_s *bfa,
155 struct bfi_lps_login_rsp_s *rsp);
156 static void bfa_lps_logout_rsp(struct bfa_s *bfa,
157 struct bfi_lps_logout_rsp_s *rsp);
158 static void bfa_lps_reqq_resume(void *lps_arg);
159 static void bfa_lps_free(struct bfa_lps_s *lps);
160 static void bfa_lps_send_login(struct bfa_lps_s *lps);
161 static void bfa_lps_send_logout(struct bfa_lps_s *lps);
162 static void bfa_lps_login_comp(struct bfa_lps_s *lps);
163 static void bfa_lps_logout_comp(struct bfa_lps_s *lps);
164 static void bfa_lps_cvl_event(struct bfa_lps_s *lps);
165
166 /*
167 * forward declaration for LPS state machine
168 */
169 static void bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event);
170 static void bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event);
171 static void bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event
172 event);
173 static void bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event);
174 static void bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event);
175 static void bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event
176 event);
177
178 /*
179 * forward declaration for FC Port functions
180 */
181 static bfa_boolean_t bfa_fcport_send_enable(struct bfa_fcport_s *fcport);
182 static bfa_boolean_t bfa_fcport_send_disable(struct bfa_fcport_s *fcport);
183 static void bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport);
184 static void bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport);
185 static void bfa_fcport_set_wwns(struct bfa_fcport_s *fcport);
186 static void __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete);
187 static void bfa_fcport_scn(struct bfa_fcport_s *fcport,
188 enum bfa_port_linkstate event, bfa_boolean_t trunk);
189 static void bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln,
190 enum bfa_port_linkstate event);
191 static void __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete);
192 static void bfa_fcport_stats_get_timeout(void *cbarg);
193 static void bfa_fcport_stats_clr_timeout(void *cbarg);
194 static void bfa_trunk_iocdisable(struct bfa_s *bfa);
195
196 /*
197 * forward declaration for FC PORT state machine
198 */
199 static void bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
200 enum bfa_fcport_sm_event event);
201 static void bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
202 enum bfa_fcport_sm_event event);
203 static void bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
204 enum bfa_fcport_sm_event event);
205 static void bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
206 enum bfa_fcport_sm_event event);
207 static void bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
208 enum bfa_fcport_sm_event event);
209 static void bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
210 enum bfa_fcport_sm_event event);
211 static void bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
212 enum bfa_fcport_sm_event event);
213 static void bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport,
214 enum bfa_fcport_sm_event event);
215 static void bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
216 enum bfa_fcport_sm_event event);
217 static void bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
218 enum bfa_fcport_sm_event event);
219 static void bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
220 enum bfa_fcport_sm_event event);
221 static void bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
222 enum bfa_fcport_sm_event event);
223
224 static void bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
225 enum bfa_fcport_ln_sm_event event);
226 static void bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
227 enum bfa_fcport_ln_sm_event event);
228 static void bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
229 enum bfa_fcport_ln_sm_event event);
230 static void bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
231 enum bfa_fcport_ln_sm_event event);
232 static void bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
233 enum bfa_fcport_ln_sm_event event);
234 static void bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
235 enum bfa_fcport_ln_sm_event event);
236 static void bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
237 enum bfa_fcport_ln_sm_event event);
238
239 static struct bfa_sm_table_s hal_port_sm_table[] = {
240 {BFA_SM(bfa_fcport_sm_uninit), BFA_PORT_ST_UNINIT},
241 {BFA_SM(bfa_fcport_sm_enabling_qwait), BFA_PORT_ST_ENABLING_QWAIT},
242 {BFA_SM(bfa_fcport_sm_enabling), BFA_PORT_ST_ENABLING},
243 {BFA_SM(bfa_fcport_sm_linkdown), BFA_PORT_ST_LINKDOWN},
244 {BFA_SM(bfa_fcport_sm_linkup), BFA_PORT_ST_LINKUP},
245 {BFA_SM(bfa_fcport_sm_disabling_qwait), BFA_PORT_ST_DISABLING_QWAIT},
246 {BFA_SM(bfa_fcport_sm_toggling_qwait), BFA_PORT_ST_TOGGLING_QWAIT},
247 {BFA_SM(bfa_fcport_sm_disabling), BFA_PORT_ST_DISABLING},
248 {BFA_SM(bfa_fcport_sm_disabled), BFA_PORT_ST_DISABLED},
249 {BFA_SM(bfa_fcport_sm_stopped), BFA_PORT_ST_STOPPED},
250 {BFA_SM(bfa_fcport_sm_iocdown), BFA_PORT_ST_IOCDOWN},
251 {BFA_SM(bfa_fcport_sm_iocfail), BFA_PORT_ST_IOCDOWN},
252 };
253
254
255 /*
256 * forward declaration for RPORT related functions
257 */
258 static struct bfa_rport_s *bfa_rport_alloc(struct bfa_rport_mod_s *rp_mod);
259 static void bfa_rport_free(struct bfa_rport_s *rport);
260 static bfa_boolean_t bfa_rport_send_fwcreate(struct bfa_rport_s *rp);
261 static bfa_boolean_t bfa_rport_send_fwdelete(struct bfa_rport_s *rp);
262 static bfa_boolean_t bfa_rport_send_fwspeed(struct bfa_rport_s *rp);
263 static void __bfa_cb_rport_online(void *cbarg,
264 bfa_boolean_t complete);
265 static void __bfa_cb_rport_offline(void *cbarg,
266 bfa_boolean_t complete);
267
268 /*
269 * forward declaration for RPORT state machine
270 */
271 static void bfa_rport_sm_uninit(struct bfa_rport_s *rp,
272 enum bfa_rport_event event);
273 static void bfa_rport_sm_created(struct bfa_rport_s *rp,
274 enum bfa_rport_event event);
275 static void bfa_rport_sm_fwcreate(struct bfa_rport_s *rp,
276 enum bfa_rport_event event);
277 static void bfa_rport_sm_online(struct bfa_rport_s *rp,
278 enum bfa_rport_event event);
279 static void bfa_rport_sm_fwdelete(struct bfa_rport_s *rp,
280 enum bfa_rport_event event);
281 static void bfa_rport_sm_offline(struct bfa_rport_s *rp,
282 enum bfa_rport_event event);
283 static void bfa_rport_sm_deleting(struct bfa_rport_s *rp,
284 enum bfa_rport_event event);
285 static void bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
286 enum bfa_rport_event event);
287 static void bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
288 enum bfa_rport_event event);
289 static void bfa_rport_sm_iocdisable(struct bfa_rport_s *rp,
290 enum bfa_rport_event event);
291 static void bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp,
292 enum bfa_rport_event event);
293 static void bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp,
294 enum bfa_rport_event event);
295 static void bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp,
296 enum bfa_rport_event event);
297
298 /*
299 * PLOG related definitions
300 */
301 static int
302 plkd_validate_logrec(struct bfa_plog_rec_s *pl_rec)
303 {
304 if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT) &&
305 (pl_rec->log_type != BFA_PL_LOG_TYPE_STRING))
306 return 1;
307
308 if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT) &&
309 (pl_rec->log_num_ints > BFA_PL_INT_LOG_SZ))
310 return 1;
311
312 return 0;
313 }
314
315 static void
316 bfa_plog_add(struct bfa_plog_s *plog, struct bfa_plog_rec_s *pl_rec)
317 {
318 u16 tail;
319 struct bfa_plog_rec_s *pl_recp;
320
321 if (plog->plog_enabled == 0)
322 return;
323
324 if (plkd_validate_logrec(pl_rec)) {
325 bfa_assert(0);
326 return;
327 }
328
329 tail = plog->tail;
330
331 pl_recp = &(plog->plog_recs[tail]);
332
333 memcpy(pl_recp, pl_rec, sizeof(struct bfa_plog_rec_s));
334
335 pl_recp->tv = bfa_os_get_log_time();
336 BFA_PL_LOG_REC_INCR(plog->tail);
337
338 if (plog->head == plog->tail)
339 BFA_PL_LOG_REC_INCR(plog->head);
340 }
341
342 void
343 bfa_plog_init(struct bfa_plog_s *plog)
344 {
345 memset((char *)plog, 0, sizeof(struct bfa_plog_s));
346
347 memcpy(plog->plog_sig, BFA_PL_SIG_STR, BFA_PL_SIG_LEN);
348 plog->head = plog->tail = 0;
349 plog->plog_enabled = 1;
350 }
351
352 void
353 bfa_plog_str(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
354 enum bfa_plog_eid event,
355 u16 misc, char *log_str)
356 {
357 struct bfa_plog_rec_s lp;
358
359 if (plog->plog_enabled) {
360 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
361 lp.mid = mid;
362 lp.eid = event;
363 lp.log_type = BFA_PL_LOG_TYPE_STRING;
364 lp.misc = misc;
365 strncpy(lp.log_entry.string_log, log_str,
366 BFA_PL_STRING_LOG_SZ - 1);
367 lp.log_entry.string_log[BFA_PL_STRING_LOG_SZ - 1] = '\0';
368 bfa_plog_add(plog, &lp);
369 }
370 }
371
372 void
373 bfa_plog_intarr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
374 enum bfa_plog_eid event,
375 u16 misc, u32 *intarr, u32 num_ints)
376 {
377 struct bfa_plog_rec_s lp;
378 u32 i;
379
380 if (num_ints > BFA_PL_INT_LOG_SZ)
381 num_ints = BFA_PL_INT_LOG_SZ;
382
383 if (plog->plog_enabled) {
384 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
385 lp.mid = mid;
386 lp.eid = event;
387 lp.log_type = BFA_PL_LOG_TYPE_INT;
388 lp.misc = misc;
389
390 for (i = 0; i < num_ints; i++)
391 lp.log_entry.int_log[i] = intarr[i];
392
393 lp.log_num_ints = (u8) num_ints;
394
395 bfa_plog_add(plog, &lp);
396 }
397 }
398
399 void
400 bfa_plog_fchdr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
401 enum bfa_plog_eid event,
402 u16 misc, struct fchs_s *fchdr)
403 {
404 struct bfa_plog_rec_s lp;
405 u32 *tmp_int = (u32 *) fchdr;
406 u32 ints[BFA_PL_INT_LOG_SZ];
407
408 if (plog->plog_enabled) {
409 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
410
411 ints[0] = tmp_int[0];
412 ints[1] = tmp_int[1];
413 ints[2] = tmp_int[4];
414
415 bfa_plog_intarr(plog, mid, event, misc, ints, 3);
416 }
417 }
418
419 void
420 bfa_plog_fchdr_and_pl(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
421 enum bfa_plog_eid event, u16 misc, struct fchs_s *fchdr,
422 u32 pld_w0)
423 {
424 struct bfa_plog_rec_s lp;
425 u32 *tmp_int = (u32 *) fchdr;
426 u32 ints[BFA_PL_INT_LOG_SZ];
427
428 if (plog->plog_enabled) {
429 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
430
431 ints[0] = tmp_int[0];
432 ints[1] = tmp_int[1];
433 ints[2] = tmp_int[4];
434 ints[3] = pld_w0;
435
436 bfa_plog_intarr(plog, mid, event, misc, ints, 4);
437 }
438 }
439
440
441 bfa_boolean_t
442 bfa_plog_get_setting(struct bfa_plog_s *plog)
443 {
444 return (bfa_boolean_t)plog->plog_enabled;
445 }
446
447 /*
448 * fcxp_pvt BFA FCXP private functions
449 */
450
451 static void
452 claim_fcxp_req_rsp_mem(struct bfa_fcxp_mod_s *mod, struct bfa_meminfo_s *mi)
453 {
454 u8 *dm_kva = NULL;
455 u64 dm_pa;
456 u32 buf_pool_sz;
457
458 dm_kva = bfa_meminfo_dma_virt(mi);
459 dm_pa = bfa_meminfo_dma_phys(mi);
460
461 buf_pool_sz = mod->req_pld_sz * mod->num_fcxps;
462
463 /*
464 * Initialize the fcxp req payload list
465 */
466 mod->req_pld_list_kva = dm_kva;
467 mod->req_pld_list_pa = dm_pa;
468 dm_kva += buf_pool_sz;
469 dm_pa += buf_pool_sz;
470 memset(mod->req_pld_list_kva, 0, buf_pool_sz);
471
472 /*
473 * Initialize the fcxp rsp payload list
474 */
475 buf_pool_sz = mod->rsp_pld_sz * mod->num_fcxps;
476 mod->rsp_pld_list_kva = dm_kva;
477 mod->rsp_pld_list_pa = dm_pa;
478 dm_kva += buf_pool_sz;
479 dm_pa += buf_pool_sz;
480 memset(mod->rsp_pld_list_kva, 0, buf_pool_sz);
481
482 bfa_meminfo_dma_virt(mi) = dm_kva;
483 bfa_meminfo_dma_phys(mi) = dm_pa;
484 }
485
486 static void
487 claim_fcxps_mem(struct bfa_fcxp_mod_s *mod, struct bfa_meminfo_s *mi)
488 {
489 u16 i;
490 struct bfa_fcxp_s *fcxp;
491
492 fcxp = (struct bfa_fcxp_s *) bfa_meminfo_kva(mi);
493 memset(fcxp, 0, sizeof(struct bfa_fcxp_s) * mod->num_fcxps);
494
495 INIT_LIST_HEAD(&mod->fcxp_free_q);
496 INIT_LIST_HEAD(&mod->fcxp_active_q);
497
498 mod->fcxp_list = fcxp;
499
500 for (i = 0; i < mod->num_fcxps; i++) {
501 fcxp->fcxp_mod = mod;
502 fcxp->fcxp_tag = i;
503
504 list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
505 bfa_reqq_winit(&fcxp->reqq_wqe, bfa_fcxp_qresume, fcxp);
506 fcxp->reqq_waiting = BFA_FALSE;
507
508 fcxp = fcxp + 1;
509 }
510
511 bfa_meminfo_kva(mi) = (void *)fcxp;
512 }
513
514 static void
515 bfa_fcxp_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
516 u32 *dm_len)
517 {
518 u16 num_fcxp_reqs = cfg->fwcfg.num_fcxp_reqs;
519
520 if (num_fcxp_reqs == 0)
521 return;
522
523 /*
524 * Account for req/rsp payload
525 */
526 *dm_len += BFA_FCXP_MAX_IBUF_SZ * num_fcxp_reqs;
527 if (cfg->drvcfg.min_cfg)
528 *dm_len += BFA_FCXP_MAX_IBUF_SZ * num_fcxp_reqs;
529 else
530 *dm_len += BFA_FCXP_MAX_LBUF_SZ * num_fcxp_reqs;
531
532 /*
533 * Account for fcxp structs
534 */
535 *ndm_len += sizeof(struct bfa_fcxp_s) * num_fcxp_reqs;
536 }
537
538 static void
539 bfa_fcxp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
540 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
541 {
542 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
543
544 memset(mod, 0, sizeof(struct bfa_fcxp_mod_s));
545 mod->bfa = bfa;
546 mod->num_fcxps = cfg->fwcfg.num_fcxp_reqs;
547
548 /*
549 * Initialize FCXP request and response payload sizes.
550 */
551 mod->req_pld_sz = mod->rsp_pld_sz = BFA_FCXP_MAX_IBUF_SZ;
552 if (!cfg->drvcfg.min_cfg)
553 mod->rsp_pld_sz = BFA_FCXP_MAX_LBUF_SZ;
554
555 INIT_LIST_HEAD(&mod->wait_q);
556
557 claim_fcxp_req_rsp_mem(mod, meminfo);
558 claim_fcxps_mem(mod, meminfo);
559 }
560
561 static void
562 bfa_fcxp_detach(struct bfa_s *bfa)
563 {
564 }
565
566 static void
567 bfa_fcxp_start(struct bfa_s *bfa)
568 {
569 }
570
571 static void
572 bfa_fcxp_stop(struct bfa_s *bfa)
573 {
574 }
575
576 static void
577 bfa_fcxp_iocdisable(struct bfa_s *bfa)
578 {
579 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
580 struct bfa_fcxp_s *fcxp;
581 struct list_head *qe, *qen;
582
583 list_for_each_safe(qe, qen, &mod->fcxp_active_q) {
584 fcxp = (struct bfa_fcxp_s *) qe;
585 if (fcxp->caller == NULL) {
586 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
587 BFA_STATUS_IOC_FAILURE, 0, 0, NULL);
588 bfa_fcxp_free(fcxp);
589 } else {
590 fcxp->rsp_status = BFA_STATUS_IOC_FAILURE;
591 bfa_cb_queue(bfa, &fcxp->hcb_qe,
592 __bfa_fcxp_send_cbfn, fcxp);
593 }
594 }
595 }
596
597 static struct bfa_fcxp_s *
598 bfa_fcxp_get(struct bfa_fcxp_mod_s *fm)
599 {
600 struct bfa_fcxp_s *fcxp;
601
602 bfa_q_deq(&fm->fcxp_free_q, &fcxp);
603
604 if (fcxp)
605 list_add_tail(&fcxp->qe, &fm->fcxp_active_q);
606
607 return fcxp;
608 }
609
610 static void
611 bfa_fcxp_init_reqrsp(struct bfa_fcxp_s *fcxp,
612 struct bfa_s *bfa,
613 u8 *use_ibuf,
614 u32 *nr_sgles,
615 bfa_fcxp_get_sgaddr_t *r_sga_cbfn,
616 bfa_fcxp_get_sglen_t *r_sglen_cbfn,
617 struct list_head *r_sgpg_q,
618 int n_sgles,
619 bfa_fcxp_get_sgaddr_t sga_cbfn,
620 bfa_fcxp_get_sglen_t sglen_cbfn)
621 {
622
623 bfa_assert(bfa != NULL);
624
625 bfa_trc(bfa, fcxp->fcxp_tag);
626
627 if (n_sgles == 0) {
628 *use_ibuf = 1;
629 } else {
630 bfa_assert(*sga_cbfn != NULL);
631 bfa_assert(*sglen_cbfn != NULL);
632
633 *use_ibuf = 0;
634 *r_sga_cbfn = sga_cbfn;
635 *r_sglen_cbfn = sglen_cbfn;
636
637 *nr_sgles = n_sgles;
638
639 /*
640 * alloc required sgpgs
641 */
642 if (n_sgles > BFI_SGE_INLINE)
643 bfa_assert(0);
644 }
645
646 }
647
648 static void
649 bfa_fcxp_init(struct bfa_fcxp_s *fcxp,
650 void *caller, struct bfa_s *bfa, int nreq_sgles,
651 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
652 bfa_fcxp_get_sglen_t req_sglen_cbfn,
653 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
654 bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
655 {
656
657 bfa_assert(bfa != NULL);
658
659 bfa_trc(bfa, fcxp->fcxp_tag);
660
661 fcxp->caller = caller;
662
663 bfa_fcxp_init_reqrsp(fcxp, bfa,
664 &fcxp->use_ireqbuf, &fcxp->nreq_sgles, &fcxp->req_sga_cbfn,
665 &fcxp->req_sglen_cbfn, &fcxp->req_sgpg_q,
666 nreq_sgles, req_sga_cbfn, req_sglen_cbfn);
667
668 bfa_fcxp_init_reqrsp(fcxp, bfa,
669 &fcxp->use_irspbuf, &fcxp->nrsp_sgles, &fcxp->rsp_sga_cbfn,
670 &fcxp->rsp_sglen_cbfn, &fcxp->rsp_sgpg_q,
671 nrsp_sgles, rsp_sga_cbfn, rsp_sglen_cbfn);
672
673 }
674
675 static void
676 bfa_fcxp_put(struct bfa_fcxp_s *fcxp)
677 {
678 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
679 struct bfa_fcxp_wqe_s *wqe;
680
681 bfa_q_deq(&mod->wait_q, &wqe);
682 if (wqe) {
683 bfa_trc(mod->bfa, fcxp->fcxp_tag);
684
685 bfa_fcxp_init(fcxp, wqe->caller, wqe->bfa, wqe->nreq_sgles,
686 wqe->nrsp_sgles, wqe->req_sga_cbfn,
687 wqe->req_sglen_cbfn, wqe->rsp_sga_cbfn,
688 wqe->rsp_sglen_cbfn);
689
690 wqe->alloc_cbfn(wqe->alloc_cbarg, fcxp);
691 return;
692 }
693
694 bfa_assert(bfa_q_is_on_q(&mod->fcxp_active_q, fcxp));
695 list_del(&fcxp->qe);
696 list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
697 }
698
699 static void
700 bfa_fcxp_null_comp(void *bfad_fcxp, struct bfa_fcxp_s *fcxp, void *cbarg,
701 bfa_status_t req_status, u32 rsp_len,
702 u32 resid_len, struct fchs_s *rsp_fchs)
703 {
704 /* discarded fcxp completion */
705 }
706
707 static void
708 __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete)
709 {
710 struct bfa_fcxp_s *fcxp = cbarg;
711
712 if (complete) {
713 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
714 fcxp->rsp_status, fcxp->rsp_len,
715 fcxp->residue_len, &fcxp->rsp_fchs);
716 } else {
717 bfa_fcxp_free(fcxp);
718 }
719 }
720
721 static void
722 hal_fcxp_send_comp(struct bfa_s *bfa, struct bfi_fcxp_send_rsp_s *fcxp_rsp)
723 {
724 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
725 struct bfa_fcxp_s *fcxp;
726 u16 fcxp_tag = be16_to_cpu(fcxp_rsp->fcxp_tag);
727
728 bfa_trc(bfa, fcxp_tag);
729
730 fcxp_rsp->rsp_len = be32_to_cpu(fcxp_rsp->rsp_len);
731
732 /*
733 * @todo f/w should not set residue to non-0 when everything
734 * is received.
735 */
736 if (fcxp_rsp->req_status == BFA_STATUS_OK)
737 fcxp_rsp->residue_len = 0;
738 else
739 fcxp_rsp->residue_len = be32_to_cpu(fcxp_rsp->residue_len);
740
741 fcxp = BFA_FCXP_FROM_TAG(mod, fcxp_tag);
742
743 bfa_assert(fcxp->send_cbfn != NULL);
744
745 hal_fcxp_rx_plog(mod->bfa, fcxp, fcxp_rsp);
746
747 if (fcxp->send_cbfn != NULL) {
748 bfa_trc(mod->bfa, (NULL == fcxp->caller));
749 if (fcxp->caller == NULL) {
750 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
751 fcxp_rsp->req_status, fcxp_rsp->rsp_len,
752 fcxp_rsp->residue_len, &fcxp_rsp->fchs);
753 /*
754 * fcxp automatically freed on return from the callback
755 */
756 bfa_fcxp_free(fcxp);
757 } else {
758 fcxp->rsp_status = fcxp_rsp->req_status;
759 fcxp->rsp_len = fcxp_rsp->rsp_len;
760 fcxp->residue_len = fcxp_rsp->residue_len;
761 fcxp->rsp_fchs = fcxp_rsp->fchs;
762
763 bfa_cb_queue(bfa, &fcxp->hcb_qe,
764 __bfa_fcxp_send_cbfn, fcxp);
765 }
766 } else {
767 bfa_trc(bfa, (NULL == fcxp->send_cbfn));
768 }
769 }
770
771 static void
772 hal_fcxp_set_local_sges(struct bfi_sge_s *sge, u32 reqlen, u64 req_pa)
773 {
774 union bfi_addr_u sga_zero = { {0} };
775
776 sge->sg_len = reqlen;
777 sge->flags = BFI_SGE_DATA_LAST;
778 bfa_dma_addr_set(sge[0].sga, req_pa);
779 bfa_sge_to_be(sge);
780 sge++;
781
782 sge->sga = sga_zero;
783 sge->sg_len = reqlen;
784 sge->flags = BFI_SGE_PGDLEN;
785 bfa_sge_to_be(sge);
786 }
787
788 static void
789 hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen, struct bfa_fcxp_s *fcxp,
790 struct fchs_s *fchs)
791 {
792 /*
793 * TODO: TX ox_id
794 */
795 if (reqlen > 0) {
796 if (fcxp->use_ireqbuf) {
797 u32 pld_w0 =
798 *((u32 *) BFA_FCXP_REQ_PLD(fcxp));
799
800 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP,
801 BFA_PL_EID_TX,
802 reqlen + sizeof(struct fchs_s), fchs,
803 pld_w0);
804 } else {
805 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
806 BFA_PL_EID_TX,
807 reqlen + sizeof(struct fchs_s),
808 fchs);
809 }
810 } else {
811 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_TX,
812 reqlen + sizeof(struct fchs_s), fchs);
813 }
814 }
815
816 static void
817 hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
818 struct bfi_fcxp_send_rsp_s *fcxp_rsp)
819 {
820 if (fcxp_rsp->rsp_len > 0) {
821 if (fcxp->use_irspbuf) {
822 u32 pld_w0 =
823 *((u32 *) BFA_FCXP_RSP_PLD(fcxp));
824
825 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP,
826 BFA_PL_EID_RX,
827 (u16) fcxp_rsp->rsp_len,
828 &fcxp_rsp->fchs, pld_w0);
829 } else {
830 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
831 BFA_PL_EID_RX,
832 (u16) fcxp_rsp->rsp_len,
833 &fcxp_rsp->fchs);
834 }
835 } else {
836 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_RX,
837 (u16) fcxp_rsp->rsp_len, &fcxp_rsp->fchs);
838 }
839 }
840
841 /*
842 * Handler to resume sending fcxp when space in available in cpe queue.
843 */
844 static void
845 bfa_fcxp_qresume(void *cbarg)
846 {
847 struct bfa_fcxp_s *fcxp = cbarg;
848 struct bfa_s *bfa = fcxp->fcxp_mod->bfa;
849 struct bfi_fcxp_send_req_s *send_req;
850
851 fcxp->reqq_waiting = BFA_FALSE;
852 send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP);
853 bfa_fcxp_queue(fcxp, send_req);
854 }
855
856 /*
857 * Queue fcxp send request to foimrware.
858 */
859 static void
860 bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, struct bfi_fcxp_send_req_s *send_req)
861 {
862 struct bfa_s *bfa = fcxp->fcxp_mod->bfa;
863 struct bfa_fcxp_req_info_s *reqi = &fcxp->req_info;
864 struct bfa_fcxp_rsp_info_s *rspi = &fcxp->rsp_info;
865 struct bfa_rport_s *rport = reqi->bfa_rport;
866
867 bfi_h2i_set(send_req->mh, BFI_MC_FCXP, BFI_FCXP_H2I_SEND_REQ,
868 bfa_lpuid(bfa));
869
870 send_req->fcxp_tag = cpu_to_be16(fcxp->fcxp_tag);
871 if (rport) {
872 send_req->rport_fw_hndl = rport->fw_handle;
873 send_req->max_frmsz = cpu_to_be16(rport->rport_info.max_frmsz);
874 if (send_req->max_frmsz == 0)
875 send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ);
876 } else {
877 send_req->rport_fw_hndl = 0;
878 send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ);
879 }
880
881 send_req->vf_id = cpu_to_be16(reqi->vf_id);
882 send_req->lp_tag = reqi->lp_tag;
883 send_req->class = reqi->class;
884 send_req->rsp_timeout = rspi->rsp_timeout;
885 send_req->cts = reqi->cts;
886 send_req->fchs = reqi->fchs;
887
888 send_req->req_len = cpu_to_be32(reqi->req_tot_len);
889 send_req->rsp_maxlen = cpu_to_be32(rspi->rsp_maxlen);
890
891 /*
892 * setup req sgles
893 */
894 if (fcxp->use_ireqbuf == 1) {
895 hal_fcxp_set_local_sges(send_req->req_sge, reqi->req_tot_len,
896 BFA_FCXP_REQ_PLD_PA(fcxp));
897 } else {
898 if (fcxp->nreq_sgles > 0) {
899 bfa_assert(fcxp->nreq_sgles == 1);
900 hal_fcxp_set_local_sges(send_req->req_sge,
901 reqi->req_tot_len,
902 fcxp->req_sga_cbfn(fcxp->caller,
903 0));
904 } else {
905 bfa_assert(reqi->req_tot_len == 0);
906 hal_fcxp_set_local_sges(send_req->rsp_sge, 0, 0);
907 }
908 }
909
910 /*
911 * setup rsp sgles
912 */
913 if (fcxp->use_irspbuf == 1) {
914 bfa_assert(rspi->rsp_maxlen <= BFA_FCXP_MAX_LBUF_SZ);
915
916 hal_fcxp_set_local_sges(send_req->rsp_sge, rspi->rsp_maxlen,
917 BFA_FCXP_RSP_PLD_PA(fcxp));
918
919 } else {
920 if (fcxp->nrsp_sgles > 0) {
921 bfa_assert(fcxp->nrsp_sgles == 1);
922 hal_fcxp_set_local_sges(send_req->rsp_sge,
923 rspi->rsp_maxlen,
924 fcxp->rsp_sga_cbfn(fcxp->caller,
925 0));
926 } else {
927 bfa_assert(rspi->rsp_maxlen == 0);
928 hal_fcxp_set_local_sges(send_req->rsp_sge, 0, 0);
929 }
930 }
931
932 hal_fcxp_tx_plog(bfa, reqi->req_tot_len, fcxp, &reqi->fchs);
933
934 bfa_reqq_produce(bfa, BFA_REQQ_FCXP);
935
936 bfa_trc(bfa, bfa_reqq_pi(bfa, BFA_REQQ_FCXP));
937 bfa_trc(bfa, bfa_reqq_ci(bfa, BFA_REQQ_FCXP));
938 }
939
940 /*
941 * hal_fcxp_api BFA FCXP API
942 */
943
944 /*
945 * Allocate an FCXP instance to send a response or to send a request
946 * that has a response. Request/response buffers are allocated by caller.
947 *
948 * @param[in] bfa BFA bfa instance
949 * @param[in] nreq_sgles Number of SG elements required for request
950 * buffer. 0, if fcxp internal buffers are used.
951 * Use bfa_fcxp_get_reqbuf() to get the
952 * internal req buffer.
953 * @param[in] req_sgles SG elements describing request buffer. Will be
954 * copied in by BFA and hence can be freed on
955 * return from this function.
956 * @param[in] get_req_sga function ptr to be called to get a request SG
957 * Address (given the sge index).
958 * @param[in] get_req_sglen function ptr to be called to get a request SG
959 * len (given the sge index).
960 * @param[in] get_rsp_sga function ptr to be called to get a response SG
961 * Address (given the sge index).
962 * @param[in] get_rsp_sglen function ptr to be called to get a response SG
963 * len (given the sge index).
964 *
965 * @return FCXP instance. NULL on failure.
966 */
967 struct bfa_fcxp_s *
968 bfa_fcxp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
969 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
970 bfa_fcxp_get_sglen_t req_sglen_cbfn,
971 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
972 bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
973 {
974 struct bfa_fcxp_s *fcxp = NULL;
975
976 bfa_assert(bfa != NULL);
977
978 fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa));
979 if (fcxp == NULL)
980 return NULL;
981
982 bfa_trc(bfa, fcxp->fcxp_tag);
983
984 bfa_fcxp_init(fcxp, caller, bfa, nreq_sgles, nrsp_sgles, req_sga_cbfn,
985 req_sglen_cbfn, rsp_sga_cbfn, rsp_sglen_cbfn);
986
987 return fcxp;
988 }
989
990 /*
991 * Get the internal request buffer pointer
992 *
993 * @param[in] fcxp BFA fcxp pointer
994 *
995 * @return pointer to the internal request buffer
996 */
997 void *
998 bfa_fcxp_get_reqbuf(struct bfa_fcxp_s *fcxp)
999 {
1000 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
1001 void *reqbuf;
1002
1003 bfa_assert(fcxp->use_ireqbuf == 1);
1004 reqbuf = ((u8 *)mod->req_pld_list_kva) +
1005 fcxp->fcxp_tag * mod->req_pld_sz;
1006 return reqbuf;
1007 }
1008
1009 u32
1010 bfa_fcxp_get_reqbufsz(struct bfa_fcxp_s *fcxp)
1011 {
1012 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
1013
1014 return mod->req_pld_sz;
1015 }
1016
1017 /*
1018 * Get the internal response buffer pointer
1019 *
1020 * @param[in] fcxp BFA fcxp pointer
1021 *
1022 * @return pointer to the internal request buffer
1023 */
1024 void *
1025 bfa_fcxp_get_rspbuf(struct bfa_fcxp_s *fcxp)
1026 {
1027 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
1028 void *rspbuf;
1029
1030 bfa_assert(fcxp->use_irspbuf == 1);
1031
1032 rspbuf = ((u8 *)mod->rsp_pld_list_kva) +
1033 fcxp->fcxp_tag * mod->rsp_pld_sz;
1034 return rspbuf;
1035 }
1036
1037 /*
1038 * Free the BFA FCXP
1039 *
1040 * @param[in] fcxp BFA fcxp pointer
1041 *
1042 * @return void
1043 */
1044 void
1045 bfa_fcxp_free(struct bfa_fcxp_s *fcxp)
1046 {
1047 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
1048
1049 bfa_assert(fcxp != NULL);
1050 bfa_trc(mod->bfa, fcxp->fcxp_tag);
1051 bfa_fcxp_put(fcxp);
1052 }
1053
1054 /*
1055 * Send a FCXP request
1056 *
1057 * @param[in] fcxp BFA fcxp pointer
1058 * @param[in] rport BFA rport pointer. Could be left NULL for WKA rports
1059 * @param[in] vf_id virtual Fabric ID
1060 * @param[in] lp_tag lport tag
1061 * @param[in] cts use Continous sequence
1062 * @param[in] cos fc Class of Service
1063 * @param[in] reqlen request length, does not include FCHS length
1064 * @param[in] fchs fc Header Pointer. The header content will be copied
1065 * in by BFA.
1066 *
1067 * @param[in] cbfn call back function to be called on receiving
1068 * the response
1069 * @param[in] cbarg arg for cbfn
1070 * @param[in] rsp_timeout
1071 * response timeout
1072 *
1073 * @return bfa_status_t
1074 */
1075 void
1076 bfa_fcxp_send(struct bfa_fcxp_s *fcxp, struct bfa_rport_s *rport,
1077 u16 vf_id, u8 lp_tag, bfa_boolean_t cts, enum fc_cos cos,
1078 u32 reqlen, struct fchs_s *fchs, bfa_cb_fcxp_send_t cbfn,
1079 void *cbarg, u32 rsp_maxlen, u8 rsp_timeout)
1080 {
1081 struct bfa_s *bfa = fcxp->fcxp_mod->bfa;
1082 struct bfa_fcxp_req_info_s *reqi = &fcxp->req_info;
1083 struct bfa_fcxp_rsp_info_s *rspi = &fcxp->rsp_info;
1084 struct bfi_fcxp_send_req_s *send_req;
1085
1086 bfa_trc(bfa, fcxp->fcxp_tag);
1087
1088 /*
1089 * setup request/response info
1090 */
1091 reqi->bfa_rport = rport;
1092 reqi->vf_id = vf_id;
1093 reqi->lp_tag = lp_tag;
1094 reqi->class = cos;
1095 rspi->rsp_timeout = rsp_timeout;
1096 reqi->cts = cts;
1097 reqi->fchs = *fchs;
1098 reqi->req_tot_len = reqlen;
1099 rspi->rsp_maxlen = rsp_maxlen;
1100 fcxp->send_cbfn = cbfn ? cbfn : bfa_fcxp_null_comp;
1101 fcxp->send_cbarg = cbarg;
1102
1103 /*
1104 * If no room in CPE queue, wait for space in request queue
1105 */
1106 send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP);
1107 if (!send_req) {
1108 bfa_trc(bfa, fcxp->fcxp_tag);
1109 fcxp->reqq_waiting = BFA_TRUE;
1110 bfa_reqq_wait(bfa, BFA_REQQ_FCXP, &fcxp->reqq_wqe);
1111 return;
1112 }
1113
1114 bfa_fcxp_queue(fcxp, send_req);
1115 }
1116
1117 /*
1118 * Abort a BFA FCXP
1119 *
1120 * @param[in] fcxp BFA fcxp pointer
1121 *
1122 * @return void
1123 */
1124 bfa_status_t
1125 bfa_fcxp_abort(struct bfa_fcxp_s *fcxp)
1126 {
1127 bfa_trc(fcxp->fcxp_mod->bfa, fcxp->fcxp_tag);
1128 bfa_assert(0);
1129 return BFA_STATUS_OK;
1130 }
1131
1132 void
1133 bfa_fcxp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
1134 bfa_fcxp_alloc_cbfn_t alloc_cbfn, void *alloc_cbarg,
1135 void *caller, int nreq_sgles,
1136 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
1137 bfa_fcxp_get_sglen_t req_sglen_cbfn,
1138 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
1139 bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
1140 {
1141 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1142
1143 bfa_assert(list_empty(&mod->fcxp_free_q));
1144
1145 wqe->alloc_cbfn = alloc_cbfn;
1146 wqe->alloc_cbarg = alloc_cbarg;
1147 wqe->caller = caller;
1148 wqe->bfa = bfa;
1149 wqe->nreq_sgles = nreq_sgles;
1150 wqe->nrsp_sgles = nrsp_sgles;
1151 wqe->req_sga_cbfn = req_sga_cbfn;
1152 wqe->req_sglen_cbfn = req_sglen_cbfn;
1153 wqe->rsp_sga_cbfn = rsp_sga_cbfn;
1154 wqe->rsp_sglen_cbfn = rsp_sglen_cbfn;
1155
1156 list_add_tail(&wqe->qe, &mod->wait_q);
1157 }
1158
1159 void
1160 bfa_fcxp_walloc_cancel(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe)
1161 {
1162 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1163
1164 bfa_assert(bfa_q_is_on_q(&mod->wait_q, wqe));
1165 list_del(&wqe->qe);
1166 }
1167
1168 void
1169 bfa_fcxp_discard(struct bfa_fcxp_s *fcxp)
1170 {
1171 /*
1172 * If waiting for room in request queue, cancel reqq wait
1173 * and free fcxp.
1174 */
1175 if (fcxp->reqq_waiting) {
1176 fcxp->reqq_waiting = BFA_FALSE;
1177 bfa_reqq_wcancel(&fcxp->reqq_wqe);
1178 bfa_fcxp_free(fcxp);
1179 return;
1180 }
1181
1182 fcxp->send_cbfn = bfa_fcxp_null_comp;
1183 }
1184
1185
1186
1187 /*
1188 * hal_fcxp_public BFA FCXP public functions
1189 */
1190
1191 void
1192 bfa_fcxp_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
1193 {
1194 switch (msg->mhdr.msg_id) {
1195 case BFI_FCXP_I2H_SEND_RSP:
1196 hal_fcxp_send_comp(bfa, (struct bfi_fcxp_send_rsp_s *) msg);
1197 break;
1198
1199 default:
1200 bfa_trc(bfa, msg->mhdr.msg_id);
1201 bfa_assert(0);
1202 }
1203 }
1204
1205 u32
1206 bfa_fcxp_get_maxrsp(struct bfa_s *bfa)
1207 {
1208 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1209
1210 return mod->rsp_pld_sz;
1211 }
1212
1213
1214 /*
1215 * BFA LPS state machine functions
1216 */
1217
1218 /*
1219 * Init state -- no login
1220 */
1221 static void
1222 bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event)
1223 {
1224 bfa_trc(lps->bfa, lps->lp_tag);
1225 bfa_trc(lps->bfa, event);
1226
1227 switch (event) {
1228 case BFA_LPS_SM_LOGIN:
1229 if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1230 bfa_sm_set_state(lps, bfa_lps_sm_loginwait);
1231 bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1232 } else {
1233 bfa_sm_set_state(lps, bfa_lps_sm_login);
1234 bfa_lps_send_login(lps);
1235 }
1236
1237 if (lps->fdisc)
1238 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1239 BFA_PL_EID_LOGIN, 0, "FDISC Request");
1240 else
1241 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1242 BFA_PL_EID_LOGIN, 0, "FLOGI Request");
1243 break;
1244
1245 case BFA_LPS_SM_LOGOUT:
1246 bfa_lps_logout_comp(lps);
1247 break;
1248
1249 case BFA_LPS_SM_DELETE:
1250 bfa_lps_free(lps);
1251 break;
1252
1253 case BFA_LPS_SM_RX_CVL:
1254 case BFA_LPS_SM_OFFLINE:
1255 break;
1256
1257 case BFA_LPS_SM_FWRSP:
1258 /*
1259 * Could happen when fabric detects loopback and discards
1260 * the lps request. Fw will eventually sent out the timeout
1261 * Just ignore
1262 */
1263 break;
1264
1265 default:
1266 bfa_sm_fault(lps->bfa, event);
1267 }
1268 }
1269
1270 /*
1271 * login is in progress -- awaiting response from firmware
1272 */
1273 static void
1274 bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
1275 {
1276 bfa_trc(lps->bfa, lps->lp_tag);
1277 bfa_trc(lps->bfa, event);
1278
1279 switch (event) {
1280 case BFA_LPS_SM_FWRSP:
1281 if (lps->status == BFA_STATUS_OK) {
1282 bfa_sm_set_state(lps, bfa_lps_sm_online);
1283 if (lps->fdisc)
1284 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1285 BFA_PL_EID_LOGIN, 0, "FDISC Accept");
1286 else
1287 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1288 BFA_PL_EID_LOGIN, 0, "FLOGI Accept");
1289 } else {
1290 bfa_sm_set_state(lps, bfa_lps_sm_init);
1291 if (lps->fdisc)
1292 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1293 BFA_PL_EID_LOGIN, 0,
1294 "FDISC Fail (RJT or timeout)");
1295 else
1296 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1297 BFA_PL_EID_LOGIN, 0,
1298 "FLOGI Fail (RJT or timeout)");
1299 }
1300 bfa_lps_login_comp(lps);
1301 break;
1302
1303 case BFA_LPS_SM_OFFLINE:
1304 bfa_sm_set_state(lps, bfa_lps_sm_init);
1305 break;
1306
1307 default:
1308 bfa_sm_fault(lps->bfa, event);
1309 }
1310 }
1311
1312 /*
1313 * login pending - awaiting space in request queue
1314 */
1315 static void
1316 bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1317 {
1318 bfa_trc(lps->bfa, lps->lp_tag);
1319 bfa_trc(lps->bfa, event);
1320
1321 switch (event) {
1322 case BFA_LPS_SM_RESUME:
1323 bfa_sm_set_state(lps, bfa_lps_sm_login);
1324 break;
1325
1326 case BFA_LPS_SM_OFFLINE:
1327 bfa_sm_set_state(lps, bfa_lps_sm_init);
1328 bfa_reqq_wcancel(&lps->wqe);
1329 break;
1330
1331 case BFA_LPS_SM_RX_CVL:
1332 /*
1333 * Login was not even sent out; so when getting out
1334 * of this state, it will appear like a login retry
1335 * after Clear virtual link
1336 */
1337 break;
1338
1339 default:
1340 bfa_sm_fault(lps->bfa, event);
1341 }
1342 }
1343
1344 /*
1345 * login complete
1346 */
1347 static void
1348 bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event)
1349 {
1350 bfa_trc(lps->bfa, lps->lp_tag);
1351 bfa_trc(lps->bfa, event);
1352
1353 switch (event) {
1354 case BFA_LPS_SM_LOGOUT:
1355 if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1356 bfa_sm_set_state(lps, bfa_lps_sm_logowait);
1357 bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1358 } else {
1359 bfa_sm_set_state(lps, bfa_lps_sm_logout);
1360 bfa_lps_send_logout(lps);
1361 }
1362 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1363 BFA_PL_EID_LOGO, 0, "Logout");
1364 break;
1365
1366 case BFA_LPS_SM_RX_CVL:
1367 bfa_sm_set_state(lps, bfa_lps_sm_init);
1368
1369 /* Let the vport module know about this event */
1370 bfa_lps_cvl_event(lps);
1371 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1372 BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx");
1373 break;
1374
1375 case BFA_LPS_SM_OFFLINE:
1376 case BFA_LPS_SM_DELETE:
1377 bfa_sm_set_state(lps, bfa_lps_sm_init);
1378 break;
1379
1380 default:
1381 bfa_sm_fault(lps->bfa, event);
1382 }
1383 }
1384
1385 /*
1386 * logout in progress - awaiting firmware response
1387 */
1388 static void
1389 bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event)
1390 {
1391 bfa_trc(lps->bfa, lps->lp_tag);
1392 bfa_trc(lps->bfa, event);
1393
1394 switch (event) {
1395 case BFA_LPS_SM_FWRSP:
1396 bfa_sm_set_state(lps, bfa_lps_sm_init);
1397 bfa_lps_logout_comp(lps);
1398 break;
1399
1400 case BFA_LPS_SM_OFFLINE:
1401 bfa_sm_set_state(lps, bfa_lps_sm_init);
1402 break;
1403
1404 default:
1405 bfa_sm_fault(lps->bfa, event);
1406 }
1407 }
1408
1409 /*
1410 * logout pending -- awaiting space in request queue
1411 */
1412 static void
1413 bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1414 {
1415 bfa_trc(lps->bfa, lps->lp_tag);
1416 bfa_trc(lps->bfa, event);
1417
1418 switch (event) {
1419 case BFA_LPS_SM_RESUME:
1420 bfa_sm_set_state(lps, bfa_lps_sm_logout);
1421 bfa_lps_send_logout(lps);
1422 break;
1423
1424 case BFA_LPS_SM_OFFLINE:
1425 bfa_sm_set_state(lps, bfa_lps_sm_init);
1426 bfa_reqq_wcancel(&lps->wqe);
1427 break;
1428
1429 default:
1430 bfa_sm_fault(lps->bfa, event);
1431 }
1432 }
1433
1434
1435
1436 /*
1437 * lps_pvt BFA LPS private functions
1438 */
1439
1440 /*
1441 * return memory requirement
1442 */
1443 static void
1444 bfa_lps_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
1445 u32 *dm_len)
1446 {
1447 if (cfg->drvcfg.min_cfg)
1448 *ndm_len += sizeof(struct bfa_lps_s) * BFA_LPS_MIN_LPORTS;
1449 else
1450 *ndm_len += sizeof(struct bfa_lps_s) * BFA_LPS_MAX_LPORTS;
1451 }
1452
1453 /*
1454 * bfa module attach at initialization time
1455 */
1456 static void
1457 bfa_lps_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1458 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
1459 {
1460 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1461 struct bfa_lps_s *lps;
1462 int i;
1463
1464 memset(mod, 0, sizeof(struct bfa_lps_mod_s));
1465 mod->num_lps = BFA_LPS_MAX_LPORTS;
1466 if (cfg->drvcfg.min_cfg)
1467 mod->num_lps = BFA_LPS_MIN_LPORTS;
1468 else
1469 mod->num_lps = BFA_LPS_MAX_LPORTS;
1470 mod->lps_arr = lps = (struct bfa_lps_s *) bfa_meminfo_kva(meminfo);
1471
1472 bfa_meminfo_kva(meminfo) += mod->num_lps * sizeof(struct bfa_lps_s);
1473
1474 INIT_LIST_HEAD(&mod->lps_free_q);
1475 INIT_LIST_HEAD(&mod->lps_active_q);
1476
1477 for (i = 0; i < mod->num_lps; i++, lps++) {
1478 lps->bfa = bfa;
1479 lps->lp_tag = (u8) i;
1480 lps->reqq = BFA_REQQ_LPS;
1481 bfa_reqq_winit(&lps->wqe, bfa_lps_reqq_resume, lps);
1482 list_add_tail(&lps->qe, &mod->lps_free_q);
1483 }
1484 }
1485
1486 static void
1487 bfa_lps_detach(struct bfa_s *bfa)
1488 {
1489 }
1490
1491 static void
1492 bfa_lps_start(struct bfa_s *bfa)
1493 {
1494 }
1495
1496 static void
1497 bfa_lps_stop(struct bfa_s *bfa)
1498 {
1499 }
1500
1501 /*
1502 * IOC in disabled state -- consider all lps offline
1503 */
1504 static void
1505 bfa_lps_iocdisable(struct bfa_s *bfa)
1506 {
1507 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1508 struct bfa_lps_s *lps;
1509 struct list_head *qe, *qen;
1510
1511 list_for_each_safe(qe, qen, &mod->lps_active_q) {
1512 lps = (struct bfa_lps_s *) qe;
1513 bfa_sm_send_event(lps, BFA_LPS_SM_OFFLINE);
1514 }
1515 }
1516
1517 /*
1518 * Firmware login response
1519 */
1520 static void
1521 bfa_lps_login_rsp(struct bfa_s *bfa, struct bfi_lps_login_rsp_s *rsp)
1522 {
1523 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1524 struct bfa_lps_s *lps;
1525
1526 bfa_assert(rsp->lp_tag < mod->num_lps);
1527 lps = BFA_LPS_FROM_TAG(mod, rsp->lp_tag);
1528
1529 lps->status = rsp->status;
1530 switch (rsp->status) {
1531 case BFA_STATUS_OK:
1532 lps->fport = rsp->f_port;
1533 lps->npiv_en = rsp->npiv_en;
1534 lps->lp_pid = rsp->lp_pid;
1535 lps->pr_bbcred = be16_to_cpu(rsp->bb_credit);
1536 lps->pr_pwwn = rsp->port_name;
1537 lps->pr_nwwn = rsp->node_name;
1538 lps->auth_req = rsp->auth_req;
1539 lps->lp_mac = rsp->lp_mac;
1540 lps->brcd_switch = rsp->brcd_switch;
1541 lps->fcf_mac = rsp->fcf_mac;
1542
1543 break;
1544
1545 case BFA_STATUS_FABRIC_RJT:
1546 lps->lsrjt_rsn = rsp->lsrjt_rsn;
1547 lps->lsrjt_expl = rsp->lsrjt_expl;
1548
1549 break;
1550
1551 case BFA_STATUS_EPROTOCOL:
1552 lps->ext_status = rsp->ext_status;
1553
1554 break;
1555
1556 default:
1557 /* Nothing to do with other status */
1558 break;
1559 }
1560
1561 bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1562 }
1563
1564 /*
1565 * Firmware logout response
1566 */
1567 static void
1568 bfa_lps_logout_rsp(struct bfa_s *bfa, struct bfi_lps_logout_rsp_s *rsp)
1569 {
1570 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1571 struct bfa_lps_s *lps;
1572
1573 bfa_assert(rsp->lp_tag < mod->num_lps);
1574 lps = BFA_LPS_FROM_TAG(mod, rsp->lp_tag);
1575
1576 bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1577 }
1578
1579 /*
1580 * Firmware received a Clear virtual link request (for FCoE)
1581 */
1582 static void
1583 bfa_lps_rx_cvl_event(struct bfa_s *bfa, struct bfi_lps_cvl_event_s *cvl)
1584 {
1585 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1586 struct bfa_lps_s *lps;
1587
1588 lps = BFA_LPS_FROM_TAG(mod, cvl->lp_tag);
1589
1590 bfa_sm_send_event(lps, BFA_LPS_SM_RX_CVL);
1591 }
1592
1593 /*
1594 * Space is available in request queue, resume queueing request to firmware.
1595 */
1596 static void
1597 bfa_lps_reqq_resume(void *lps_arg)
1598 {
1599 struct bfa_lps_s *lps = lps_arg;
1600
1601 bfa_sm_send_event(lps, BFA_LPS_SM_RESUME);
1602 }
1603
1604 /*
1605 * lps is freed -- triggered by vport delete
1606 */
1607 static void
1608 bfa_lps_free(struct bfa_lps_s *lps)
1609 {
1610 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(lps->bfa);
1611
1612 lps->lp_pid = 0;
1613 list_del(&lps->qe);
1614 list_add_tail(&lps->qe, &mod->lps_free_q);
1615 }
1616
1617 /*
1618 * send login request to firmware
1619 */
1620 static void
1621 bfa_lps_send_login(struct bfa_lps_s *lps)
1622 {
1623 struct bfi_lps_login_req_s *m;
1624
1625 m = bfa_reqq_next(lps->bfa, lps->reqq);
1626 bfa_assert(m);
1627
1628 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGIN_REQ,
1629 bfa_lpuid(lps->bfa));
1630
1631 m->lp_tag = lps->lp_tag;
1632 m->alpa = lps->alpa;
1633 m->pdu_size = cpu_to_be16(lps->pdusz);
1634 m->pwwn = lps->pwwn;
1635 m->nwwn = lps->nwwn;
1636 m->fdisc = lps->fdisc;
1637 m->auth_en = lps->auth_en;
1638
1639 bfa_reqq_produce(lps->bfa, lps->reqq);
1640 }
1641
1642 /*
1643 * send logout request to firmware
1644 */
1645 static void
1646 bfa_lps_send_logout(struct bfa_lps_s *lps)
1647 {
1648 struct bfi_lps_logout_req_s *m;
1649
1650 m = bfa_reqq_next(lps->bfa, lps->reqq);
1651 bfa_assert(m);
1652
1653 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGOUT_REQ,
1654 bfa_lpuid(lps->bfa));
1655
1656 m->lp_tag = lps->lp_tag;
1657 m->port_name = lps->pwwn;
1658 bfa_reqq_produce(lps->bfa, lps->reqq);
1659 }
1660
1661 /*
1662 * Indirect login completion handler for non-fcs
1663 */
1664 static void
1665 bfa_lps_login_comp_cb(void *arg, bfa_boolean_t complete)
1666 {
1667 struct bfa_lps_s *lps = arg;
1668
1669 if (!complete)
1670 return;
1671
1672 if (lps->fdisc)
1673 bfa_cb_lps_fdisc_comp(lps->bfa->bfad, lps->uarg, lps->status);
1674 else
1675 bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status);
1676 }
1677
1678 /*
1679 * Login completion handler -- direct call for fcs, queue for others
1680 */
1681 static void
1682 bfa_lps_login_comp(struct bfa_lps_s *lps)
1683 {
1684 if (!lps->bfa->fcs) {
1685 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_login_comp_cb,
1686 lps);
1687 return;
1688 }
1689
1690 if (lps->fdisc)
1691 bfa_cb_lps_fdisc_comp(lps->bfa->bfad, lps->uarg, lps->status);
1692 else
1693 bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status);
1694 }
1695
1696 /*
1697 * Indirect logout completion handler for non-fcs
1698 */
1699 static void
1700 bfa_lps_logout_comp_cb(void *arg, bfa_boolean_t complete)
1701 {
1702 struct bfa_lps_s *lps = arg;
1703
1704 if (!complete)
1705 return;
1706
1707 if (lps->fdisc)
1708 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg);
1709 }
1710
1711 /*
1712 * Logout completion handler -- direct call for fcs, queue for others
1713 */
1714 static void
1715 bfa_lps_logout_comp(struct bfa_lps_s *lps)
1716 {
1717 if (!lps->bfa->fcs) {
1718 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_logout_comp_cb,
1719 lps);
1720 return;
1721 }
1722 if (lps->fdisc)
1723 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg);
1724 }
1725
1726 /*
1727 * Clear virtual link completion handler for non-fcs
1728 */
1729 static void
1730 bfa_lps_cvl_event_cb(void *arg, bfa_boolean_t complete)
1731 {
1732 struct bfa_lps_s *lps = arg;
1733
1734 if (!complete)
1735 return;
1736
1737 /* Clear virtual link to base port will result in link down */
1738 if (lps->fdisc)
1739 bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg);
1740 }
1741
1742 /*
1743 * Received Clear virtual link event --direct call for fcs,
1744 * queue for others
1745 */
1746 static void
1747 bfa_lps_cvl_event(struct bfa_lps_s *lps)
1748 {
1749 if (!lps->bfa->fcs) {
1750 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_cvl_event_cb,
1751 lps);
1752 return;
1753 }
1754
1755 /* Clear virtual link to base port will result in link down */
1756 if (lps->fdisc)
1757 bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg);
1758 }
1759
1760
1761
1762 /*
1763 * lps_public BFA LPS public functions
1764 */
1765
1766 u32
1767 bfa_lps_get_max_vport(struct bfa_s *bfa)
1768 {
1769 if (bfa_ioc_devid(&bfa->ioc) == BFA_PCI_DEVICE_ID_CT)
1770 return BFA_LPS_MAX_VPORTS_SUPP_CT;
1771 else
1772 return BFA_LPS_MAX_VPORTS_SUPP_CB;
1773 }
1774
1775 /*
1776 * Allocate a lport srvice tag.
1777 */
1778 struct bfa_lps_s *
1779 bfa_lps_alloc(struct bfa_s *bfa)
1780 {
1781 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1782 struct bfa_lps_s *lps = NULL;
1783
1784 bfa_q_deq(&mod->lps_free_q, &lps);
1785
1786 if (lps == NULL)
1787 return NULL;
1788
1789 list_add_tail(&lps->qe, &mod->lps_active_q);
1790
1791 bfa_sm_set_state(lps, bfa_lps_sm_init);
1792 return lps;
1793 }
1794
1795 /*
1796 * Free lport service tag. This can be called anytime after an alloc.
1797 * No need to wait for any pending login/logout completions.
1798 */
1799 void
1800 bfa_lps_delete(struct bfa_lps_s *lps)
1801 {
1802 bfa_sm_send_event(lps, BFA_LPS_SM_DELETE);
1803 }
1804
1805 /*
1806 * Initiate a lport login.
1807 */
1808 void
1809 bfa_lps_flogi(struct bfa_lps_s *lps, void *uarg, u8 alpa, u16 pdusz,
1810 wwn_t pwwn, wwn_t nwwn, bfa_boolean_t auth_en)
1811 {
1812 lps->uarg = uarg;
1813 lps->alpa = alpa;
1814 lps->pdusz = pdusz;
1815 lps->pwwn = pwwn;
1816 lps->nwwn = nwwn;
1817 lps->fdisc = BFA_FALSE;
1818 lps->auth_en = auth_en;
1819 bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN);
1820 }
1821
1822 /*
1823 * Initiate a lport fdisc login.
1824 */
1825 void
1826 bfa_lps_fdisc(struct bfa_lps_s *lps, void *uarg, u16 pdusz, wwn_t pwwn,
1827 wwn_t nwwn)
1828 {
1829 lps->uarg = uarg;
1830 lps->alpa = 0;
1831 lps->pdusz = pdusz;
1832 lps->pwwn = pwwn;
1833 lps->nwwn = nwwn;
1834 lps->fdisc = BFA_TRUE;
1835 lps->auth_en = BFA_FALSE;
1836 bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN);
1837 }
1838
1839
1840 /*
1841 * Initiate a lport FDSIC logout.
1842 */
1843 void
1844 bfa_lps_fdisclogo(struct bfa_lps_s *lps)
1845 {
1846 bfa_sm_send_event(lps, BFA_LPS_SM_LOGOUT);
1847 }
1848
1849 /*
1850 * Discard a pending login request -- should be called only for
1851 * link down handling.
1852 */
1853 void
1854 bfa_lps_discard(struct bfa_lps_s *lps)
1855 {
1856 bfa_sm_send_event(lps, BFA_LPS_SM_OFFLINE);
1857 }
1858
1859 /*
1860 * Return lport services tag
1861 */
1862 u8
1863 bfa_lps_get_tag(struct bfa_lps_s *lps)
1864 {
1865 return lps->lp_tag;
1866 }
1867
1868 /*
1869 * Return lport services tag given the pid
1870 */
1871 u8
1872 bfa_lps_get_tag_from_pid(struct bfa_s *bfa, u32 pid)
1873 {
1874 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1875 struct bfa_lps_s *lps;
1876 int i;
1877
1878 for (i = 0, lps = mod->lps_arr; i < mod->num_lps; i++, lps++) {
1879 if (lps->lp_pid == pid)
1880 return lps->lp_tag;
1881 }
1882
1883 /* Return base port tag anyway */
1884 return 0;
1885 }
1886
1887 /*
1888 * return if fabric login indicates support for NPIV
1889 */
1890 bfa_boolean_t
1891 bfa_lps_is_npiv_en(struct bfa_lps_s *lps)
1892 {
1893 return lps->npiv_en;
1894 }
1895
1896 /*
1897 * Return TRUE if attached to F-Port, else return FALSE
1898 */
1899 bfa_boolean_t
1900 bfa_lps_is_fport(struct bfa_lps_s *lps)
1901 {
1902 return lps->fport;
1903 }
1904
1905 /*
1906 * Return TRUE if attached to a Brocade Fabric
1907 */
1908 bfa_boolean_t
1909 bfa_lps_is_brcd_fabric(struct bfa_lps_s *lps)
1910 {
1911 return lps->brcd_switch;
1912 }
1913 /*
1914 * return TRUE if authentication is required
1915 */
1916 bfa_boolean_t
1917 bfa_lps_is_authreq(struct bfa_lps_s *lps)
1918 {
1919 return lps->auth_req;
1920 }
1921
1922 bfa_eproto_status_t
1923 bfa_lps_get_extstatus(struct bfa_lps_s *lps)
1924 {
1925 return lps->ext_status;
1926 }
1927
1928 /*
1929 * return port id assigned to the lport
1930 */
1931 u32
1932 bfa_lps_get_pid(struct bfa_lps_s *lps)
1933 {
1934 return lps->lp_pid;
1935 }
1936
1937 /*
1938 * return port id assigned to the base lport
1939 */
1940 u32
1941 bfa_lps_get_base_pid(struct bfa_s *bfa)
1942 {
1943 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1944
1945 return BFA_LPS_FROM_TAG(mod, 0)->lp_pid;
1946 }
1947
1948 /*
1949 * Return bb_credit assigned in FLOGI response
1950 */
1951 u16
1952 bfa_lps_get_peer_bbcredit(struct bfa_lps_s *lps)
1953 {
1954 return lps->pr_bbcred;
1955 }
1956
1957 /*
1958 * Return peer port name
1959 */
1960 wwn_t
1961 bfa_lps_get_peer_pwwn(struct bfa_lps_s *lps)
1962 {
1963 return lps->pr_pwwn;
1964 }
1965
1966 /*
1967 * Return peer node name
1968 */
1969 wwn_t
1970 bfa_lps_get_peer_nwwn(struct bfa_lps_s *lps)
1971 {
1972 return lps->pr_nwwn;
1973 }
1974
1975 /*
1976 * return reason code if login request is rejected
1977 */
1978 u8
1979 bfa_lps_get_lsrjt_rsn(struct bfa_lps_s *lps)
1980 {
1981 return lps->lsrjt_rsn;
1982 }
1983
1984 /*
1985 * return explanation code if login request is rejected
1986 */
1987 u8
1988 bfa_lps_get_lsrjt_expl(struct bfa_lps_s *lps)
1989 {
1990 return lps->lsrjt_expl;
1991 }
1992
1993 /*
1994 * Return fpma/spma MAC for lport
1995 */
1996 mac_t
1997 bfa_lps_get_lp_mac(struct bfa_lps_s *lps)
1998 {
1999 return lps->lp_mac;
2000 }
2001
2002 /*
2003 * LPS firmware message class handler.
2004 */
2005 void
2006 bfa_lps_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
2007 {
2008 union bfi_lps_i2h_msg_u msg;
2009
2010 bfa_trc(bfa, m->mhdr.msg_id);
2011 msg.msg = m;
2012
2013 switch (m->mhdr.msg_id) {
2014 case BFI_LPS_H2I_LOGIN_RSP:
2015 bfa_lps_login_rsp(bfa, msg.login_rsp);
2016 break;
2017
2018 case BFI_LPS_H2I_LOGOUT_RSP:
2019 bfa_lps_logout_rsp(bfa, msg.logout_rsp);
2020 break;
2021
2022 case BFI_LPS_H2I_CVL_EVENT:
2023 bfa_lps_rx_cvl_event(bfa, msg.cvl_event);
2024 break;
2025
2026 default:
2027 bfa_trc(bfa, m->mhdr.msg_id);
2028 bfa_assert(0);
2029 }
2030 }
2031
2032 /*
2033 * FC PORT state machine functions
2034 */
2035 static void
2036 bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
2037 enum bfa_fcport_sm_event event)
2038 {
2039 bfa_trc(fcport->bfa, event);
2040
2041 switch (event) {
2042 case BFA_FCPORT_SM_START:
2043 /*
2044 * Start event after IOC is configured and BFA is started.
2045 */
2046 if (bfa_fcport_send_enable(fcport)) {
2047 bfa_trc(fcport->bfa, BFA_TRUE);
2048 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2049 } else {
2050 bfa_trc(fcport->bfa, BFA_FALSE);
2051 bfa_sm_set_state(fcport,
2052 bfa_fcport_sm_enabling_qwait);
2053 }
2054 break;
2055
2056 case BFA_FCPORT_SM_ENABLE:
2057 /*
2058 * Port is persistently configured to be in enabled state. Do
2059 * not change state. Port enabling is done when START event is
2060 * received.
2061 */
2062 break;
2063
2064 case BFA_FCPORT_SM_DISABLE:
2065 /*
2066 * If a port is persistently configured to be disabled, the
2067 * first event will a port disable request.
2068 */
2069 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2070 break;
2071
2072 case BFA_FCPORT_SM_HWFAIL:
2073 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2074 break;
2075
2076 default:
2077 bfa_sm_fault(fcport->bfa, event);
2078 }
2079 }
2080
2081 static void
2082 bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
2083 enum bfa_fcport_sm_event event)
2084 {
2085 char pwwn_buf[BFA_STRING_32];
2086 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2087 bfa_trc(fcport->bfa, event);
2088
2089 switch (event) {
2090 case BFA_FCPORT_SM_QRESUME:
2091 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2092 bfa_fcport_send_enable(fcport);
2093 break;
2094
2095 case BFA_FCPORT_SM_STOP:
2096 bfa_reqq_wcancel(&fcport->reqq_wait);
2097 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2098 break;
2099
2100 case BFA_FCPORT_SM_ENABLE:
2101 /*
2102 * Already enable is in progress.
2103 */
2104 break;
2105
2106 case BFA_FCPORT_SM_DISABLE:
2107 /*
2108 * Just send disable request to firmware when room becomes
2109 * available in request queue.
2110 */
2111 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2112 bfa_reqq_wcancel(&fcport->reqq_wait);
2113 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2114 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2115 wwn2str(pwwn_buf, fcport->pwwn);
2116 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2117 "Base port disabled: WWN = %s\n", pwwn_buf);
2118 break;
2119
2120 case BFA_FCPORT_SM_LINKUP:
2121 case BFA_FCPORT_SM_LINKDOWN:
2122 /*
2123 * Possible to get link events when doing back-to-back
2124 * enable/disables.
2125 */
2126 break;
2127
2128 case BFA_FCPORT_SM_HWFAIL:
2129 bfa_reqq_wcancel(&fcport->reqq_wait);
2130 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2131 break;
2132
2133 default:
2134 bfa_sm_fault(fcport->bfa, event);
2135 }
2136 }
2137
2138 static void
2139 bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
2140 enum bfa_fcport_sm_event event)
2141 {
2142 char pwwn_buf[BFA_STRING_32];
2143 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2144 bfa_trc(fcport->bfa, event);
2145
2146 switch (event) {
2147 case BFA_FCPORT_SM_FWRSP:
2148 case BFA_FCPORT_SM_LINKDOWN:
2149 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
2150 break;
2151
2152 case BFA_FCPORT_SM_LINKUP:
2153 bfa_fcport_update_linkinfo(fcport);
2154 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
2155
2156 bfa_assert(fcport->event_cbfn);
2157 bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
2158 break;
2159
2160 case BFA_FCPORT_SM_ENABLE:
2161 /*
2162 * Already being enabled.
2163 */
2164 break;
2165
2166 case BFA_FCPORT_SM_DISABLE:
2167 if (bfa_fcport_send_disable(fcport))
2168 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2169 else
2170 bfa_sm_set_state(fcport,
2171 bfa_fcport_sm_disabling_qwait);
2172
2173 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2174 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2175 wwn2str(pwwn_buf, fcport->pwwn);
2176 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2177 "Base port disabled: WWN = %s\n", pwwn_buf);
2178 break;
2179
2180 case BFA_FCPORT_SM_STOP:
2181 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2182 break;
2183
2184 case BFA_FCPORT_SM_HWFAIL:
2185 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2186 break;
2187
2188 default:
2189 bfa_sm_fault(fcport->bfa, event);
2190 }
2191 }
2192
2193 static void
2194 bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
2195 enum bfa_fcport_sm_event event)
2196 {
2197 struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
2198 char pwwn_buf[BFA_STRING_32];
2199 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2200
2201 bfa_trc(fcport->bfa, event);
2202
2203 switch (event) {
2204 case BFA_FCPORT_SM_LINKUP:
2205 bfa_fcport_update_linkinfo(fcport);
2206 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
2207 bfa_assert(fcport->event_cbfn);
2208 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2209 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkup");
2210 if (!bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
2211
2212 bfa_trc(fcport->bfa,
2213 pevent->link_state.vc_fcf.fcf.fipenabled);
2214 bfa_trc(fcport->bfa,
2215 pevent->link_state.vc_fcf.fcf.fipfailed);
2216
2217 if (pevent->link_state.vc_fcf.fcf.fipfailed)
2218 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2219 BFA_PL_EID_FIP_FCF_DISC, 0,
2220 "FIP FCF Discovery Failed");
2221 else
2222 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2223 BFA_PL_EID_FIP_FCF_DISC, 0,
2224 "FIP FCF Discovered");
2225 }
2226
2227 bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
2228 wwn2str(pwwn_buf, fcport->pwwn);
2229 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2230 "Base port online: WWN = %s\n", pwwn_buf);
2231 break;
2232
2233 case BFA_FCPORT_SM_LINKDOWN:
2234 /*
2235 * Possible to get link down event.
2236 */
2237 break;
2238
2239 case BFA_FCPORT_SM_ENABLE:
2240 /*
2241 * Already enabled.
2242 */
2243 break;
2244
2245 case BFA_FCPORT_SM_DISABLE:
2246 if (bfa_fcport_send_disable(fcport))
2247 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2248 else
2249 bfa_sm_set_state(fcport,
2250 bfa_fcport_sm_disabling_qwait);
2251
2252 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2253 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2254 wwn2str(pwwn_buf, fcport->pwwn);
2255 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2256 "Base port disabled: WWN = %s\n", pwwn_buf);
2257 break;
2258
2259 case BFA_FCPORT_SM_STOP:
2260 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2261 break;
2262
2263 case BFA_FCPORT_SM_HWFAIL:
2264 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2265 break;
2266
2267 default:
2268 bfa_sm_fault(fcport->bfa, event);
2269 }
2270 }
2271
2272 static void
2273 bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
2274 enum bfa_fcport_sm_event event)
2275 {
2276 char pwwn_buf[BFA_STRING_32];
2277 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2278
2279 bfa_trc(fcport->bfa, event);
2280
2281 switch (event) {
2282 case BFA_FCPORT_SM_ENABLE:
2283 /*
2284 * Already enabled.
2285 */
2286 break;
2287
2288 case BFA_FCPORT_SM_DISABLE:
2289 if (bfa_fcport_send_disable(fcport))
2290 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2291 else
2292 bfa_sm_set_state(fcport,
2293 bfa_fcport_sm_disabling_qwait);
2294
2295 bfa_fcport_reset_linkinfo(fcport);
2296 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2297 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2298 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2299 wwn2str(pwwn_buf, fcport->pwwn);
2300 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2301 "Base port offline: WWN = %s\n", pwwn_buf);
2302 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2303 "Base port disabled: WWN = %s\n", pwwn_buf);
2304 break;
2305
2306 case BFA_FCPORT_SM_LINKDOWN:
2307 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
2308 bfa_fcport_reset_linkinfo(fcport);
2309 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2310 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2311 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
2312 wwn2str(pwwn_buf, fcport->pwwn);
2313 if (BFA_PORT_IS_DISABLED(fcport->bfa))
2314 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2315 "Base port offline: WWN = %s\n", pwwn_buf);
2316 else
2317 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2318 "Base port (WWN = %s) "
2319 "lost fabric connectivity\n", pwwn_buf);
2320 break;
2321
2322 case BFA_FCPORT_SM_STOP:
2323 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2324 bfa_fcport_reset_linkinfo(fcport);
2325 wwn2str(pwwn_buf, fcport->pwwn);
2326 if (BFA_PORT_IS_DISABLED(fcport->bfa))
2327 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2328 "Base port offline: WWN = %s\n", pwwn_buf);
2329 else
2330 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2331 "Base port (WWN = %s) "
2332 "lost fabric connectivity\n", pwwn_buf);
2333 break;
2334
2335 case BFA_FCPORT_SM_HWFAIL:
2336 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2337 bfa_fcport_reset_linkinfo(fcport);
2338 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2339 wwn2str(pwwn_buf, fcport->pwwn);
2340 if (BFA_PORT_IS_DISABLED(fcport->bfa))
2341 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2342 "Base port offline: WWN = %s\n", pwwn_buf);
2343 else
2344 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2345 "Base port (WWN = %s) "
2346 "lost fabric connectivity\n", pwwn_buf);
2347 break;
2348
2349 default:
2350 bfa_sm_fault(fcport->bfa, event);
2351 }
2352 }
2353
2354 static void
2355 bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
2356 enum bfa_fcport_sm_event event)
2357 {
2358 bfa_trc(fcport->bfa, event);
2359
2360 switch (event) {
2361 case BFA_FCPORT_SM_QRESUME:
2362 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2363 bfa_fcport_send_disable(fcport);
2364 break;
2365
2366 case BFA_FCPORT_SM_STOP:
2367 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2368 bfa_reqq_wcancel(&fcport->reqq_wait);
2369 break;
2370
2371 case BFA_FCPORT_SM_ENABLE:
2372 bfa_sm_set_state(fcport, bfa_fcport_sm_toggling_qwait);
2373 break;
2374
2375 case BFA_FCPORT_SM_DISABLE:
2376 /*
2377 * Already being disabled.
2378 */
2379 break;
2380
2381 case BFA_FCPORT_SM_LINKUP:
2382 case BFA_FCPORT_SM_LINKDOWN:
2383 /*
2384 * Possible to get link events when doing back-to-back
2385 * enable/disables.
2386 */
2387 break;
2388
2389 case BFA_FCPORT_SM_HWFAIL:
2390 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2391 bfa_reqq_wcancel(&fcport->reqq_wait);
2392 break;
2393
2394 default:
2395 bfa_sm_fault(fcport->bfa, event);
2396 }
2397 }
2398
2399 static void
2400 bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport,
2401 enum bfa_fcport_sm_event event)
2402 {
2403 bfa_trc(fcport->bfa, event);
2404
2405 switch (event) {
2406 case BFA_FCPORT_SM_QRESUME:
2407 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2408 bfa_fcport_send_disable(fcport);
2409 if (bfa_fcport_send_enable(fcport))
2410 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2411 else
2412 bfa_sm_set_state(fcport,
2413 bfa_fcport_sm_enabling_qwait);
2414 break;
2415
2416 case BFA_FCPORT_SM_STOP:
2417 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2418 bfa_reqq_wcancel(&fcport->reqq_wait);
2419 break;
2420
2421 case BFA_FCPORT_SM_ENABLE:
2422 break;
2423
2424 case BFA_FCPORT_SM_DISABLE:
2425 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
2426 break;
2427
2428 case BFA_FCPORT_SM_LINKUP:
2429 case BFA_FCPORT_SM_LINKDOWN:
2430 /*
2431 * Possible to get link events when doing back-to-back
2432 * enable/disables.
2433 */
2434 break;
2435
2436 case BFA_FCPORT_SM_HWFAIL:
2437 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2438 bfa_reqq_wcancel(&fcport->reqq_wait);
2439 break;
2440
2441 default:
2442 bfa_sm_fault(fcport->bfa, event);
2443 }
2444 }
2445
2446 static void
2447 bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
2448 enum bfa_fcport_sm_event event)
2449 {
2450 char pwwn_buf[BFA_STRING_32];
2451 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2452 bfa_trc(fcport->bfa, event);
2453
2454 switch (event) {
2455 case BFA_FCPORT_SM_FWRSP:
2456 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2457 break;
2458
2459 case BFA_FCPORT_SM_DISABLE:
2460 /*
2461 * Already being disabled.
2462 */
2463 break;
2464
2465 case BFA_FCPORT_SM_ENABLE:
2466 if (bfa_fcport_send_enable(fcport))
2467 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2468 else
2469 bfa_sm_set_state(fcport,
2470 bfa_fcport_sm_enabling_qwait);
2471
2472 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2473 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2474 wwn2str(pwwn_buf, fcport->pwwn);
2475 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2476 "Base port enabled: WWN = %s\n", pwwn_buf);
2477 break;
2478
2479 case BFA_FCPORT_SM_STOP:
2480 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2481 break;
2482
2483 case BFA_FCPORT_SM_LINKUP:
2484 case BFA_FCPORT_SM_LINKDOWN:
2485 /*
2486 * Possible to get link events when doing back-to-back
2487 * enable/disables.
2488 */
2489 break;
2490
2491 case BFA_FCPORT_SM_HWFAIL:
2492 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2493 break;
2494
2495 default:
2496 bfa_sm_fault(fcport->bfa, event);
2497 }
2498 }
2499
2500 static void
2501 bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
2502 enum bfa_fcport_sm_event event)
2503 {
2504 char pwwn_buf[BFA_STRING_32];
2505 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2506 bfa_trc(fcport->bfa, event);
2507
2508 switch (event) {
2509 case BFA_FCPORT_SM_START:
2510 /*
2511 * Ignore start event for a port that is disabled.
2512 */
2513 break;
2514
2515 case BFA_FCPORT_SM_STOP:
2516 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2517 break;
2518
2519 case BFA_FCPORT_SM_ENABLE:
2520 if (bfa_fcport_send_enable(fcport))
2521 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2522 else
2523 bfa_sm_set_state(fcport,
2524 bfa_fcport_sm_enabling_qwait);
2525
2526 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2527 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2528 wwn2str(pwwn_buf, fcport->pwwn);
2529 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2530 "Base port enabled: WWN = %s\n", pwwn_buf);
2531 break;
2532
2533 case BFA_FCPORT_SM_DISABLE:
2534 /*
2535 * Already disabled.
2536 */
2537 break;
2538
2539 case BFA_FCPORT_SM_HWFAIL:
2540 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2541 break;
2542
2543 default:
2544 bfa_sm_fault(fcport->bfa, event);
2545 }
2546 }
2547
2548 static void
2549 bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
2550 enum bfa_fcport_sm_event event)
2551 {
2552 bfa_trc(fcport->bfa, event);
2553
2554 switch (event) {
2555 case BFA_FCPORT_SM_START:
2556 if (bfa_fcport_send_enable(fcport))
2557 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2558 else
2559 bfa_sm_set_state(fcport,
2560 bfa_fcport_sm_enabling_qwait);
2561 break;
2562
2563 default:
2564 /*
2565 * Ignore all other events.
2566 */
2567 ;
2568 }
2569 }
2570
2571 /*
2572 * Port is enabled. IOC is down/failed.
2573 */
2574 static void
2575 bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
2576 enum bfa_fcport_sm_event event)
2577 {
2578 bfa_trc(fcport->bfa, event);
2579
2580 switch (event) {
2581 case BFA_FCPORT_SM_START:
2582 if (bfa_fcport_send_enable(fcport))
2583 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2584 else
2585 bfa_sm_set_state(fcport,
2586 bfa_fcport_sm_enabling_qwait);
2587 break;
2588
2589 default:
2590 /*
2591 * Ignore all events.
2592 */
2593 ;
2594 }
2595 }
2596
2597 /*
2598 * Port is disabled. IOC is down/failed.
2599 */
2600 static void
2601 bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
2602 enum bfa_fcport_sm_event event)
2603 {
2604 bfa_trc(fcport->bfa, event);
2605
2606 switch (event) {
2607 case BFA_FCPORT_SM_START:
2608 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2609 break;
2610
2611 case BFA_FCPORT_SM_ENABLE:
2612 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2613 break;
2614
2615 default:
2616 /*
2617 * Ignore all events.
2618 */
2619 ;
2620 }
2621 }
2622
2623 /*
2624 * Link state is down
2625 */
2626 static void
2627 bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
2628 enum bfa_fcport_ln_sm_event event)
2629 {
2630 bfa_trc(ln->fcport->bfa, event);
2631
2632 switch (event) {
2633 case BFA_FCPORT_LN_SM_LINKUP:
2634 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
2635 bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP);
2636 break;
2637
2638 default:
2639 bfa_sm_fault(ln->fcport->bfa, event);
2640 }
2641 }
2642
2643 /*
2644 * Link state is waiting for down notification
2645 */
2646 static void
2647 bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
2648 enum bfa_fcport_ln_sm_event event)
2649 {
2650 bfa_trc(ln->fcport->bfa, event);
2651
2652 switch (event) {
2653 case BFA_FCPORT_LN_SM_LINKUP:
2654 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
2655 break;
2656
2657 case BFA_FCPORT_LN_SM_NOTIFICATION:
2658 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
2659 break;
2660
2661 default:
2662 bfa_sm_fault(ln->fcport->bfa, event);
2663 }
2664 }
2665
2666 /*
2667 * Link state is waiting for down notification and there is a pending up
2668 */
2669 static void
2670 bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
2671 enum bfa_fcport_ln_sm_event event)
2672 {
2673 bfa_trc(ln->fcport->bfa, event);
2674
2675 switch (event) {
2676 case BFA_FCPORT_LN_SM_LINKDOWN:
2677 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2678 break;
2679
2680 case BFA_FCPORT_LN_SM_NOTIFICATION:
2681 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
2682 bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP);
2683 break;
2684
2685 default:
2686 bfa_sm_fault(ln->fcport->bfa, event);
2687 }
2688 }
2689
2690 /*
2691 * Link state is up
2692 */
2693 static void
2694 bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
2695 enum bfa_fcport_ln_sm_event event)
2696 {
2697 bfa_trc(ln->fcport->bfa, event);
2698
2699 switch (event) {
2700 case BFA_FCPORT_LN_SM_LINKDOWN:
2701 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2702 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2703 break;
2704
2705 default:
2706 bfa_sm_fault(ln->fcport->bfa, event);
2707 }
2708 }
2709
2710 /*
2711 * Link state is waiting for up notification
2712 */
2713 static void
2714 bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
2715 enum bfa_fcport_ln_sm_event event)
2716 {
2717 bfa_trc(ln->fcport->bfa, event);
2718
2719 switch (event) {
2720 case BFA_FCPORT_LN_SM_LINKDOWN:
2721 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
2722 break;
2723
2724 case BFA_FCPORT_LN_SM_NOTIFICATION:
2725 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up);
2726 break;
2727
2728 default:
2729 bfa_sm_fault(ln->fcport->bfa, event);
2730 }
2731 }
2732
2733 /*
2734 * Link state is waiting for up notification and there is a pending down
2735 */
2736 static void
2737 bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
2738 enum bfa_fcport_ln_sm_event event)
2739 {
2740 bfa_trc(ln->fcport->bfa, event);
2741
2742 switch (event) {
2743 case BFA_FCPORT_LN_SM_LINKUP:
2744 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_up_nf);
2745 break;
2746
2747 case BFA_FCPORT_LN_SM_NOTIFICATION:
2748 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2749 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2750 break;
2751
2752 default:
2753 bfa_sm_fault(ln->fcport->bfa, event);
2754 }
2755 }
2756
2757 /*
2758 * Link state is waiting for up notification and there are pending down and up
2759 */
2760 static void
2761 bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
2762 enum bfa_fcport_ln_sm_event event)
2763 {
2764 bfa_trc(ln->fcport->bfa, event);
2765
2766 switch (event) {
2767 case BFA_FCPORT_LN_SM_LINKDOWN:
2768 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
2769 break;
2770
2771 case BFA_FCPORT_LN_SM_NOTIFICATION:
2772 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
2773 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2774 break;
2775
2776 default:
2777 bfa_sm_fault(ln->fcport->bfa, event);
2778 }
2779 }
2780
2781
2782
2783 /*
2784 * hal_port_private
2785 */
2786
2787 static void
2788 __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete)
2789 {
2790 struct bfa_fcport_ln_s *ln = cbarg;
2791
2792 if (complete)
2793 ln->fcport->event_cbfn(ln->fcport->event_cbarg, ln->ln_event);
2794 else
2795 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
2796 }
2797
2798 /*
2799 * Send SCN notification to upper layers.
2800 * trunk - false if caller is fcport to ignore fcport event in trunked mode
2801 */
2802 static void
2803 bfa_fcport_scn(struct bfa_fcport_s *fcport, enum bfa_port_linkstate event,
2804 bfa_boolean_t trunk)
2805 {
2806 if (fcport->cfg.trunked && !trunk)
2807 return;
2808
2809 switch (event) {
2810 case BFA_PORT_LINKUP:
2811 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKUP);
2812 break;
2813 case BFA_PORT_LINKDOWN:
2814 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN);
2815 break;
2816 default:
2817 bfa_assert(0);
2818 }
2819 }
2820
2821 static void
2822 bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, enum bfa_port_linkstate event)
2823 {
2824 struct bfa_fcport_s *fcport = ln->fcport;
2825
2826 if (fcport->bfa->fcs) {
2827 fcport->event_cbfn(fcport->event_cbarg, event);
2828 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
2829 } else {
2830 ln->ln_event = event;
2831 bfa_cb_queue(fcport->bfa, &ln->ln_qe,
2832 __bfa_cb_fcport_event, ln);
2833 }
2834 }
2835
2836 #define FCPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \
2837 BFA_CACHELINE_SZ))
2838
2839 static void
2840 bfa_fcport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
2841 u32 *dm_len)
2842 {
2843 *dm_len += FCPORT_STATS_DMA_SZ;
2844 }
2845
2846 static void
2847 bfa_fcport_qresume(void *cbarg)
2848 {
2849 struct bfa_fcport_s *fcport = cbarg;
2850
2851 bfa_sm_send_event(fcport, BFA_FCPORT_SM_QRESUME);
2852 }
2853
2854 static void
2855 bfa_fcport_mem_claim(struct bfa_fcport_s *fcport, struct bfa_meminfo_s *meminfo)
2856 {
2857 u8 *dm_kva;
2858 u64 dm_pa;
2859
2860 dm_kva = bfa_meminfo_dma_virt(meminfo);
2861 dm_pa = bfa_meminfo_dma_phys(meminfo);
2862
2863 fcport->stats_kva = dm_kva;
2864 fcport->stats_pa = dm_pa;
2865 fcport->stats = (union bfa_fcport_stats_u *) dm_kva;
2866
2867 dm_kva += FCPORT_STATS_DMA_SZ;
2868 dm_pa += FCPORT_STATS_DMA_SZ;
2869
2870 bfa_meminfo_dma_virt(meminfo) = dm_kva;
2871 bfa_meminfo_dma_phys(meminfo) = dm_pa;
2872 }
2873
2874 /*
2875 * Memory initialization.
2876 */
2877 static void
2878 bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
2879 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
2880 {
2881 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
2882 struct bfa_port_cfg_s *port_cfg = &fcport->cfg;
2883 struct bfa_fcport_ln_s *ln = &fcport->ln;
2884 struct bfa_timeval_s tv;
2885
2886 memset(fcport, 0, sizeof(struct bfa_fcport_s));
2887 fcport->bfa = bfa;
2888 ln->fcport = fcport;
2889
2890 bfa_fcport_mem_claim(fcport, meminfo);
2891
2892 bfa_sm_set_state(fcport, bfa_fcport_sm_uninit);
2893 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
2894
2895 /*
2896 * initialize time stamp for stats reset
2897 */
2898 bfa_os_gettimeofday(&tv);
2899 fcport->stats_reset_time = tv.tv_sec;
2900
2901 /*
2902 * initialize and set default configuration
2903 */
2904 port_cfg->topology = BFA_PORT_TOPOLOGY_P2P;
2905 port_cfg->speed = BFA_PORT_SPEED_AUTO;
2906 port_cfg->trunked = BFA_FALSE;
2907 port_cfg->maxfrsize = 0;
2908
2909 port_cfg->trl_def_speed = BFA_PORT_SPEED_1GBPS;
2910
2911 bfa_reqq_winit(&fcport->reqq_wait, bfa_fcport_qresume, fcport);
2912 }
2913
2914 static void
2915 bfa_fcport_detach(struct bfa_s *bfa)
2916 {
2917 }
2918
2919 /*
2920 * Called when IOC is ready.
2921 */
2922 static void
2923 bfa_fcport_start(struct bfa_s *bfa)
2924 {
2925 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_START);
2926 }
2927
2928 /*
2929 * Called before IOC is stopped.
2930 */
2931 static void
2932 bfa_fcport_stop(struct bfa_s *bfa)
2933 {
2934 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_STOP);
2935 bfa_trunk_iocdisable(bfa);
2936 }
2937
2938 /*
2939 * Called when IOC failure is detected.
2940 */
2941 static void
2942 bfa_fcport_iocdisable(struct bfa_s *bfa)
2943 {
2944 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
2945
2946 bfa_sm_send_event(fcport, BFA_FCPORT_SM_HWFAIL);
2947 bfa_trunk_iocdisable(bfa);
2948 }
2949
2950 static void
2951 bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
2952 {
2953 struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
2954 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
2955
2956 fcport->speed = pevent->link_state.speed;
2957 fcport->topology = pevent->link_state.topology;
2958
2959 if (fcport->topology == BFA_PORT_TOPOLOGY_LOOP)
2960 fcport->myalpa = 0;
2961
2962 /* QoS Details */
2963 fcport->qos_attr = pevent->link_state.qos_attr;
2964 fcport->qos_vc_attr = pevent->link_state.vc_fcf.qos_vc_attr;
2965
2966 /*
2967 * update trunk state if applicable
2968 */
2969 if (!fcport->cfg.trunked)
2970 trunk->attr.state = BFA_TRUNK_DISABLED;
2971
2972 /* update FCoE specific */
2973 fcport->fcoe_vlan = be16_to_cpu(pevent->link_state.vc_fcf.fcf.vlan);
2974
2975 bfa_trc(fcport->bfa, fcport->speed);
2976 bfa_trc(fcport->bfa, fcport->topology);
2977 }
2978
2979 static void
2980 bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport)
2981 {
2982 fcport->speed = BFA_PORT_SPEED_UNKNOWN;
2983 fcport->topology = BFA_PORT_TOPOLOGY_NONE;
2984 }
2985
2986 /*
2987 * Send port enable message to firmware.
2988 */
2989 static bfa_boolean_t
2990 bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
2991 {
2992 struct bfi_fcport_enable_req_s *m;
2993
2994 /*
2995 * Increment message tag before queue check, so that responses to old
2996 * requests are discarded.
2997 */
2998 fcport->msgtag++;
2999
3000 /*
3001 * check for room in queue to send request now
3002 */
3003 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3004 if (!m) {
3005 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3006 &fcport->reqq_wait);
3007 return BFA_FALSE;
3008 }
3009
3010 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_ENABLE_REQ,
3011 bfa_lpuid(fcport->bfa));
3012 m->nwwn = fcport->nwwn;
3013 m->pwwn = fcport->pwwn;
3014 m->port_cfg = fcport->cfg;
3015 m->msgtag = fcport->msgtag;
3016 m->port_cfg.maxfrsize = cpu_to_be16(fcport->cfg.maxfrsize);
3017 bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa);
3018 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo);
3019 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi);
3020
3021 /*
3022 * queue I/O message to firmware
3023 */
3024 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3025 return BFA_TRUE;
3026 }
3027
3028 /*
3029 * Send port disable message to firmware.
3030 */
3031 static bfa_boolean_t
3032 bfa_fcport_send_disable(struct bfa_fcport_s *fcport)
3033 {
3034 struct bfi_fcport_req_s *m;
3035
3036 /*
3037 * Increment message tag before queue check, so that responses to old
3038 * requests are discarded.
3039 */
3040 fcport->msgtag++;
3041
3042 /*
3043 * check for room in queue to send request now
3044 */
3045 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3046 if (!m) {
3047 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3048 &fcport->reqq_wait);
3049 return BFA_FALSE;
3050 }
3051
3052 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_DISABLE_REQ,
3053 bfa_lpuid(fcport->bfa));
3054 m->msgtag = fcport->msgtag;
3055
3056 /*
3057 * queue I/O message to firmware
3058 */
3059 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3060
3061 return BFA_TRUE;
3062 }
3063
3064 static void
3065 bfa_fcport_set_wwns(struct bfa_fcport_s *fcport)
3066 {
3067 fcport->pwwn = bfa_ioc_get_pwwn(&fcport->bfa->ioc);
3068 fcport->nwwn = bfa_ioc_get_nwwn(&fcport->bfa->ioc);
3069
3070 bfa_trc(fcport->bfa, fcport->pwwn);
3071 bfa_trc(fcport->bfa, fcport->nwwn);
3072 }
3073
3074 static void
3075 bfa_fcport_send_txcredit(void *port_cbarg)
3076 {
3077
3078 struct bfa_fcport_s *fcport = port_cbarg;
3079 struct bfi_fcport_set_svc_params_req_s *m;
3080
3081 /*
3082 * check for room in queue to send request now
3083 */
3084 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3085 if (!m) {
3086 bfa_trc(fcport->bfa, fcport->cfg.tx_bbcredit);
3087 return;
3088 }
3089
3090 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_SET_SVC_PARAMS_REQ,
3091 bfa_lpuid(fcport->bfa));
3092 m->tx_bbcredit = cpu_to_be16((u16)fcport->cfg.tx_bbcredit);
3093
3094 /*
3095 * queue I/O message to firmware
3096 */
3097 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3098 }
3099
3100 static void
3101 bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d,
3102 struct bfa_qos_stats_s *s)
3103 {
3104 u32 *dip = (u32 *) d;
3105 __be32 *sip = (__be32 *) s;
3106 int i;
3107
3108 /* Now swap the 32 bit fields */
3109 for (i = 0; i < (sizeof(struct bfa_qos_stats_s)/sizeof(u32)); ++i)
3110 dip[i] = be32_to_cpu(sip[i]);
3111 }
3112
3113 static void
3114 bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s *d,
3115 struct bfa_fcoe_stats_s *s)
3116 {
3117 u32 *dip = (u32 *) d;
3118 __be32 *sip = (__be32 *) s;
3119 int i;
3120
3121 for (i = 0; i < ((sizeof(struct bfa_fcoe_stats_s))/sizeof(u32));
3122 i = i + 2) {
3123 #ifdef __BIGENDIAN
3124 dip[i] = be32_to_cpu(sip[i]);
3125 dip[i + 1] = be32_to_cpu(sip[i + 1]);
3126 #else
3127 dip[i] = be32_to_cpu(sip[i + 1]);
3128 dip[i + 1] = be32_to_cpu(sip[i]);
3129 #endif
3130 }
3131 }
3132
3133 static void
3134 __bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete)
3135 {
3136 struct bfa_fcport_s *fcport = cbarg;
3137
3138 if (complete) {
3139 if (fcport->stats_status == BFA_STATUS_OK) {
3140 struct bfa_timeval_s tv;
3141
3142 /* Swap FC QoS or FCoE stats */
3143 if (bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
3144 bfa_fcport_qos_stats_swap(
3145 &fcport->stats_ret->fcqos,
3146 &fcport->stats->fcqos);
3147 } else {
3148 bfa_fcport_fcoe_stats_swap(
3149 &fcport->stats_ret->fcoe,
3150 &fcport->stats->fcoe);
3151
3152 bfa_os_gettimeofday(&tv);
3153 fcport->stats_ret->fcoe.secs_reset =
3154 tv.tv_sec - fcport->stats_reset_time;
3155 }
3156 }
3157 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
3158 } else {
3159 fcport->stats_busy = BFA_FALSE;
3160 fcport->stats_status = BFA_STATUS_OK;
3161 }
3162 }
3163
3164 static void
3165 bfa_fcport_stats_get_timeout(void *cbarg)
3166 {
3167 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3168
3169 bfa_trc(fcport->bfa, fcport->stats_qfull);
3170
3171 if (fcport->stats_qfull) {
3172 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
3173 fcport->stats_qfull = BFA_FALSE;
3174 }
3175
3176 fcport->stats_status = BFA_STATUS_ETIMER;
3177 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_fcport_stats_get,
3178 fcport);
3179 }
3180
3181 static void
3182 bfa_fcport_send_stats_get(void *cbarg)
3183 {
3184 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3185 struct bfi_fcport_req_s *msg;
3186
3187 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3188
3189 if (!msg) {
3190 fcport->stats_qfull = BFA_TRUE;
3191 bfa_reqq_winit(&fcport->stats_reqq_wait,
3192 bfa_fcport_send_stats_get, fcport);
3193 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3194 &fcport->stats_reqq_wait);
3195 return;
3196 }
3197 fcport->stats_qfull = BFA_FALSE;
3198
3199 memset(msg, 0, sizeof(struct bfi_fcport_req_s));
3200 bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_GET_REQ,
3201 bfa_lpuid(fcport->bfa));
3202 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3203 }
3204
3205 static void
3206 __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
3207 {
3208 struct bfa_fcport_s *fcport = cbarg;
3209
3210 if (complete) {
3211 struct bfa_timeval_s tv;
3212
3213 /*
3214 * re-initialize time stamp for stats reset
3215 */
3216 bfa_os_gettimeofday(&tv);
3217 fcport->stats_reset_time = tv.tv_sec;
3218
3219 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
3220 } else {
3221 fcport->stats_busy = BFA_FALSE;
3222 fcport->stats_status = BFA_STATUS_OK;
3223 }
3224 }
3225
3226 static void
3227 bfa_fcport_stats_clr_timeout(void *cbarg)
3228 {
3229 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3230
3231 bfa_trc(fcport->bfa, fcport->stats_qfull);
3232
3233 if (fcport->stats_qfull) {
3234 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
3235 fcport->stats_qfull = BFA_FALSE;
3236 }
3237
3238 fcport->stats_status = BFA_STATUS_ETIMER;
3239 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
3240 __bfa_cb_fcport_stats_clr, fcport);
3241 }
3242
3243 static void
3244 bfa_fcport_send_stats_clear(void *cbarg)
3245 {
3246 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3247 struct bfi_fcport_req_s *msg;
3248
3249 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3250
3251 if (!msg) {
3252 fcport->stats_qfull = BFA_TRUE;
3253 bfa_reqq_winit(&fcport->stats_reqq_wait,
3254 bfa_fcport_send_stats_clear, fcport);
3255 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3256 &fcport->stats_reqq_wait);
3257 return;
3258 }
3259 fcport->stats_qfull = BFA_FALSE;
3260
3261 memset(msg, 0, sizeof(struct bfi_fcport_req_s));
3262 bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_CLEAR_REQ,
3263 bfa_lpuid(fcport->bfa));
3264 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3265 }
3266
3267 /*
3268 * Handle trunk SCN event from firmware.
3269 */
3270 static void
3271 bfa_trunk_scn(struct bfa_fcport_s *fcport, struct bfi_fcport_trunk_scn_s *scn)
3272 {
3273 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
3274 struct bfi_fcport_trunk_link_s *tlink;
3275 struct bfa_trunk_link_attr_s *lattr;
3276 enum bfa_trunk_state state_prev;
3277 int i;
3278 int link_bm = 0;
3279
3280 bfa_trc(fcport->bfa, fcport->cfg.trunked);
3281 bfa_assert(scn->trunk_state == BFA_TRUNK_ONLINE ||
3282 scn->trunk_state == BFA_TRUNK_OFFLINE);
3283
3284 bfa_trc(fcport->bfa, trunk->attr.state);
3285 bfa_trc(fcport->bfa, scn->trunk_state);
3286 bfa_trc(fcport->bfa, scn->trunk_speed);
3287
3288 /*
3289 * Save off new state for trunk attribute query
3290 */
3291 state_prev = trunk->attr.state;
3292 if (fcport->cfg.trunked && (trunk->attr.state != BFA_TRUNK_DISABLED))
3293 trunk->attr.state = scn->trunk_state;
3294 trunk->attr.speed = scn->trunk_speed;
3295 for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) {
3296 lattr = &trunk->attr.link_attr[i];
3297 tlink = &scn->tlink[i];
3298
3299 lattr->link_state = tlink->state;
3300 lattr->trunk_wwn = tlink->trunk_wwn;
3301 lattr->fctl = tlink->fctl;
3302 lattr->speed = tlink->speed;
3303 lattr->deskew = be32_to_cpu(tlink->deskew);
3304
3305 if (tlink->state == BFA_TRUNK_LINK_STATE_UP) {
3306 fcport->speed = tlink->speed;
3307 fcport->topology = BFA_PORT_TOPOLOGY_P2P;
3308 link_bm |= 1 << i;
3309 }
3310
3311 bfa_trc(fcport->bfa, lattr->link_state);
3312 bfa_trc(fcport->bfa, lattr->trunk_wwn);
3313 bfa_trc(fcport->bfa, lattr->fctl);
3314 bfa_trc(fcport->bfa, lattr->speed);
3315 bfa_trc(fcport->bfa, lattr->deskew);
3316 }
3317
3318 switch (link_bm) {
3319 case 3:
3320 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3321 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,1)");
3322 break;
3323 case 2:
3324 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3325 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(-,1)");
3326 break;
3327 case 1:
3328 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3329 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,-)");
3330 break;
3331 default:
3332 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3333 BFA_PL_EID_TRUNK_SCN, 0, "Trunk down");
3334 }
3335
3336 /*
3337 * Notify upper layers if trunk state changed.
3338 */
3339 if ((state_prev != trunk->attr.state) ||
3340 (scn->trunk_state == BFA_TRUNK_OFFLINE)) {
3341 bfa_fcport_scn(fcport, (scn->trunk_state == BFA_TRUNK_ONLINE) ?
3342 BFA_PORT_LINKUP : BFA_PORT_LINKDOWN, BFA_TRUE);
3343 }
3344 }
3345
3346 static void
3347 bfa_trunk_iocdisable(struct bfa_s *bfa)
3348 {
3349 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3350 int i = 0;
3351
3352 /*
3353 * In trunked mode, notify upper layers that link is down
3354 */
3355 if (fcport->cfg.trunked) {
3356 if (fcport->trunk.attr.state == BFA_TRUNK_ONLINE)
3357 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_TRUE);
3358
3359 fcport->trunk.attr.state = BFA_TRUNK_OFFLINE;
3360 fcport->trunk.attr.speed = BFA_PORT_SPEED_UNKNOWN;
3361 for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) {
3362 fcport->trunk.attr.link_attr[i].trunk_wwn = 0;
3363 fcport->trunk.attr.link_attr[i].fctl =
3364 BFA_TRUNK_LINK_FCTL_NORMAL;
3365 fcport->trunk.attr.link_attr[i].link_state =
3366 BFA_TRUNK_LINK_STATE_DN_LINKDN;
3367 fcport->trunk.attr.link_attr[i].speed =
3368 BFA_PORT_SPEED_UNKNOWN;
3369 fcport->trunk.attr.link_attr[i].deskew = 0;
3370 }
3371 }
3372 }
3373
3374
3375
3376 /*
3377 * hal_port_public
3378 */
3379
3380 /*
3381 * Called to initialize port attributes
3382 */
3383 void
3384 bfa_fcport_init(struct bfa_s *bfa)
3385 {
3386 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3387
3388 /*
3389 * Initialize port attributes from IOC hardware data.
3390 */
3391 bfa_fcport_set_wwns(fcport);
3392 if (fcport->cfg.maxfrsize == 0)
3393 fcport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc);
3394 fcport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc);
3395 fcport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc);
3396
3397 bfa_assert(fcport->cfg.maxfrsize);
3398 bfa_assert(fcport->cfg.rx_bbcredit);
3399 bfa_assert(fcport->speed_sup);
3400 }
3401
3402 /*
3403 * Firmware message handler.
3404 */
3405 void
3406 bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
3407 {
3408 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3409 union bfi_fcport_i2h_msg_u i2hmsg;
3410
3411 i2hmsg.msg = msg;
3412 fcport->event_arg.i2hmsg = i2hmsg;
3413
3414 bfa_trc(bfa, msg->mhdr.msg_id);
3415 bfa_trc(bfa, bfa_sm_to_state(hal_port_sm_table, fcport->sm));
3416
3417 switch (msg->mhdr.msg_id) {
3418 case BFI_FCPORT_I2H_ENABLE_RSP:
3419 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
3420 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
3421 break;
3422
3423 case BFI_FCPORT_I2H_DISABLE_RSP:
3424 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
3425 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
3426 break;
3427
3428 case BFI_FCPORT_I2H_EVENT:
3429 if (i2hmsg.event->link_state.linkstate == BFA_PORT_LINKUP)
3430 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP);
3431 else
3432 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKDOWN);
3433 break;
3434
3435 case BFI_FCPORT_I2H_TRUNK_SCN:
3436 bfa_trunk_scn(fcport, i2hmsg.trunk_scn);
3437 break;
3438
3439 case BFI_FCPORT_I2H_STATS_GET_RSP:
3440 /*
3441 * check for timer pop before processing the rsp
3442 */
3443 if (fcport->stats_busy == BFA_FALSE ||
3444 fcport->stats_status == BFA_STATUS_ETIMER)
3445 break;
3446
3447 bfa_timer_stop(&fcport->timer);
3448 fcport->stats_status = i2hmsg.pstatsget_rsp->status;
3449 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
3450 __bfa_cb_fcport_stats_get, fcport);
3451 break;
3452
3453 case BFI_FCPORT_I2H_STATS_CLEAR_RSP:
3454 /*
3455 * check for timer pop before processing the rsp
3456 */
3457 if (fcport->stats_busy == BFA_FALSE ||
3458 fcport->stats_status == BFA_STATUS_ETIMER)
3459 break;
3460
3461 bfa_timer_stop(&fcport->timer);
3462 fcport->stats_status = BFA_STATUS_OK;
3463 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
3464 __bfa_cb_fcport_stats_clr, fcport);
3465 break;
3466
3467 case BFI_FCPORT_I2H_ENABLE_AEN:
3468 bfa_sm_send_event(fcport, BFA_FCPORT_SM_ENABLE);
3469 break;
3470
3471 case BFI_FCPORT_I2H_DISABLE_AEN:
3472 bfa_sm_send_event(fcport, BFA_FCPORT_SM_DISABLE);
3473 break;
3474
3475 default:
3476 bfa_assert(0);
3477 break;
3478 }
3479 }
3480
3481
3482
3483 /*
3484 * hal_port_api
3485 */
3486
3487 /*
3488 * Registered callback for port events.
3489 */
3490 void
3491 bfa_fcport_event_register(struct bfa_s *bfa,
3492 void (*cbfn) (void *cbarg,
3493 enum bfa_port_linkstate event),
3494 void *cbarg)
3495 {
3496 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3497
3498 fcport->event_cbfn = cbfn;
3499 fcport->event_cbarg = cbarg;
3500 }
3501
3502 bfa_status_t
3503 bfa_fcport_enable(struct bfa_s *bfa)
3504 {
3505 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3506
3507 if (bfa_ioc_is_disabled(&bfa->ioc))
3508 return BFA_STATUS_IOC_DISABLED;
3509
3510 if (fcport->diag_busy)
3511 return BFA_STATUS_DIAG_BUSY;
3512
3513 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_ENABLE);
3514 return BFA_STATUS_OK;
3515 }
3516
3517 bfa_status_t
3518 bfa_fcport_disable(struct bfa_s *bfa)
3519 {
3520
3521 if (bfa_ioc_is_disabled(&bfa->ioc))
3522 return BFA_STATUS_IOC_DISABLED;
3523
3524 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DISABLE);
3525 return BFA_STATUS_OK;
3526 }
3527
3528 /*
3529 * Configure port speed.
3530 */
3531 bfa_status_t
3532 bfa_fcport_cfg_speed(struct bfa_s *bfa, enum bfa_port_speed speed)
3533 {
3534 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3535
3536 bfa_trc(bfa, speed);
3537
3538 if (fcport->cfg.trunked == BFA_TRUE)
3539 return BFA_STATUS_TRUNK_ENABLED;
3540 if ((speed != BFA_PORT_SPEED_AUTO) && (speed > fcport->speed_sup)) {
3541 bfa_trc(bfa, fcport->speed_sup);
3542 return BFA_STATUS_UNSUPP_SPEED;
3543 }
3544
3545 fcport->cfg.speed = speed;
3546
3547 return BFA_STATUS_OK;
3548 }
3549
3550 /*
3551 * Get current speed.
3552 */
3553 enum bfa_port_speed
3554 bfa_fcport_get_speed(struct bfa_s *bfa)
3555 {
3556 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3557
3558 return fcport->speed;
3559 }
3560
3561 /*
3562 * Configure port topology.
3563 */
3564 bfa_status_t
3565 bfa_fcport_cfg_topology(struct bfa_s *bfa, enum bfa_port_topology topology)
3566 {
3567 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3568
3569 bfa_trc(bfa, topology);
3570 bfa_trc(bfa, fcport->cfg.topology);
3571
3572 switch (topology) {
3573 case BFA_PORT_TOPOLOGY_P2P:
3574 case BFA_PORT_TOPOLOGY_LOOP:
3575 case BFA_PORT_TOPOLOGY_AUTO:
3576 break;
3577
3578 default:
3579 return BFA_STATUS_EINVAL;
3580 }
3581
3582 fcport->cfg.topology = topology;
3583 return BFA_STATUS_OK;
3584 }
3585
3586 /*
3587 * Get current topology.
3588 */
3589 enum bfa_port_topology
3590 bfa_fcport_get_topology(struct bfa_s *bfa)
3591 {
3592 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3593
3594 return fcport->topology;
3595 }
3596
3597 bfa_status_t
3598 bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
3599 {
3600 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3601
3602 bfa_trc(bfa, alpa);
3603 bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
3604 bfa_trc(bfa, fcport->cfg.hardalpa);
3605
3606 fcport->cfg.cfg_hardalpa = BFA_TRUE;
3607 fcport->cfg.hardalpa = alpa;
3608
3609 return BFA_STATUS_OK;
3610 }
3611
3612 bfa_status_t
3613 bfa_fcport_clr_hardalpa(struct bfa_s *bfa)
3614 {
3615 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3616
3617 bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
3618 bfa_trc(bfa, fcport->cfg.hardalpa);
3619
3620 fcport->cfg.cfg_hardalpa = BFA_FALSE;
3621 return BFA_STATUS_OK;
3622 }
3623
3624 bfa_boolean_t
3625 bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa)
3626 {
3627 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3628
3629 *alpa = fcport->cfg.hardalpa;
3630 return fcport->cfg.cfg_hardalpa;
3631 }
3632
3633 u8
3634 bfa_fcport_get_myalpa(struct bfa_s *bfa)
3635 {
3636 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3637
3638 return fcport->myalpa;
3639 }
3640
3641 bfa_status_t
3642 bfa_fcport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
3643 {
3644 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3645
3646 bfa_trc(bfa, maxfrsize);
3647 bfa_trc(bfa, fcport->cfg.maxfrsize);
3648
3649 /* with in range */
3650 if ((maxfrsize > FC_MAX_PDUSZ) || (maxfrsize < FC_MIN_PDUSZ))
3651 return BFA_STATUS_INVLD_DFSZ;
3652
3653 /* power of 2, if not the max frame size of 2112 */
3654 if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1)))
3655 return BFA_STATUS_INVLD_DFSZ;
3656
3657 fcport->cfg.maxfrsize = maxfrsize;
3658 return BFA_STATUS_OK;
3659 }
3660
3661 u16
3662 bfa_fcport_get_maxfrsize(struct bfa_s *bfa)
3663 {
3664 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3665
3666 return fcport->cfg.maxfrsize;
3667 }
3668
3669 u8
3670 bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa)
3671 {
3672 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3673
3674 return fcport->cfg.rx_bbcredit;
3675 }
3676
3677 void
3678 bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit)
3679 {
3680 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3681
3682 fcport->cfg.tx_bbcredit = (u8)tx_bbcredit;
3683 bfa_fcport_send_txcredit(fcport);
3684 }
3685
3686 /*
3687 * Get port attributes.
3688 */
3689
3690 wwn_t
3691 bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node)
3692 {
3693 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3694 if (node)
3695 return fcport->nwwn;
3696 else
3697 return fcport->pwwn;
3698 }
3699
3700 void
3701 bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_port_attr_s *attr)
3702 {
3703 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3704
3705 memset(attr, 0, sizeof(struct bfa_port_attr_s));
3706
3707 attr->nwwn = fcport->nwwn;
3708 attr->pwwn = fcport->pwwn;
3709
3710 attr->factorypwwn = bfa_ioc_get_mfg_pwwn(&bfa->ioc);
3711 attr->factorynwwn = bfa_ioc_get_mfg_nwwn(&bfa->ioc);
3712
3713 memcpy(&attr->pport_cfg, &fcport->cfg,
3714 sizeof(struct bfa_port_cfg_s));
3715 /* speed attributes */
3716 attr->pport_cfg.speed = fcport->cfg.speed;
3717 attr->speed_supported = fcport->speed_sup;
3718 attr->speed = fcport->speed;
3719 attr->cos_supported = FC_CLASS_3;
3720
3721 /* topology attributes */
3722 attr->pport_cfg.topology = fcport->cfg.topology;
3723 attr->topology = fcport->topology;
3724 attr->pport_cfg.trunked = fcport->cfg.trunked;
3725
3726 /* beacon attributes */
3727 attr->beacon = fcport->beacon;
3728 attr->link_e2e_beacon = fcport->link_e2e_beacon;
3729 attr->plog_enabled = bfa_plog_get_setting(fcport->bfa->plog);
3730 attr->io_profile = bfa_fcpim_get_io_profile(fcport->bfa);
3731
3732 attr->pport_cfg.path_tov = bfa_fcpim_path_tov_get(bfa);
3733 attr->pport_cfg.q_depth = bfa_fcpim_qdepth_get(bfa);
3734 attr->port_state = bfa_sm_to_state(hal_port_sm_table, fcport->sm);
3735 if (bfa_ioc_is_disabled(&fcport->bfa->ioc))
3736 attr->port_state = BFA_PORT_ST_IOCDIS;
3737 else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc))
3738 attr->port_state = BFA_PORT_ST_FWMISMATCH;
3739
3740 /* FCoE vlan */
3741 attr->fcoe_vlan = fcport->fcoe_vlan;
3742 }
3743
3744 #define BFA_FCPORT_STATS_TOV 1000
3745
3746 /*
3747 * Fetch port statistics (FCQoS or FCoE).
3748 */
3749 bfa_status_t
3750 bfa_fcport_get_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
3751 bfa_cb_port_t cbfn, void *cbarg)
3752 {
3753 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3754
3755 if (fcport->stats_busy) {
3756 bfa_trc(bfa, fcport->stats_busy);
3757 return BFA_STATUS_DEVBUSY;
3758 }
3759
3760 fcport->stats_busy = BFA_TRUE;
3761 fcport->stats_ret = stats;
3762 fcport->stats_cbfn = cbfn;
3763 fcport->stats_cbarg = cbarg;
3764
3765 bfa_fcport_send_stats_get(fcport);
3766
3767 bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_get_timeout,
3768 fcport, BFA_FCPORT_STATS_TOV);
3769 return BFA_STATUS_OK;
3770 }
3771
3772 /*
3773 * Reset port statistics (FCQoS or FCoE).
3774 */
3775 bfa_status_t
3776 bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_port_t cbfn, void *cbarg)
3777 {
3778 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3779
3780 if (fcport->stats_busy) {
3781 bfa_trc(bfa, fcport->stats_busy);
3782 return BFA_STATUS_DEVBUSY;
3783 }
3784
3785 fcport->stats_busy = BFA_TRUE;
3786 fcport->stats_cbfn = cbfn;
3787 fcport->stats_cbarg = cbarg;
3788
3789 bfa_fcport_send_stats_clear(fcport);
3790
3791 bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_clr_timeout,
3792 fcport, BFA_FCPORT_STATS_TOV);
3793 return BFA_STATUS_OK;
3794 }
3795
3796
3797 /*
3798 * Fetch port attributes.
3799 */
3800 bfa_boolean_t
3801 bfa_fcport_is_disabled(struct bfa_s *bfa)
3802 {
3803 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3804
3805 return bfa_sm_to_state(hal_port_sm_table, fcport->sm) ==
3806 BFA_PORT_ST_DISABLED;
3807
3808 }
3809
3810 bfa_boolean_t
3811 bfa_fcport_is_ratelim(struct bfa_s *bfa)
3812 {
3813 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3814
3815 return fcport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE;
3816
3817 }
3818
3819
3820 /*
3821 * Get default minimum ratelim speed
3822 */
3823 enum bfa_port_speed
3824 bfa_fcport_get_ratelim_speed(struct bfa_s *bfa)
3825 {
3826 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3827
3828 bfa_trc(bfa, fcport->cfg.trl_def_speed);
3829 return fcport->cfg.trl_def_speed;
3830
3831 }
3832
3833 bfa_boolean_t
3834 bfa_fcport_is_linkup(struct bfa_s *bfa)
3835 {
3836 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3837
3838 return (!fcport->cfg.trunked &&
3839 bfa_sm_cmp_state(fcport, bfa_fcport_sm_linkup)) ||
3840 (fcport->cfg.trunked &&
3841 fcport->trunk.attr.state == BFA_TRUNK_ONLINE);
3842 }
3843
3844 bfa_boolean_t
3845 bfa_fcport_is_qos_enabled(struct bfa_s *bfa)
3846 {
3847 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3848
3849 return fcport->cfg.qos_enabled;
3850 }
3851
3852 /*
3853 * Rport State machine functions
3854 */
3855 /*
3856 * Beginning state, only online event expected.
3857 */
3858 static void
3859 bfa_rport_sm_uninit(struct bfa_rport_s *rp, enum bfa_rport_event event)
3860 {
3861 bfa_trc(rp->bfa, rp->rport_tag);
3862 bfa_trc(rp->bfa, event);
3863
3864 switch (event) {
3865 case BFA_RPORT_SM_CREATE:
3866 bfa_stats(rp, sm_un_cr);
3867 bfa_sm_set_state(rp, bfa_rport_sm_created);
3868 break;
3869
3870 default:
3871 bfa_stats(rp, sm_un_unexp);
3872 bfa_sm_fault(rp->bfa, event);
3873 }
3874 }
3875
3876 static void
3877 bfa_rport_sm_created(struct bfa_rport_s *rp, enum bfa_rport_event event)
3878 {
3879 bfa_trc(rp->bfa, rp->rport_tag);
3880 bfa_trc(rp->bfa, event);
3881
3882 switch (event) {
3883 case BFA_RPORT_SM_ONLINE:
3884 bfa_stats(rp, sm_cr_on);
3885 if (bfa_rport_send_fwcreate(rp))
3886 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
3887 else
3888 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
3889 break;
3890
3891 case BFA_RPORT_SM_DELETE:
3892 bfa_stats(rp, sm_cr_del);
3893 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
3894 bfa_rport_free(rp);
3895 break;
3896
3897 case BFA_RPORT_SM_HWFAIL:
3898 bfa_stats(rp, sm_cr_hwf);
3899 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
3900 break;
3901
3902 default:
3903 bfa_stats(rp, sm_cr_unexp);
3904 bfa_sm_fault(rp->bfa, event);
3905 }
3906 }
3907
3908 /*
3909 * Waiting for rport create response from firmware.
3910 */
3911 static void
3912 bfa_rport_sm_fwcreate(struct bfa_rport_s *rp, enum bfa_rport_event event)
3913 {
3914 bfa_trc(rp->bfa, rp->rport_tag);
3915 bfa_trc(rp->bfa, event);
3916
3917 switch (event) {
3918 case BFA_RPORT_SM_FWRSP:
3919 bfa_stats(rp, sm_fwc_rsp);
3920 bfa_sm_set_state(rp, bfa_rport_sm_online);
3921 bfa_rport_online_cb(rp);
3922 break;
3923
3924 case BFA_RPORT_SM_DELETE:
3925 bfa_stats(rp, sm_fwc_del);
3926 bfa_sm_set_state(rp, bfa_rport_sm_delete_pending);
3927 break;
3928
3929 case BFA_RPORT_SM_OFFLINE:
3930 bfa_stats(rp, sm_fwc_off);
3931 bfa_sm_set_state(rp, bfa_rport_sm_offline_pending);
3932 break;
3933
3934 case BFA_RPORT_SM_HWFAIL:
3935 bfa_stats(rp, sm_fwc_hwf);
3936 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
3937 break;
3938
3939 default:
3940 bfa_stats(rp, sm_fwc_unexp);
3941 bfa_sm_fault(rp->bfa, event);
3942 }
3943 }
3944
3945 /*
3946 * Request queue is full, awaiting queue resume to send create request.
3947 */
3948 static void
3949 bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
3950 {
3951 bfa_trc(rp->bfa, rp->rport_tag);
3952 bfa_trc(rp->bfa, event);
3953
3954 switch (event) {
3955 case BFA_RPORT_SM_QRESUME:
3956 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
3957 bfa_rport_send_fwcreate(rp);
3958 break;
3959
3960 case BFA_RPORT_SM_DELETE:
3961 bfa_stats(rp, sm_fwc_del);
3962 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
3963 bfa_reqq_wcancel(&rp->reqq_wait);
3964 bfa_rport_free(rp);
3965 break;
3966
3967 case BFA_RPORT_SM_OFFLINE:
3968 bfa_stats(rp, sm_fwc_off);
3969 bfa_sm_set_state(rp, bfa_rport_sm_offline);
3970 bfa_reqq_wcancel(&rp->reqq_wait);
3971 bfa_rport_offline_cb(rp);
3972 break;
3973
3974 case BFA_RPORT_SM_HWFAIL:
3975 bfa_stats(rp, sm_fwc_hwf);
3976 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
3977 bfa_reqq_wcancel(&rp->reqq_wait);
3978 break;
3979
3980 default:
3981 bfa_stats(rp, sm_fwc_unexp);
3982 bfa_sm_fault(rp->bfa, event);
3983 }
3984 }
3985
3986 /*
3987 * Online state - normal parking state.
3988 */
3989 static void
3990 bfa_rport_sm_online(struct bfa_rport_s *rp, enum bfa_rport_event event)
3991 {
3992 struct bfi_rport_qos_scn_s *qos_scn;
3993
3994 bfa_trc(rp->bfa, rp->rport_tag);
3995 bfa_trc(rp->bfa, event);
3996
3997 switch (event) {
3998 case BFA_RPORT_SM_OFFLINE:
3999 bfa_stats(rp, sm_on_off);
4000 if (bfa_rport_send_fwdelete(rp))
4001 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4002 else
4003 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull);
4004 break;
4005
4006 case BFA_RPORT_SM_DELETE:
4007 bfa_stats(rp, sm_on_del);
4008 if (bfa_rport_send_fwdelete(rp))
4009 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4010 else
4011 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4012 break;
4013
4014 case BFA_RPORT_SM_HWFAIL:
4015 bfa_stats(rp, sm_on_hwf);
4016 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4017 break;
4018
4019 case BFA_RPORT_SM_SET_SPEED:
4020 bfa_rport_send_fwspeed(rp);
4021 break;
4022
4023 case BFA_RPORT_SM_QOS_SCN:
4024 qos_scn = (struct bfi_rport_qos_scn_s *) rp->event_arg.fw_msg;
4025 rp->qos_attr = qos_scn->new_qos_attr;
4026 bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_flow_id);
4027 bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_flow_id);
4028 bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_priority);
4029 bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_priority);
4030
4031 qos_scn->old_qos_attr.qos_flow_id =
4032 be32_to_cpu(qos_scn->old_qos_attr.qos_flow_id);
4033 qos_scn->new_qos_attr.qos_flow_id =
4034 be32_to_cpu(qos_scn->new_qos_attr.qos_flow_id);
4035
4036 if (qos_scn->old_qos_attr.qos_flow_id !=
4037 qos_scn->new_qos_attr.qos_flow_id)
4038 bfa_cb_rport_qos_scn_flowid(rp->rport_drv,
4039 qos_scn->old_qos_attr,
4040 qos_scn->new_qos_attr);
4041 if (qos_scn->old_qos_attr.qos_priority !=
4042 qos_scn->new_qos_attr.qos_priority)
4043 bfa_cb_rport_qos_scn_prio(rp->rport_drv,
4044 qos_scn->old_qos_attr,
4045 qos_scn->new_qos_attr);
4046 break;
4047
4048 default:
4049 bfa_stats(rp, sm_on_unexp);
4050 bfa_sm_fault(rp->bfa, event);
4051 }
4052 }
4053
4054 /*
4055 * Firmware rport is being deleted - awaiting f/w response.
4056 */
4057 static void
4058 bfa_rport_sm_fwdelete(struct bfa_rport_s *rp, enum bfa_rport_event event)
4059 {
4060 bfa_trc(rp->bfa, rp->rport_tag);
4061 bfa_trc(rp->bfa, event);
4062
4063 switch (event) {
4064 case BFA_RPORT_SM_FWRSP:
4065 bfa_stats(rp, sm_fwd_rsp);
4066 bfa_sm_set_state(rp, bfa_rport_sm_offline);
4067 bfa_rport_offline_cb(rp);
4068 break;
4069
4070 case BFA_RPORT_SM_DELETE:
4071 bfa_stats(rp, sm_fwd_del);
4072 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4073 break;
4074
4075 case BFA_RPORT_SM_HWFAIL:
4076 bfa_stats(rp, sm_fwd_hwf);
4077 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4078 bfa_rport_offline_cb(rp);
4079 break;
4080
4081 default:
4082 bfa_stats(rp, sm_fwd_unexp);
4083 bfa_sm_fault(rp->bfa, event);
4084 }
4085 }
4086
4087 static void
4088 bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4089 {
4090 bfa_trc(rp->bfa, rp->rport_tag);
4091 bfa_trc(rp->bfa, event);
4092
4093 switch (event) {
4094 case BFA_RPORT_SM_QRESUME:
4095 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4096 bfa_rport_send_fwdelete(rp);
4097 break;
4098
4099 case BFA_RPORT_SM_DELETE:
4100 bfa_stats(rp, sm_fwd_del);
4101 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4102 break;
4103
4104 case BFA_RPORT_SM_HWFAIL:
4105 bfa_stats(rp, sm_fwd_hwf);
4106 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4107 bfa_reqq_wcancel(&rp->reqq_wait);
4108 bfa_rport_offline_cb(rp);
4109 break;
4110
4111 default:
4112 bfa_stats(rp, sm_fwd_unexp);
4113 bfa_sm_fault(rp->bfa, event);
4114 }
4115 }
4116
4117 /*
4118 * Offline state.
4119 */
4120 static void
4121 bfa_rport_sm_offline(struct bfa_rport_s *rp, enum bfa_rport_event event)
4122 {
4123 bfa_trc(rp->bfa, rp->rport_tag);
4124 bfa_trc(rp->bfa, event);
4125
4126 switch (event) {
4127 case BFA_RPORT_SM_DELETE:
4128 bfa_stats(rp, sm_off_del);
4129 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4130 bfa_rport_free(rp);
4131 break;
4132
4133 case BFA_RPORT_SM_ONLINE:
4134 bfa_stats(rp, sm_off_on);
4135 if (bfa_rport_send_fwcreate(rp))
4136 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4137 else
4138 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4139 break;
4140
4141 case BFA_RPORT_SM_HWFAIL:
4142 bfa_stats(rp, sm_off_hwf);
4143 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4144 break;
4145
4146 default:
4147 bfa_stats(rp, sm_off_unexp);
4148 bfa_sm_fault(rp->bfa, event);
4149 }
4150 }
4151
4152 /*
4153 * Rport is deleted, waiting for firmware response to delete.
4154 */
4155 static void
4156 bfa_rport_sm_deleting(struct bfa_rport_s *rp, enum bfa_rport_event event)
4157 {
4158 bfa_trc(rp->bfa, rp->rport_tag);
4159 bfa_trc(rp->bfa, event);
4160
4161 switch (event) {
4162 case BFA_RPORT_SM_FWRSP:
4163 bfa_stats(rp, sm_del_fwrsp);
4164 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4165 bfa_rport_free(rp);
4166 break;
4167
4168 case BFA_RPORT_SM_HWFAIL:
4169 bfa_stats(rp, sm_del_hwf);
4170 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4171 bfa_rport_free(rp);
4172 break;
4173
4174 default:
4175 bfa_sm_fault(rp->bfa, event);
4176 }
4177 }
4178
4179 static void
4180 bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4181 {
4182 bfa_trc(rp->bfa, rp->rport_tag);
4183 bfa_trc(rp->bfa, event);
4184
4185 switch (event) {
4186 case BFA_RPORT_SM_QRESUME:
4187 bfa_stats(rp, sm_del_fwrsp);
4188 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4189 bfa_rport_send_fwdelete(rp);
4190 break;
4191
4192 case BFA_RPORT_SM_HWFAIL:
4193 bfa_stats(rp, sm_del_hwf);
4194 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4195 bfa_reqq_wcancel(&rp->reqq_wait);
4196 bfa_rport_free(rp);
4197 break;
4198
4199 default:
4200 bfa_sm_fault(rp->bfa, event);
4201 }
4202 }
4203
4204 /*
4205 * Waiting for rport create response from firmware. A delete is pending.
4206 */
4207 static void
4208 bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
4209 enum bfa_rport_event event)
4210 {
4211 bfa_trc(rp->bfa, rp->rport_tag);
4212 bfa_trc(rp->bfa, event);
4213
4214 switch (event) {
4215 case BFA_RPORT_SM_FWRSP:
4216 bfa_stats(rp, sm_delp_fwrsp);
4217 if (bfa_rport_send_fwdelete(rp))
4218 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4219 else
4220 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4221 break;
4222
4223 case BFA_RPORT_SM_HWFAIL:
4224 bfa_stats(rp, sm_delp_hwf);
4225 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4226 bfa_rport_free(rp);
4227 break;
4228
4229 default:
4230 bfa_stats(rp, sm_delp_unexp);
4231 bfa_sm_fault(rp->bfa, event);
4232 }
4233 }
4234
4235 /*
4236 * Waiting for rport create response from firmware. Rport offline is pending.
4237 */
4238 static void
4239 bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
4240 enum bfa_rport_event event)
4241 {
4242 bfa_trc(rp->bfa, rp->rport_tag);
4243 bfa_trc(rp->bfa, event);
4244
4245 switch (event) {
4246 case BFA_RPORT_SM_FWRSP:
4247 bfa_stats(rp, sm_offp_fwrsp);
4248 if (bfa_rport_send_fwdelete(rp))
4249 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4250 else
4251 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull);
4252 break;
4253
4254 case BFA_RPORT_SM_DELETE:
4255 bfa_stats(rp, sm_offp_del);
4256 bfa_sm_set_state(rp, bfa_rport_sm_delete_pending);
4257 break;
4258
4259 case BFA_RPORT_SM_HWFAIL:
4260 bfa_stats(rp, sm_offp_hwf);
4261 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4262 break;
4263
4264 default:
4265 bfa_stats(rp, sm_offp_unexp);
4266 bfa_sm_fault(rp->bfa, event);
4267 }
4268 }
4269
4270 /*
4271 * IOC h/w failed.
4272 */
4273 static void
4274 bfa_rport_sm_iocdisable(struct bfa_rport_s *rp, enum bfa_rport_event event)
4275 {
4276 bfa_trc(rp->bfa, rp->rport_tag);
4277 bfa_trc(rp->bfa, event);
4278
4279 switch (event) {
4280 case BFA_RPORT_SM_OFFLINE:
4281 bfa_stats(rp, sm_iocd_off);
4282 bfa_rport_offline_cb(rp);
4283 break;
4284
4285 case BFA_RPORT_SM_DELETE:
4286 bfa_stats(rp, sm_iocd_del);
4287 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4288 bfa_rport_free(rp);
4289 break;
4290
4291 case BFA_RPORT_SM_ONLINE:
4292 bfa_stats(rp, sm_iocd_on);
4293 if (bfa_rport_send_fwcreate(rp))
4294 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4295 else
4296 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4297 break;
4298
4299 case BFA_RPORT_SM_HWFAIL:
4300 break;
4301
4302 default:
4303 bfa_stats(rp, sm_iocd_unexp);
4304 bfa_sm_fault(rp->bfa, event);
4305 }
4306 }
4307
4308
4309
4310 /*
4311 * bfa_rport_private BFA rport private functions
4312 */
4313
4314 static void
4315 __bfa_cb_rport_online(void *cbarg, bfa_boolean_t complete)
4316 {
4317 struct bfa_rport_s *rp = cbarg;
4318
4319 if (complete)
4320 bfa_cb_rport_online(rp->rport_drv);
4321 }
4322
4323 static void
4324 __bfa_cb_rport_offline(void *cbarg, bfa_boolean_t complete)
4325 {
4326 struct bfa_rport_s *rp = cbarg;
4327
4328 if (complete)
4329 bfa_cb_rport_offline(rp->rport_drv);
4330 }
4331
4332 static void
4333 bfa_rport_qresume(void *cbarg)
4334 {
4335 struct bfa_rport_s *rp = cbarg;
4336
4337 bfa_sm_send_event(rp, BFA_RPORT_SM_QRESUME);
4338 }
4339
4340 static void
4341 bfa_rport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len,
4342 u32 *dm_len)
4343 {
4344 if (cfg->fwcfg.num_rports < BFA_RPORT_MIN)
4345 cfg->fwcfg.num_rports = BFA_RPORT_MIN;
4346
4347 *km_len += cfg->fwcfg.num_rports * sizeof(struct bfa_rport_s);
4348 }
4349
4350 static void
4351 bfa_rport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4352 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
4353 {
4354 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4355 struct bfa_rport_s *rp;
4356 u16 i;
4357
4358 INIT_LIST_HEAD(&mod->rp_free_q);
4359 INIT_LIST_HEAD(&mod->rp_active_q);
4360
4361 rp = (struct bfa_rport_s *) bfa_meminfo_kva(meminfo);
4362 mod->rps_list = rp;
4363 mod->num_rports = cfg->fwcfg.num_rports;
4364
4365 bfa_assert(mod->num_rports &&
4366 !(mod->num_rports & (mod->num_rports - 1)));
4367
4368 for (i = 0; i < mod->num_rports; i++, rp++) {
4369 memset(rp, 0, sizeof(struct bfa_rport_s));
4370 rp->bfa = bfa;
4371 rp->rport_tag = i;
4372 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4373
4374 /*
4375 * - is unused
4376 */
4377 if (i)
4378 list_add_tail(&rp->qe, &mod->rp_free_q);
4379
4380 bfa_reqq_winit(&rp->reqq_wait, bfa_rport_qresume, rp);
4381 }
4382
4383 /*
4384 * consume memory
4385 */
4386 bfa_meminfo_kva(meminfo) = (u8 *) rp;
4387 }
4388
4389 static void
4390 bfa_rport_detach(struct bfa_s *bfa)
4391 {
4392 }
4393
4394 static void
4395 bfa_rport_start(struct bfa_s *bfa)
4396 {
4397 }
4398
4399 static void
4400 bfa_rport_stop(struct bfa_s *bfa)
4401 {
4402 }
4403
4404 static void
4405 bfa_rport_iocdisable(struct bfa_s *bfa)
4406 {
4407 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4408 struct bfa_rport_s *rport;
4409 struct list_head *qe, *qen;
4410
4411 list_for_each_safe(qe, qen, &mod->rp_active_q) {
4412 rport = (struct bfa_rport_s *) qe;
4413 bfa_sm_send_event(rport, BFA_RPORT_SM_HWFAIL);
4414 }
4415 }
4416
4417 static struct bfa_rport_s *
4418 bfa_rport_alloc(struct bfa_rport_mod_s *mod)
4419 {
4420 struct bfa_rport_s *rport;
4421
4422 bfa_q_deq(&mod->rp_free_q, &rport);
4423 if (rport)
4424 list_add_tail(&rport->qe, &mod->rp_active_q);
4425
4426 return rport;
4427 }
4428
4429 static void
4430 bfa_rport_free(struct bfa_rport_s *rport)
4431 {
4432 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(rport->bfa);
4433
4434 bfa_assert(bfa_q_is_on_q(&mod->rp_active_q, rport));
4435 list_del(&rport->qe);
4436 list_add_tail(&rport->qe, &mod->rp_free_q);
4437 }
4438
4439 static bfa_boolean_t
4440 bfa_rport_send_fwcreate(struct bfa_rport_s *rp)
4441 {
4442 struct bfi_rport_create_req_s *m;
4443
4444 /*
4445 * check for room in queue to send request now
4446 */
4447 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4448 if (!m) {
4449 bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait);
4450 return BFA_FALSE;
4451 }
4452
4453 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_CREATE_REQ,
4454 bfa_lpuid(rp->bfa));
4455 m->bfa_handle = rp->rport_tag;
4456 m->max_frmsz = cpu_to_be16(rp->rport_info.max_frmsz);
4457 m->pid = rp->rport_info.pid;
4458 m->lp_tag = rp->rport_info.lp_tag;
4459 m->local_pid = rp->rport_info.local_pid;
4460 m->fc_class = rp->rport_info.fc_class;
4461 m->vf_en = rp->rport_info.vf_en;
4462 m->vf_id = rp->rport_info.vf_id;
4463 m->cisc = rp->rport_info.cisc;
4464
4465 /*
4466 * queue I/O message to firmware
4467 */
4468 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT);
4469 return BFA_TRUE;
4470 }
4471
4472 static bfa_boolean_t
4473 bfa_rport_send_fwdelete(struct bfa_rport_s *rp)
4474 {
4475 struct bfi_rport_delete_req_s *m;
4476
4477 /*
4478 * check for room in queue to send request now
4479 */
4480 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4481 if (!m) {
4482 bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait);
4483 return BFA_FALSE;
4484 }
4485
4486 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_DELETE_REQ,
4487 bfa_lpuid(rp->bfa));
4488 m->fw_handle = rp->fw_handle;
4489
4490 /*
4491 * queue I/O message to firmware
4492 */
4493 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT);
4494 return BFA_TRUE;
4495 }
4496
4497 static bfa_boolean_t
4498 bfa_rport_send_fwspeed(struct bfa_rport_s *rp)
4499 {
4500 struct bfa_rport_speed_req_s *m;
4501
4502 /*
4503 * check for room in queue to send request now
4504 */
4505 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4506 if (!m) {
4507 bfa_trc(rp->bfa, rp->rport_info.speed);
4508 return BFA_FALSE;
4509 }
4510
4511 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_SET_SPEED_REQ,
4512 bfa_lpuid(rp->bfa));
4513 m->fw_handle = rp->fw_handle;
4514 m->speed = (u8)rp->rport_info.speed;
4515
4516 /*
4517 * queue I/O message to firmware
4518 */
4519 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT);
4520 return BFA_TRUE;
4521 }
4522
4523
4524
4525 /*
4526 * bfa_rport_public
4527 */
4528
4529 /*
4530 * Rport interrupt processing.
4531 */
4532 void
4533 bfa_rport_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
4534 {
4535 union bfi_rport_i2h_msg_u msg;
4536 struct bfa_rport_s *rp;
4537
4538 bfa_trc(bfa, m->mhdr.msg_id);
4539
4540 msg.msg = m;
4541
4542 switch (m->mhdr.msg_id) {
4543 case BFI_RPORT_I2H_CREATE_RSP:
4544 rp = BFA_RPORT_FROM_TAG(bfa, msg.create_rsp->bfa_handle);
4545 rp->fw_handle = msg.create_rsp->fw_handle;
4546 rp->qos_attr = msg.create_rsp->qos_attr;
4547 bfa_assert(msg.create_rsp->status == BFA_STATUS_OK);
4548 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
4549 break;
4550
4551 case BFI_RPORT_I2H_DELETE_RSP:
4552 rp = BFA_RPORT_FROM_TAG(bfa, msg.delete_rsp->bfa_handle);
4553 bfa_assert(msg.delete_rsp->status == BFA_STATUS_OK);
4554 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
4555 break;
4556
4557 case BFI_RPORT_I2H_QOS_SCN:
4558 rp = BFA_RPORT_FROM_TAG(bfa, msg.qos_scn_evt->bfa_handle);
4559 rp->event_arg.fw_msg = msg.qos_scn_evt;
4560 bfa_sm_send_event(rp, BFA_RPORT_SM_QOS_SCN);
4561 break;
4562
4563 default:
4564 bfa_trc(bfa, m->mhdr.msg_id);
4565 bfa_assert(0);
4566 }
4567 }
4568
4569
4570
4571 /*
4572 * bfa_rport_api
4573 */
4574
4575 struct bfa_rport_s *
4576 bfa_rport_create(struct bfa_s *bfa, void *rport_drv)
4577 {
4578 struct bfa_rport_s *rp;
4579
4580 rp = bfa_rport_alloc(BFA_RPORT_MOD(bfa));
4581
4582 if (rp == NULL)
4583 return NULL;
4584
4585 rp->bfa = bfa;
4586 rp->rport_drv = rport_drv;
4587 bfa_rport_clear_stats(rp);
4588
4589 bfa_assert(bfa_sm_cmp_state(rp, bfa_rport_sm_uninit));
4590 bfa_sm_send_event(rp, BFA_RPORT_SM_CREATE);
4591
4592 return rp;
4593 }
4594
4595 void
4596 bfa_rport_delete(struct bfa_rport_s *rport)
4597 {
4598 bfa_sm_send_event(rport, BFA_RPORT_SM_DELETE);
4599 }
4600
4601 void
4602 bfa_rport_online(struct bfa_rport_s *rport, struct bfa_rport_info_s *rport_info)
4603 {
4604 bfa_assert(rport_info->max_frmsz != 0);
4605
4606 /*
4607 * Some JBODs are seen to be not setting PDU size correctly in PLOGI
4608 * responses. Default to minimum size.
4609 */
4610 if (rport_info->max_frmsz == 0) {
4611 bfa_trc(rport->bfa, rport->rport_tag);
4612 rport_info->max_frmsz = FC_MIN_PDUSZ;
4613 }
4614
4615 rport->rport_info = *rport_info;
4616 bfa_sm_send_event(rport, BFA_RPORT_SM_ONLINE);
4617 }
4618
4619 void
4620 bfa_rport_offline(struct bfa_rport_s *rport)
4621 {
4622 bfa_sm_send_event(rport, BFA_RPORT_SM_OFFLINE);
4623 }
4624
4625 void
4626 bfa_rport_speed(struct bfa_rport_s *rport, enum bfa_port_speed speed)
4627 {
4628 bfa_assert(speed != 0);
4629 bfa_assert(speed != BFA_PORT_SPEED_AUTO);
4630
4631 rport->rport_info.speed = speed;
4632 bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED);
4633 }
4634
4635 void
4636 bfa_rport_clear_stats(struct bfa_rport_s *rport)
4637 {
4638 memset(&rport->stats, 0, sizeof(rport->stats));
4639 }
4640
4641
4642 /*
4643 * SGPG related functions
4644 */
4645
4646 /*
4647 * Compute and return memory needed by FCP(im) module.
4648 */
4649 static void
4650 bfa_sgpg_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len,
4651 u32 *dm_len)
4652 {
4653 if (cfg->drvcfg.num_sgpgs < BFA_SGPG_MIN)
4654 cfg->drvcfg.num_sgpgs = BFA_SGPG_MIN;
4655
4656 *km_len += (cfg->drvcfg.num_sgpgs + 1) * sizeof(struct bfa_sgpg_s);
4657 *dm_len += (cfg->drvcfg.num_sgpgs + 1) * sizeof(struct bfi_sgpg_s);
4658 }
4659
4660
4661 static void
4662 bfa_sgpg_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4663 struct bfa_meminfo_s *minfo, struct bfa_pcidev_s *pcidev)
4664 {
4665 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4666 int i;
4667 struct bfa_sgpg_s *hsgpg;
4668 struct bfi_sgpg_s *sgpg;
4669 u64 align_len;
4670
4671 union {
4672 u64 pa;
4673 union bfi_addr_u addr;
4674 } sgpg_pa, sgpg_pa_tmp;
4675
4676 INIT_LIST_HEAD(&mod->sgpg_q);
4677 INIT_LIST_HEAD(&mod->sgpg_wait_q);
4678
4679 bfa_trc(bfa, cfg->drvcfg.num_sgpgs);
4680
4681 mod->num_sgpgs = cfg->drvcfg.num_sgpgs;
4682 mod->sgpg_arr_pa = bfa_meminfo_dma_phys(minfo);
4683 align_len = (BFA_SGPG_ROUNDUP(mod->sgpg_arr_pa) - mod->sgpg_arr_pa);
4684 mod->sgpg_arr_pa += align_len;
4685 mod->hsgpg_arr = (struct bfa_sgpg_s *) (bfa_meminfo_kva(minfo) +
4686 align_len);
4687 mod->sgpg_arr = (struct bfi_sgpg_s *) (bfa_meminfo_dma_virt(minfo) +
4688 align_len);
4689
4690 hsgpg = mod->hsgpg_arr;
4691 sgpg = mod->sgpg_arr;
4692 sgpg_pa.pa = mod->sgpg_arr_pa;
4693 mod->free_sgpgs = mod->num_sgpgs;
4694
4695 bfa_assert(!(sgpg_pa.pa & (sizeof(struct bfi_sgpg_s) - 1)));
4696
4697 for (i = 0; i < mod->num_sgpgs; i++) {
4698 memset(hsgpg, 0, sizeof(*hsgpg));
4699 memset(sgpg, 0, sizeof(*sgpg));
4700
4701 hsgpg->sgpg = sgpg;
4702 sgpg_pa_tmp.pa = bfa_sgaddr_le(sgpg_pa.pa);
4703 hsgpg->sgpg_pa = sgpg_pa_tmp.addr;
4704 list_add_tail(&hsgpg->qe, &mod->sgpg_q);
4705
4706 hsgpg++;
4707 sgpg++;
4708 sgpg_pa.pa += sizeof(struct bfi_sgpg_s);
4709 }
4710
4711 bfa_meminfo_kva(minfo) = (u8 *) hsgpg;
4712 bfa_meminfo_dma_virt(minfo) = (u8 *) sgpg;
4713 bfa_meminfo_dma_phys(minfo) = sgpg_pa.pa;
4714 }
4715
4716 static void
4717 bfa_sgpg_detach(struct bfa_s *bfa)
4718 {
4719 }
4720
4721 static void
4722 bfa_sgpg_start(struct bfa_s *bfa)
4723 {
4724 }
4725
4726 static void
4727 bfa_sgpg_stop(struct bfa_s *bfa)
4728 {
4729 }
4730
4731 static void
4732 bfa_sgpg_iocdisable(struct bfa_s *bfa)
4733 {
4734 }
4735
4736
4737
4738 /*
4739 * hal_sgpg_public BFA SGPG public functions
4740 */
4741
4742 bfa_status_t
4743 bfa_sgpg_malloc(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpgs)
4744 {
4745 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4746 struct bfa_sgpg_s *hsgpg;
4747 int i;
4748
4749 bfa_trc_fp(bfa, nsgpgs);
4750
4751 if (mod->free_sgpgs < nsgpgs)
4752 return BFA_STATUS_ENOMEM;
4753
4754 for (i = 0; i < nsgpgs; i++) {
4755 bfa_q_deq(&mod->sgpg_q, &hsgpg);
4756 bfa_assert(hsgpg);
4757 list_add_tail(&hsgpg->qe, sgpg_q);
4758 }
4759
4760 mod->free_sgpgs -= nsgpgs;
4761 return BFA_STATUS_OK;
4762 }
4763
4764 void
4765 bfa_sgpg_mfree(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpg)
4766 {
4767 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4768 struct bfa_sgpg_wqe_s *wqe;
4769
4770 bfa_trc_fp(bfa, nsgpg);
4771
4772 mod->free_sgpgs += nsgpg;
4773 bfa_assert(mod->free_sgpgs <= mod->num_sgpgs);
4774
4775 list_splice_tail_init(sgpg_q, &mod->sgpg_q);
4776
4777 if (list_empty(&mod->sgpg_wait_q))
4778 return;
4779
4780 /*
4781 * satisfy as many waiting requests as possible
4782 */
4783 do {
4784 wqe = bfa_q_first(&mod->sgpg_wait_q);
4785 if (mod->free_sgpgs < wqe->nsgpg)
4786 nsgpg = mod->free_sgpgs;
4787 else
4788 nsgpg = wqe->nsgpg;
4789 bfa_sgpg_malloc(bfa, &wqe->sgpg_q, nsgpg);
4790 wqe->nsgpg -= nsgpg;
4791 if (wqe->nsgpg == 0) {
4792 list_del(&wqe->qe);
4793 wqe->cbfn(wqe->cbarg);
4794 }
4795 } while (mod->free_sgpgs && !list_empty(&mod->sgpg_wait_q));
4796 }
4797
4798 void
4799 bfa_sgpg_wait(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe, int nsgpg)
4800 {
4801 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4802
4803 bfa_assert(nsgpg > 0);
4804 bfa_assert(nsgpg > mod->free_sgpgs);
4805
4806 wqe->nsgpg_total = wqe->nsgpg = nsgpg;
4807
4808 /*
4809 * allocate any left to this one first
4810 */
4811 if (mod->free_sgpgs) {
4812 /*
4813 * no one else is waiting for SGPG
4814 */
4815 bfa_assert(list_empty(&mod->sgpg_wait_q));
4816 list_splice_tail_init(&mod->sgpg_q, &wqe->sgpg_q);
4817 wqe->nsgpg -= mod->free_sgpgs;
4818 mod->free_sgpgs = 0;
4819 }
4820
4821 list_add_tail(&wqe->qe, &mod->sgpg_wait_q);
4822 }
4823
4824 void
4825 bfa_sgpg_wcancel(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe)
4826 {
4827 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4828
4829 bfa_assert(bfa_q_is_on_q(&mod->sgpg_wait_q, wqe));
4830 list_del(&wqe->qe);
4831
4832 if (wqe->nsgpg_total != wqe->nsgpg)
4833 bfa_sgpg_mfree(bfa, &wqe->sgpg_q,
4834 wqe->nsgpg_total - wqe->nsgpg);
4835 }
4836
4837 void
4838 bfa_sgpg_winit(struct bfa_sgpg_wqe_s *wqe, void (*cbfn) (void *cbarg),
4839 void *cbarg)
4840 {
4841 INIT_LIST_HEAD(&wqe->sgpg_q);
4842 wqe->cbfn = cbfn;
4843 wqe->cbarg = cbarg;
4844 }
4845
4846 /*
4847 * UF related functions
4848 */
4849 /*
4850 *****************************************************************************
4851 * Internal functions
4852 *****************************************************************************
4853 */
4854 static void
4855 __bfa_cb_uf_recv(void *cbarg, bfa_boolean_t complete)
4856 {
4857 struct bfa_uf_s *uf = cbarg;
4858 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(uf->bfa);
4859
4860 if (complete)
4861 ufm->ufrecv(ufm->cbarg, uf);
4862 }
4863
4864 static void
4865 claim_uf_pbs(struct bfa_uf_mod_s *ufm, struct bfa_meminfo_s *mi)
4866 {
4867 u32 uf_pb_tot_sz;
4868
4869 ufm->uf_pbs_kva = (struct bfa_uf_buf_s *) bfa_meminfo_dma_virt(mi);
4870 ufm->uf_pbs_pa = bfa_meminfo_dma_phys(mi);
4871 uf_pb_tot_sz = BFA_ROUNDUP((sizeof(struct bfa_uf_buf_s) * ufm->num_ufs),
4872 BFA_DMA_ALIGN_SZ);
4873
4874 bfa_meminfo_dma_virt(mi) += uf_pb_tot_sz;
4875 bfa_meminfo_dma_phys(mi) += uf_pb_tot_sz;
4876
4877 memset((void *)ufm->uf_pbs_kva, 0, uf_pb_tot_sz);
4878 }
4879
4880 static void
4881 claim_uf_post_msgs(struct bfa_uf_mod_s *ufm, struct bfa_meminfo_s *mi)
4882 {
4883 struct bfi_uf_buf_post_s *uf_bp_msg;
4884 struct bfi_sge_s *sge;
4885 union bfi_addr_u sga_zero = { {0} };
4886 u16 i;
4887 u16 buf_len;
4888
4889 ufm->uf_buf_posts = (struct bfi_uf_buf_post_s *) bfa_meminfo_kva(mi);
4890 uf_bp_msg = ufm->uf_buf_posts;
4891
4892 for (i = 0, uf_bp_msg = ufm->uf_buf_posts; i < ufm->num_ufs;
4893 i++, uf_bp_msg++) {
4894 memset(uf_bp_msg, 0, sizeof(struct bfi_uf_buf_post_s));
4895
4896 uf_bp_msg->buf_tag = i;
4897 buf_len = sizeof(struct bfa_uf_buf_s);
4898 uf_bp_msg->buf_len = cpu_to_be16(buf_len);
4899 bfi_h2i_set(uf_bp_msg->mh, BFI_MC_UF, BFI_UF_H2I_BUF_POST,
4900 bfa_lpuid(ufm->bfa));
4901
4902 sge = uf_bp_msg->sge;
4903 sge[0].sg_len = buf_len;
4904 sge[0].flags = BFI_SGE_DATA_LAST;
4905 bfa_dma_addr_set(sge[0].sga, ufm_pbs_pa(ufm, i));
4906 bfa_sge_to_be(sge);
4907
4908 sge[1].sg_len = buf_len;
4909 sge[1].flags = BFI_SGE_PGDLEN;
4910 sge[1].sga = sga_zero;
4911 bfa_sge_to_be(&sge[1]);
4912 }
4913
4914 /*
4915 * advance pointer beyond consumed memory
4916 */
4917 bfa_meminfo_kva(mi) = (u8 *) uf_bp_msg;
4918 }
4919
4920 static void
4921 claim_ufs(struct bfa_uf_mod_s *ufm, struct bfa_meminfo_s *mi)
4922 {
4923 u16 i;
4924 struct bfa_uf_s *uf;
4925
4926 /*
4927 * Claim block of memory for UF list
4928 */
4929 ufm->uf_list = (struct bfa_uf_s *) bfa_meminfo_kva(mi);
4930
4931 /*
4932 * Initialize UFs and queue it in UF free queue
4933 */
4934 for (i = 0, uf = ufm->uf_list; i < ufm->num_ufs; i++, uf++) {
4935 memset(uf, 0, sizeof(struct bfa_uf_s));
4936 uf->bfa = ufm->bfa;
4937 uf->uf_tag = i;
4938 uf->pb_len = sizeof(struct bfa_uf_buf_s);
4939 uf->buf_kva = (void *)&ufm->uf_pbs_kva[i];
4940 uf->buf_pa = ufm_pbs_pa(ufm, i);
4941 list_add_tail(&uf->qe, &ufm->uf_free_q);
4942 }
4943
4944 /*
4945 * advance memory pointer
4946 */
4947 bfa_meminfo_kva(mi) = (u8 *) uf;
4948 }
4949
4950 static void
4951 uf_mem_claim(struct bfa_uf_mod_s *ufm, struct bfa_meminfo_s *mi)
4952 {
4953 claim_uf_pbs(ufm, mi);
4954 claim_ufs(ufm, mi);
4955 claim_uf_post_msgs(ufm, mi);
4956 }
4957
4958 static void
4959 bfa_uf_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len, u32 *dm_len)
4960 {
4961 u32 num_ufs = cfg->fwcfg.num_uf_bufs;
4962
4963 /*
4964 * dma-able memory for UF posted bufs
4965 */
4966 *dm_len += BFA_ROUNDUP((sizeof(struct bfa_uf_buf_s) * num_ufs),
4967 BFA_DMA_ALIGN_SZ);
4968
4969 /*
4970 * kernel Virtual memory for UFs and UF buf post msg copies
4971 */
4972 *ndm_len += sizeof(struct bfa_uf_s) * num_ufs;
4973 *ndm_len += sizeof(struct bfi_uf_buf_post_s) * num_ufs;
4974 }
4975
4976 static void
4977 bfa_uf_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4978 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
4979 {
4980 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
4981
4982 memset(ufm, 0, sizeof(struct bfa_uf_mod_s));
4983 ufm->bfa = bfa;
4984 ufm->num_ufs = cfg->fwcfg.num_uf_bufs;
4985 INIT_LIST_HEAD(&ufm->uf_free_q);
4986 INIT_LIST_HEAD(&ufm->uf_posted_q);
4987
4988 uf_mem_claim(ufm, meminfo);
4989 }
4990
4991 static void
4992 bfa_uf_detach(struct bfa_s *bfa)
4993 {
4994 }
4995
4996 static struct bfa_uf_s *
4997 bfa_uf_get(struct bfa_uf_mod_s *uf_mod)
4998 {
4999 struct bfa_uf_s *uf;
5000
5001 bfa_q_deq(&uf_mod->uf_free_q, &uf);
5002 return uf;
5003 }
5004
5005 static void
5006 bfa_uf_put(struct bfa_uf_mod_s *uf_mod, struct bfa_uf_s *uf)
5007 {
5008 list_add_tail(&uf->qe, &uf_mod->uf_free_q);
5009 }
5010
5011 static bfa_status_t
5012 bfa_uf_post(struct bfa_uf_mod_s *ufm, struct bfa_uf_s *uf)
5013 {
5014 struct bfi_uf_buf_post_s *uf_post_msg;
5015
5016 uf_post_msg = bfa_reqq_next(ufm->bfa, BFA_REQQ_FCXP);
5017 if (!uf_post_msg)
5018 return BFA_STATUS_FAILED;
5019
5020 memcpy(uf_post_msg, &ufm->uf_buf_posts[uf->uf_tag],
5021 sizeof(struct bfi_uf_buf_post_s));
5022 bfa_reqq_produce(ufm->bfa, BFA_REQQ_FCXP);
5023
5024 bfa_trc(ufm->bfa, uf->uf_tag);
5025
5026 list_add_tail(&uf->qe, &ufm->uf_posted_q);
5027 return BFA_STATUS_OK;
5028 }
5029
5030 static void
5031 bfa_uf_post_all(struct bfa_uf_mod_s *uf_mod)
5032 {
5033 struct bfa_uf_s *uf;
5034
5035 while ((uf = bfa_uf_get(uf_mod)) != NULL) {
5036 if (bfa_uf_post(uf_mod, uf) != BFA_STATUS_OK)
5037 break;
5038 }
5039 }
5040
5041 static void
5042 uf_recv(struct bfa_s *bfa, struct bfi_uf_frm_rcvd_s *m)
5043 {
5044 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5045 u16 uf_tag = m->buf_tag;
5046 struct bfa_uf_buf_s *uf_buf = &ufm->uf_pbs_kva[uf_tag];
5047 struct bfa_uf_s *uf = &ufm->uf_list[uf_tag];
5048 u8 *buf = &uf_buf->d[0];
5049 struct fchs_s *fchs;
5050
5051 m->frm_len = be16_to_cpu(m->frm_len);
5052 m->xfr_len = be16_to_cpu(m->xfr_len);
5053
5054 fchs = (struct fchs_s *)uf_buf;
5055
5056 list_del(&uf->qe); /* dequeue from posted queue */
5057
5058 uf->data_ptr = buf;
5059 uf->data_len = m->xfr_len;
5060
5061 bfa_assert(uf->data_len >= sizeof(struct fchs_s));
5062
5063 if (uf->data_len == sizeof(struct fchs_s)) {
5064 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_UF, BFA_PL_EID_RX,
5065 uf->data_len, (struct fchs_s *)buf);
5066 } else {
5067 u32 pld_w0 = *((u32 *) (buf + sizeof(struct fchs_s)));
5068 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_UF,
5069 BFA_PL_EID_RX, uf->data_len,
5070 (struct fchs_s *)buf, pld_w0);
5071 }
5072
5073 if (bfa->fcs)
5074 __bfa_cb_uf_recv(uf, BFA_TRUE);
5075 else
5076 bfa_cb_queue(bfa, &uf->hcb_qe, __bfa_cb_uf_recv, uf);
5077 }
5078
5079 static void
5080 bfa_uf_stop(struct bfa_s *bfa)
5081 {
5082 }
5083
5084 static void
5085 bfa_uf_iocdisable(struct bfa_s *bfa)
5086 {
5087 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5088 struct bfa_uf_s *uf;
5089 struct list_head *qe, *qen;
5090
5091 list_for_each_safe(qe, qen, &ufm->uf_posted_q) {
5092 uf = (struct bfa_uf_s *) qe;
5093 list_del(&uf->qe);
5094 bfa_uf_put(ufm, uf);
5095 }
5096 }
5097
5098 static void
5099 bfa_uf_start(struct bfa_s *bfa)
5100 {
5101 bfa_uf_post_all(BFA_UF_MOD(bfa));
5102 }
5103
5104
5105
5106 /*
5107 * hal_uf_api
5108 */
5109
5110 /*
5111 * Register handler for all unsolicted recieve frames.
5112 *
5113 * @param[in] bfa BFA instance
5114 * @param[in] ufrecv receive handler function
5115 * @param[in] cbarg receive handler arg
5116 */
5117 void
5118 bfa_uf_recv_register(struct bfa_s *bfa, bfa_cb_uf_recv_t ufrecv, void *cbarg)
5119 {
5120 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5121
5122 ufm->ufrecv = ufrecv;
5123 ufm->cbarg = cbarg;
5124 }
5125
5126 /*
5127 * Free an unsolicited frame back to BFA.
5128 *
5129 * @param[in] uf unsolicited frame to be freed
5130 *
5131 * @return None
5132 */
5133 void
5134 bfa_uf_free(struct bfa_uf_s *uf)
5135 {
5136 bfa_uf_put(BFA_UF_MOD(uf->bfa), uf);
5137 bfa_uf_post_all(BFA_UF_MOD(uf->bfa));
5138 }
5139
5140
5141
5142 /*
5143 * uf_pub BFA uf module public functions
5144 */
5145 void
5146 bfa_uf_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
5147 {
5148 bfa_trc(bfa, msg->mhdr.msg_id);
5149
5150 switch (msg->mhdr.msg_id) {
5151 case BFI_UF_I2H_FRM_RCVD:
5152 uf_recv(bfa, (struct bfi_uf_frm_rcvd_s *) msg);
5153 break;
5154
5155 default:
5156 bfa_trc(bfa, msg->mhdr.msg_id);
5157 bfa_assert(0);
5158 }
5159 }
5160
5161
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree