aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/scsi/bfa/bfa_fcport.c1570
-rw-r--r--drivers/scsi/bfa/bfa_fcs_port.c2
-rw-r--r--drivers/scsi/bfa/bfa_module.c4
-rw-r--r--drivers/scsi/bfa/bfa_modules_priv.h2
-rw-r--r--drivers/scsi/bfa/bfa_port_priv.h19
-rw-r--r--drivers/scsi/bfa/bfa_priv.h2
-rw-r--r--drivers/scsi/bfa/bfa_trcmod_priv.h2
-rw-r--r--drivers/scsi/bfa/bfad.c2
-rw-r--r--drivers/scsi/bfa/bfad_attr.c6
-rw-r--r--drivers/scsi/bfa/bfad_im.c2
-rw-r--r--drivers/scsi/bfa/fabric.c20
-rw-r--r--drivers/scsi/bfa/fdmi.c2
-rw-r--r--drivers/scsi/bfa/include/bfa_svc.h76
-rw-r--r--drivers/scsi/bfa/include/bfi/bfi_pport.h5
-rw-r--r--drivers/scsi/bfa/include/cs/bfa_sm.h8
-rw-r--r--drivers/scsi/bfa/include/defs/bfa_defs_ethport.h1
-rw-r--r--drivers/scsi/bfa/include/defs/bfa_defs_fcport.h94
-rw-r--r--drivers/scsi/bfa/include/defs/bfa_defs_iocfc.h1
-rw-r--r--drivers/scsi/bfa/loop.c2
-rw-r--r--drivers/scsi/bfa/lport_api.c2
-rw-r--r--drivers/scsi/bfa/ms.c2
-rw-r--r--drivers/scsi/bfa/ns.c2
-rw-r--r--drivers/scsi/bfa/rport.c8
-rw-r--r--drivers/scsi/bfa/rport_api.c2
-rw-r--r--drivers/scsi/bfa/vport.c2
25 files changed, 1103 insertions, 735 deletions
diff --git a/drivers/scsi/bfa/bfa_fcport.c b/drivers/scsi/bfa/bfa_fcport.c
index bdea7f0eb6bd..f392a7fa8c7f 100644
--- a/drivers/scsi/bfa/bfa_fcport.c
+++ b/drivers/scsi/bfa/bfa_fcport.c
@@ -23,34 +23,40 @@
23#include <cs/bfa_plog.h> 23#include <cs/bfa_plog.h>
24#include <aen/bfa_aen_port.h> 24#include <aen/bfa_aen_port.h>
25 25
26BFA_TRC_FILE(HAL, PPORT); 26BFA_TRC_FILE(HAL, FCPORT);
27BFA_MODULE(pport); 27BFA_MODULE(fcport);
28 28
29/* 29/*
30 * The port is considered disabled if corresponding physical port or IOC are 30 * The port is considered disabled if corresponding physical port or IOC are
31 * disabled explicitly 31 * disabled explicitly
32 */ 32 */
33#define BFA_PORT_IS_DISABLED(bfa) \ 33#define BFA_PORT_IS_DISABLED(bfa) \
34 ((bfa_pport_is_disabled(bfa) == BFA_TRUE) || \ 34 ((bfa_fcport_is_disabled(bfa) == BFA_TRUE) || \
35 (bfa_ioc_is_disabled(&bfa->ioc) == BFA_TRUE)) 35 (bfa_ioc_is_disabled(&bfa->ioc) == BFA_TRUE))
36 36
37/* 37/*
38 * forward declarations 38 * forward declarations
39 */ 39 */
40static bfa_boolean_t bfa_pport_send_enable(struct bfa_pport_s *port); 40static bfa_boolean_t bfa_fcport_send_enable(struct bfa_fcport_s *fcport);
41static bfa_boolean_t bfa_pport_send_disable(struct bfa_pport_s *port); 41static bfa_boolean_t bfa_fcport_send_disable(struct bfa_fcport_s *fcport);
42static void bfa_pport_update_linkinfo(struct bfa_pport_s *pport); 42static void bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport);
43static void bfa_pport_reset_linkinfo(struct bfa_pport_s *pport); 43static void bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport);
44static void bfa_pport_set_wwns(struct bfa_pport_s *port); 44static void bfa_fcport_set_wwns(struct bfa_fcport_s *fcport);
45static void __bfa_cb_port_event(void *cbarg, bfa_boolean_t complete); 45static void __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete);
46static void bfa_fcport_callback(struct bfa_fcport_s *fcport,
47 enum bfa_pport_linkstate event);
48static void bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln,
49 enum bfa_pport_linkstate event);
50static void __bfa_cb_fcport_stats(void *cbarg, bfa_boolean_t complete);
51static void __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete);
52static void bfa_fcport_stats_timeout(void *cbarg);
53static void bfa_fcport_stats_clr_timeout(void *cbarg);
54
46static void __bfa_cb_port_stats(void *cbarg, bfa_boolean_t complete); 55static void __bfa_cb_port_stats(void *cbarg, bfa_boolean_t complete);
47static void __bfa_cb_port_stats_clr(void *cbarg, bfa_boolean_t complete); 56static void __bfa_cb_port_stats_clr(void *cbarg, bfa_boolean_t complete);
48static void bfa_port_stats_timeout(void *cbarg); 57static void bfa_port_stats_timeout(void *cbarg);
49static void bfa_port_stats_clr_timeout(void *cbarg); 58static void bfa_port_stats_clr_timeout(void *cbarg);
50static void bfa_pport_callback(struct bfa_pport_s *pport, 59
51 enum bfa_pport_linkstate event);
52static void bfa_pport_queue_cb(struct bfa_pport_ln_s *ln,
53 enum bfa_pport_linkstate event);
54/** 60/**
55 * bfa_pport_private 61 * bfa_pport_private
56 */ 62 */
@@ -58,87 +64,86 @@ static void bfa_pport_queue_cb(struct bfa_pport_ln_s *ln,
58/** 64/**
59 * BFA port state machine events 65 * BFA port state machine events
60 */ 66 */
61enum bfa_pport_sm_event { 67enum bfa_fcport_sm_event {
62 BFA_PPORT_SM_START = 1, /* start port state machine */ 68 BFA_FCPORT_SM_START = 1, /* start port state machine */
63 BFA_PPORT_SM_STOP = 2, /* stop port state machine */ 69 BFA_FCPORT_SM_STOP = 2, /* stop port state machine */
64 BFA_PPORT_SM_ENABLE = 3, /* enable port */ 70 BFA_FCPORT_SM_ENABLE = 3, /* enable port */
65 BFA_PPORT_SM_DISABLE = 4, /* disable port state machine */ 71 BFA_FCPORT_SM_DISABLE = 4, /* disable port state machine */
66 BFA_PPORT_SM_FWRSP = 5, /* firmware enable/disable rsp */ 72 BFA_FCPORT_SM_FWRSP = 5, /* firmware enable/disable rsp */
67 BFA_PPORT_SM_LINKUP = 6, /* firmware linkup event */ 73 BFA_FCPORT_SM_LINKUP = 6, /* firmware linkup event */
68 BFA_PPORT_SM_LINKDOWN = 7, /* firmware linkup down */ 74 BFA_FCPORT_SM_LINKDOWN = 7, /* firmware linkup down */
69 BFA_PPORT_SM_QRESUME = 8, /* CQ space available */ 75 BFA_FCPORT_SM_QRESUME = 8, /* CQ space available */
70 BFA_PPORT_SM_HWFAIL = 9, /* IOC h/w failure */ 76 BFA_FCPORT_SM_HWFAIL = 9, /* IOC h/w failure */
71}; 77};
72 78
73/** 79/**
74 * BFA port link notification state machine events 80 * BFA port link notification state machine events
75 */ 81 */
76 82
77enum bfa_pport_ln_sm_event { 83enum bfa_fcport_ln_sm_event {
78 BFA_PPORT_LN_SM_LINKUP = 1, /* linkup event */ 84 BFA_FCPORT_LN_SM_LINKUP = 1, /* linkup event */
79 BFA_PPORT_LN_SM_LINKDOWN = 2, /* linkdown event */ 85 BFA_FCPORT_LN_SM_LINKDOWN = 2, /* linkdown event */
80 BFA_PPORT_LN_SM_NOTIFICATION = 3 /* done notification */ 86 BFA_FCPORT_LN_SM_NOTIFICATION = 3 /* done notification */
81}; 87};
82 88
83static void bfa_pport_sm_uninit(struct bfa_pport_s *pport, 89static void bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
84 enum bfa_pport_sm_event event); 90 enum bfa_fcport_sm_event event);
85static void bfa_pport_sm_enabling_qwait(struct bfa_pport_s *pport, 91static void bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
86 enum bfa_pport_sm_event event); 92 enum bfa_fcport_sm_event event);
87static void bfa_pport_sm_enabling(struct bfa_pport_s *pport, 93static void bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
88 enum bfa_pport_sm_event event); 94 enum bfa_fcport_sm_event event);
89static void bfa_pport_sm_linkdown(struct bfa_pport_s *pport, 95static void bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
90 enum bfa_pport_sm_event event); 96 enum bfa_fcport_sm_event event);
91static void bfa_pport_sm_linkup(struct bfa_pport_s *pport, 97static void bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
92 enum bfa_pport_sm_event event); 98 enum bfa_fcport_sm_event event);
93static void bfa_pport_sm_disabling(struct bfa_pport_s *pport, 99static void bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
94 enum bfa_pport_sm_event event); 100 enum bfa_fcport_sm_event event);
95static void bfa_pport_sm_disabling_qwait(struct bfa_pport_s *pport, 101static void bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
96 enum bfa_pport_sm_event event); 102 enum bfa_fcport_sm_event event);
97static void bfa_pport_sm_disabled(struct bfa_pport_s *pport, 103static void bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
98 enum bfa_pport_sm_event event); 104 enum bfa_fcport_sm_event event);
99static void bfa_pport_sm_stopped(struct bfa_pport_s *pport, 105static void bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
100 enum bfa_pport_sm_event event); 106 enum bfa_fcport_sm_event event);
101static void bfa_pport_sm_iocdown(struct bfa_pport_s *pport, 107static void bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
102 enum bfa_pport_sm_event event); 108 enum bfa_fcport_sm_event event);
103static void bfa_pport_sm_iocfail(struct bfa_pport_s *pport, 109static void bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
104 enum bfa_pport_sm_event event); 110 enum bfa_fcport_sm_event event);
105 111
106static void bfa_pport_ln_sm_dn(struct bfa_pport_ln_s *ln, 112static void bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
107 enum bfa_pport_ln_sm_event event); 113 enum bfa_fcport_ln_sm_event event);
108static void bfa_pport_ln_sm_dn_nf(struct bfa_pport_ln_s *ln, 114static void bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
109 enum bfa_pport_ln_sm_event event); 115 enum bfa_fcport_ln_sm_event event);
110static void bfa_pport_ln_sm_dn_up_nf(struct bfa_pport_ln_s *ln, 116static void bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
111 enum bfa_pport_ln_sm_event event); 117 enum bfa_fcport_ln_sm_event event);
112static void bfa_pport_ln_sm_up(struct bfa_pport_ln_s *ln, 118static void bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
113 enum bfa_pport_ln_sm_event event); 119 enum bfa_fcport_ln_sm_event event);
114static void bfa_pport_ln_sm_up_nf(struct bfa_pport_ln_s *ln, 120static void bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
115 enum bfa_pport_ln_sm_event event); 121 enum bfa_fcport_ln_sm_event event);
116static void bfa_pport_ln_sm_up_dn_nf(struct bfa_pport_ln_s *ln, 122static void bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
117 enum bfa_pport_ln_sm_event event); 123 enum bfa_fcport_ln_sm_event event);
118static void bfa_pport_ln_sm_up_dn_up_nf(struct bfa_pport_ln_s *ln, 124static void bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
119 enum bfa_pport_ln_sm_event event); 125 enum bfa_fcport_ln_sm_event event);
120 126
121static struct bfa_sm_table_s hal_pport_sm_table[] = { 127static struct bfa_sm_table_s hal_pport_sm_table[] = {
122 {BFA_SM(bfa_pport_sm_uninit), BFA_PPORT_ST_UNINIT}, 128 {BFA_SM(bfa_fcport_sm_uninit), BFA_PPORT_ST_UNINIT},
123 {BFA_SM(bfa_pport_sm_enabling_qwait), BFA_PPORT_ST_ENABLING_QWAIT}, 129 {BFA_SM(bfa_fcport_sm_enabling_qwait), BFA_PPORT_ST_ENABLING_QWAIT},
124 {BFA_SM(bfa_pport_sm_enabling), BFA_PPORT_ST_ENABLING}, 130 {BFA_SM(bfa_fcport_sm_enabling), BFA_PPORT_ST_ENABLING},
125 {BFA_SM(bfa_pport_sm_linkdown), BFA_PPORT_ST_LINKDOWN}, 131 {BFA_SM(bfa_fcport_sm_linkdown), BFA_PPORT_ST_LINKDOWN},
126 {BFA_SM(bfa_pport_sm_linkup), BFA_PPORT_ST_LINKUP}, 132 {BFA_SM(bfa_fcport_sm_linkup), BFA_PPORT_ST_LINKUP},
127 {BFA_SM(bfa_pport_sm_disabling_qwait), 133 {BFA_SM(bfa_fcport_sm_disabling_qwait), BFA_PPORT_ST_DISABLING_QWAIT},
128 BFA_PPORT_ST_DISABLING_QWAIT}, 134 {BFA_SM(bfa_fcport_sm_disabling), BFA_PPORT_ST_DISABLING},
129 {BFA_SM(bfa_pport_sm_disabling), BFA_PPORT_ST_DISABLING}, 135 {BFA_SM(bfa_fcport_sm_disabled), BFA_PPORT_ST_DISABLED},
130 {BFA_SM(bfa_pport_sm_disabled), BFA_PPORT_ST_DISABLED}, 136 {BFA_SM(bfa_fcport_sm_stopped), BFA_PPORT_ST_STOPPED},
131 {BFA_SM(bfa_pport_sm_stopped), BFA_PPORT_ST_STOPPED}, 137 {BFA_SM(bfa_fcport_sm_iocdown), BFA_PPORT_ST_IOCDOWN},
132 {BFA_SM(bfa_pport_sm_iocdown), BFA_PPORT_ST_IOCDOWN}, 138 {BFA_SM(bfa_fcport_sm_iocfail), BFA_PPORT_ST_IOCDOWN},
133 {BFA_SM(bfa_pport_sm_iocfail), BFA_PPORT_ST_IOCDOWN},
134}; 139};
135 140
136static void 141static void
137bfa_pport_aen_post(struct bfa_pport_s *pport, enum bfa_port_aen_event event) 142bfa_fcport_aen_post(struct bfa_fcport_s *fcport, enum bfa_port_aen_event event)
138{ 143{
139 union bfa_aen_data_u aen_data; 144 union bfa_aen_data_u aen_data;
140 struct bfa_log_mod_s *logmod = pport->bfa->logm; 145 struct bfa_log_mod_s *logmod = fcport->bfa->logm;
141 wwn_t pwwn = pport->pwwn; 146 wwn_t pwwn = fcport->pwwn;
142 char pwwn_ptr[BFA_STRING_32]; 147 char pwwn_ptr[BFA_STRING_32];
143 struct bfa_ioc_attr_s ioc_attr; 148 struct bfa_ioc_attr_s ioc_attr;
144 149
@@ -167,28 +172,29 @@ bfa_pport_aen_post(struct bfa_pport_s *pport, enum bfa_port_aen_event event)
167 break; 172 break;
168 } 173 }
169 174
170 bfa_ioc_get_attr(&pport->bfa->ioc, &ioc_attr); 175 bfa_ioc_get_attr(&fcport->bfa->ioc, &ioc_attr);
171 aen_data.port.ioc_type = ioc_attr.ioc_type; 176 aen_data.port.ioc_type = ioc_attr.ioc_type;
172 aen_data.port.pwwn = pwwn; 177 aen_data.port.pwwn = pwwn;
173} 178}
174 179
175static void 180static void
176bfa_pport_sm_uninit(struct bfa_pport_s *pport, enum bfa_pport_sm_event event) 181bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
182 enum bfa_fcport_sm_event event)
177{ 183{
178 bfa_trc(pport->bfa, event); 184 bfa_trc(fcport->bfa, event);
179 185
180 switch (event) { 186 switch (event) {
181 case BFA_PPORT_SM_START: 187 case BFA_FCPORT_SM_START:
182 /** 188 /**
183 * Start event after IOC is configured and BFA is started. 189 * Start event after IOC is configured and BFA is started.
184 */ 190 */
185 if (bfa_pport_send_enable(pport)) 191 if (bfa_fcport_send_enable(fcport))
186 bfa_sm_set_state(pport, bfa_pport_sm_enabling); 192 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
187 else 193 else
188 bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait); 194 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
189 break; 195 break;
190 196
191 case BFA_PPORT_SM_ENABLE: 197 case BFA_FCPORT_SM_ENABLE:
192 /** 198 /**
193 * Port is persistently configured to be in enabled state. Do 199 * Port is persistently configured to be in enabled state. Do
194 * not change state. Port enabling is done when START event is 200 * not change state. Port enabling is done when START event is
@@ -196,389 +202,395 @@ bfa_pport_sm_uninit(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
196 */ 202 */
197 break; 203 break;
198 204
199 case BFA_PPORT_SM_DISABLE: 205 case BFA_FCPORT_SM_DISABLE:
200 /** 206 /**
201 * If a port is persistently configured to be disabled, the 207 * If a port is persistently configured to be disabled, the
202 * first event will a port disable request. 208 * first event will a port disable request.
203 */ 209 */
204 bfa_sm_set_state(pport, bfa_pport_sm_disabled); 210 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
205 break; 211 break;
206 212
207 case BFA_PPORT_SM_HWFAIL: 213 case BFA_FCPORT_SM_HWFAIL:
208 bfa_sm_set_state(pport, bfa_pport_sm_iocdown); 214 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
209 break; 215 break;
210 216
211 default: 217 default:
212 bfa_sm_fault(pport->bfa, event); 218 bfa_sm_fault(fcport->bfa, event);
213 } 219 }
214} 220}
215 221
216static void 222static void
217bfa_pport_sm_enabling_qwait(struct bfa_pport_s *pport, 223bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
218 enum bfa_pport_sm_event event) 224 enum bfa_fcport_sm_event event)
219{ 225{
220 bfa_trc(pport->bfa, event); 226 bfa_trc(fcport->bfa, event);
221 227
222 switch (event) { 228 switch (event) {
223 case BFA_PPORT_SM_QRESUME: 229 case BFA_FCPORT_SM_QRESUME:
224 bfa_sm_set_state(pport, bfa_pport_sm_enabling); 230 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
225 bfa_pport_send_enable(pport); 231 bfa_fcport_send_enable(fcport);
226 break; 232 break;
227 233
228 case BFA_PPORT_SM_STOP: 234 case BFA_FCPORT_SM_STOP:
229 bfa_reqq_wcancel(&pport->reqq_wait); 235 bfa_reqq_wcancel(&fcport->reqq_wait);
230 bfa_sm_set_state(pport, bfa_pport_sm_stopped); 236 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
231 break; 237 break;
232 238
233 case BFA_PPORT_SM_ENABLE: 239 case BFA_FCPORT_SM_ENABLE:
234 /** 240 /**
235 * Already enable is in progress. 241 * Already enable is in progress.
236 */ 242 */
237 break; 243 break;
238 244
239 case BFA_PPORT_SM_DISABLE: 245 case BFA_FCPORT_SM_DISABLE:
240 /** 246 /**
241 * Just send disable request to firmware when room becomes 247 * Just send disable request to firmware when room becomes
242 * available in request queue. 248 * available in request queue.
243 */ 249 */
244 bfa_sm_set_state(pport, bfa_pport_sm_disabled); 250 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
245 bfa_reqq_wcancel(&pport->reqq_wait); 251 bfa_reqq_wcancel(&fcport->reqq_wait);
246 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL, 252 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
247 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable"); 253 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
248 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISABLE); 254 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
249 break; 255 break;
250 256
251 case BFA_PPORT_SM_LINKUP: 257 case BFA_FCPORT_SM_LINKUP:
252 case BFA_PPORT_SM_LINKDOWN: 258 case BFA_FCPORT_SM_LINKDOWN:
253 /** 259 /**
254 * Possible to get link events when doing back-to-back 260 * Possible to get link events when doing back-to-back
255 * enable/disables. 261 * enable/disables.
256 */ 262 */
257 break; 263 break;
258 264
259 case BFA_PPORT_SM_HWFAIL: 265 case BFA_FCPORT_SM_HWFAIL:
260 bfa_reqq_wcancel(&pport->reqq_wait); 266 bfa_reqq_wcancel(&fcport->reqq_wait);
261 bfa_sm_set_state(pport, bfa_pport_sm_iocdown); 267 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
262 break; 268 break;
263 269
264 default: 270 default:
265 bfa_sm_fault(pport->bfa, event); 271 bfa_sm_fault(fcport->bfa, event);
266 } 272 }
267} 273}
268 274
269static void 275static void
270bfa_pport_sm_enabling(struct bfa_pport_s *pport, enum bfa_pport_sm_event event) 276bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
277 enum bfa_fcport_sm_event event)
271{ 278{
272 bfa_trc(pport->bfa, event); 279 bfa_trc(fcport->bfa, event);
273 280
274 switch (event) { 281 switch (event) {
275 case BFA_PPORT_SM_FWRSP: 282 case BFA_FCPORT_SM_FWRSP:
276 case BFA_PPORT_SM_LINKDOWN: 283 case BFA_FCPORT_SM_LINKDOWN:
277 bfa_sm_set_state(pport, bfa_pport_sm_linkdown); 284 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
278 break; 285 break;
279 286
280 case BFA_PPORT_SM_LINKUP: 287 case BFA_FCPORT_SM_LINKUP:
281 bfa_pport_update_linkinfo(pport); 288 bfa_fcport_update_linkinfo(fcport);
282 bfa_sm_set_state(pport, bfa_pport_sm_linkup); 289 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
283 290
284 bfa_assert(pport->event_cbfn); 291 bfa_assert(fcport->event_cbfn);
285 bfa_pport_callback(pport, BFA_PPORT_LINKUP); 292 bfa_fcport_callback(fcport, BFA_PPORT_LINKUP);
286 break; 293 break;
287 294
288 case BFA_PPORT_SM_ENABLE: 295 case BFA_FCPORT_SM_ENABLE:
289 /** 296 /**
290 * Already being enabled. 297 * Already being enabled.
291 */ 298 */
292 break; 299 break;
293 300
294 case BFA_PPORT_SM_DISABLE: 301 case BFA_FCPORT_SM_DISABLE:
295 if (bfa_pport_send_disable(pport)) 302 if (bfa_fcport_send_disable(fcport))
296 bfa_sm_set_state(pport, bfa_pport_sm_disabling); 303 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
297 else 304 else
298 bfa_sm_set_state(pport, bfa_pport_sm_disabling_qwait); 305 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
299 306
300 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL, 307 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
301 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable"); 308 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
302 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISABLE); 309 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
303 break; 310 break;
304 311
305 case BFA_PPORT_SM_STOP: 312 case BFA_FCPORT_SM_STOP:
306 bfa_sm_set_state(pport, bfa_pport_sm_stopped); 313 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
307 break; 314 break;
308 315
309 case BFA_PPORT_SM_HWFAIL: 316 case BFA_FCPORT_SM_HWFAIL:
310 bfa_sm_set_state(pport, bfa_pport_sm_iocdown); 317 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
311 break; 318 break;
312 319
313 default: 320 default:
314 bfa_sm_fault(pport->bfa, event); 321 bfa_sm_fault(fcport->bfa, event);
315 } 322 }
316} 323}
317 324
318static void 325static void
319bfa_pport_sm_linkdown(struct bfa_pport_s *pport, enum bfa_pport_sm_event event) 326bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
327 enum bfa_fcport_sm_event event)
320{ 328{
321 bfa_trc(pport->bfa, event); 329 bfa_trc(fcport->bfa, event);
322 330
323 switch (event) { 331 switch (event) {
324 case BFA_PPORT_SM_LINKUP: 332 case BFA_FCPORT_SM_LINKUP:
325 bfa_pport_update_linkinfo(pport); 333 bfa_fcport_update_linkinfo(fcport);
326 bfa_sm_set_state(pport, bfa_pport_sm_linkup); 334 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
327 bfa_assert(pport->event_cbfn); 335 bfa_assert(fcport->event_cbfn);
328 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL, 336 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
329 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkup"); 337 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkup");
330 bfa_pport_callback(pport, BFA_PPORT_LINKUP); 338 bfa_fcport_callback(fcport, BFA_PPORT_LINKUP);
331 bfa_pport_aen_post(pport, BFA_PORT_AEN_ONLINE); 339 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ONLINE);
332 /** 340 /**
333 * If QoS is enabled and it is not online, 341 * If QoS is enabled and it is not online,
334 * Send a separate event. 342 * Send a separate event.
335 */ 343 */
336 if ((pport->cfg.qos_enabled) 344 if ((fcport->cfg.qos_enabled)
337 && (bfa_os_ntohl(pport->qos_attr.state) != BFA_QOS_ONLINE)) 345 && (bfa_os_ntohl(fcport->qos_attr.state) != BFA_QOS_ONLINE))
338 bfa_pport_aen_post(pport, BFA_PORT_AEN_QOS_NEG); 346 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_QOS_NEG);
339 347
340 break; 348 break;
341 349
342 case BFA_PPORT_SM_LINKDOWN: 350 case BFA_FCPORT_SM_LINKDOWN:
343 /** 351 /**
344 * Possible to get link down event. 352 * Possible to get link down event.
345 */ 353 */
346 break; 354 break;
347 355
348 case BFA_PPORT_SM_ENABLE: 356 case BFA_FCPORT_SM_ENABLE:
349 /** 357 /**
350 * Already enabled. 358 * Already enabled.
351 */ 359 */
352 break; 360 break;
353 361
354 case BFA_PPORT_SM_DISABLE: 362 case BFA_FCPORT_SM_DISABLE:
355 if (bfa_pport_send_disable(pport)) 363 if (bfa_fcport_send_disable(fcport))
356 bfa_sm_set_state(pport, bfa_pport_sm_disabling); 364 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
357 else 365 else
358 bfa_sm_set_state(pport, bfa_pport_sm_disabling_qwait); 366 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
359 367
360 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL, 368 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
361 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable"); 369 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
362 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISABLE); 370 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
363 break; 371 break;
364 372
365 case BFA_PPORT_SM_STOP: 373 case BFA_FCPORT_SM_STOP:
366 bfa_sm_set_state(pport, bfa_pport_sm_stopped); 374 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
367 break; 375 break;
368 376
369 case BFA_PPORT_SM_HWFAIL: 377 case BFA_FCPORT_SM_HWFAIL:
370 bfa_sm_set_state(pport, bfa_pport_sm_iocdown); 378 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
371 break; 379 break;
372 380
373 default: 381 default:
374 bfa_sm_fault(pport->bfa, event); 382 bfa_sm_fault(fcport->bfa, event);
375 } 383 }
376} 384}
377 385
378static void 386static void
379bfa_pport_sm_linkup(struct bfa_pport_s *pport, enum bfa_pport_sm_event event) 387bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
388 enum bfa_fcport_sm_event event)
380{ 389{
381 bfa_trc(pport->bfa, event); 390 bfa_trc(fcport->bfa, event);
382 391
383 switch (event) { 392 switch (event) {
384 case BFA_PPORT_SM_ENABLE: 393 case BFA_FCPORT_SM_ENABLE:
385 /** 394 /**
386 * Already enabled. 395 * Already enabled.
387 */ 396 */
388 break; 397 break;
389 398
390 case BFA_PPORT_SM_DISABLE: 399 case BFA_FCPORT_SM_DISABLE:
391 if (bfa_pport_send_disable(pport)) 400 if (bfa_fcport_send_disable(fcport))
392 bfa_sm_set_state(pport, bfa_pport_sm_disabling); 401 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
393 else 402 else
394 bfa_sm_set_state(pport, bfa_pport_sm_disabling_qwait); 403 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
395 404
396 bfa_pport_reset_linkinfo(pport); 405 bfa_fcport_reset_linkinfo(fcport);
397 bfa_pport_callback(pport, BFA_PPORT_LINKDOWN); 406 bfa_fcport_callback(fcport, BFA_PPORT_LINKDOWN);
398 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL, 407 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
399 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable"); 408 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
400 bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE); 409 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
401 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISABLE); 410 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
402 break; 411 break;
403 412
404 case BFA_PPORT_SM_LINKDOWN: 413 case BFA_FCPORT_SM_LINKDOWN:
405 bfa_sm_set_state(pport, bfa_pport_sm_linkdown); 414 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
406 bfa_pport_reset_linkinfo(pport); 415 bfa_fcport_reset_linkinfo(fcport);
407 bfa_pport_callback(pport, BFA_PPORT_LINKDOWN); 416 bfa_fcport_callback(fcport, BFA_PPORT_LINKDOWN);
408 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL, 417 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
409 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown"); 418 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
410 if (BFA_PORT_IS_DISABLED(pport->bfa)) 419 if (BFA_PORT_IS_DISABLED(fcport->bfa))
411 bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE); 420 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
412 else 421 else
413 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISCONNECT); 422 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
414 break; 423 break;
415 424
416 case BFA_PPORT_SM_STOP: 425 case BFA_FCPORT_SM_STOP:
417 bfa_sm_set_state(pport, bfa_pport_sm_stopped); 426 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
418 bfa_pport_reset_linkinfo(pport); 427 bfa_fcport_reset_linkinfo(fcport);
419 if (BFA_PORT_IS_DISABLED(pport->bfa)) 428 if (BFA_PORT_IS_DISABLED(fcport->bfa))
420 bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE); 429 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
421 else 430 else
422 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISCONNECT); 431 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
423 break; 432 break;
424 433
425 case BFA_PPORT_SM_HWFAIL: 434 case BFA_FCPORT_SM_HWFAIL:
426 bfa_sm_set_state(pport, bfa_pport_sm_iocdown); 435 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
427 bfa_pport_reset_linkinfo(pport); 436 bfa_fcport_reset_linkinfo(fcport);
428 bfa_pport_callback(pport, BFA_PPORT_LINKDOWN); 437 bfa_fcport_callback(fcport, BFA_PPORT_LINKDOWN);
429 if (BFA_PORT_IS_DISABLED(pport->bfa)) 438 if (BFA_PORT_IS_DISABLED(fcport->bfa))
430 bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE); 439 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
431 else 440 else
432 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISCONNECT); 441 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
433 break; 442 break;
434 443
435 default: 444 default:
436 bfa_sm_fault(pport->bfa, event); 445 bfa_sm_fault(fcport->bfa, event);
437 } 446 }
438} 447}
439 448
440static void 449static void
441bfa_pport_sm_disabling_qwait(struct bfa_pport_s *pport, 450bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
442 enum bfa_pport_sm_event event) 451 enum bfa_fcport_sm_event event)
443{ 452{
444 bfa_trc(pport->bfa, event); 453 bfa_trc(fcport->bfa, event);
445 454
446 switch (event) { 455 switch (event) {
447 case BFA_PPORT_SM_QRESUME: 456 case BFA_FCPORT_SM_QRESUME:
448 bfa_sm_set_state(pport, bfa_pport_sm_disabling); 457 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
449 bfa_pport_send_disable(pport); 458 bfa_fcport_send_disable(fcport);
450 break; 459 break;
451 460
452 case BFA_PPORT_SM_STOP: 461 case BFA_FCPORT_SM_STOP:
453 bfa_sm_set_state(pport, bfa_pport_sm_stopped); 462 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
454 bfa_reqq_wcancel(&pport->reqq_wait); 463 bfa_reqq_wcancel(&fcport->reqq_wait);
455 break; 464 break;
456 465
457 case BFA_PPORT_SM_DISABLE: 466 case BFA_FCPORT_SM_DISABLE:
458 /** 467 /**
459 * Already being disabled. 468 * Already being disabled.
460 */ 469 */
461 break; 470 break;
462 471
463 case BFA_PPORT_SM_LINKUP: 472 case BFA_FCPORT_SM_LINKUP:
464 case BFA_PPORT_SM_LINKDOWN: 473 case BFA_FCPORT_SM_LINKDOWN:
465 /** 474 /**
466 * Possible to get link events when doing back-to-back 475 * Possible to get link events when doing back-to-back
467 * enable/disables. 476 * enable/disables.
468 */ 477 */
469 break; 478 break;
470 479
471 case BFA_PPORT_SM_HWFAIL: 480 case BFA_FCPORT_SM_HWFAIL:
472 bfa_sm_set_state(pport, bfa_pport_sm_iocfail); 481 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
473 bfa_reqq_wcancel(&pport->reqq_wait); 482 bfa_reqq_wcancel(&fcport->reqq_wait);
474 break; 483 break;
475 484
476 default: 485 default:
477 bfa_sm_fault(pport->bfa, event); 486 bfa_sm_fault(fcport->bfa, event);
478 } 487 }
479} 488}
480 489
481static void 490static void
482bfa_pport_sm_disabling(struct bfa_pport_s *pport, enum bfa_pport_sm_event event) 491bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
492 enum bfa_fcport_sm_event event)
483{ 493{
484 bfa_trc(pport->bfa, event); 494 bfa_trc(fcport->bfa, event);
485 495
486 switch (event) { 496 switch (event) {
487 case BFA_PPORT_SM_FWRSP: 497 case BFA_FCPORT_SM_FWRSP:
488 bfa_sm_set_state(pport, bfa_pport_sm_disabled); 498 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
489 break; 499 break;
490 500
491 case BFA_PPORT_SM_DISABLE: 501 case BFA_FCPORT_SM_DISABLE:
492 /** 502 /**
493 * Already being disabled. 503 * Already being disabled.
494 */ 504 */
495 break; 505 break;
496 506
497 case BFA_PPORT_SM_ENABLE: 507 case BFA_FCPORT_SM_ENABLE:
498 if (bfa_pport_send_enable(pport)) 508 if (bfa_fcport_send_enable(fcport))
499 bfa_sm_set_state(pport, bfa_pport_sm_enabling); 509 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
500 else 510 else
501 bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait); 511 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
502 512
503 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL, 513 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
504 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable"); 514 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
505 bfa_pport_aen_post(pport, BFA_PORT_AEN_ENABLE); 515 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
506 break; 516 break;
507 517
508 case BFA_PPORT_SM_STOP: 518 case BFA_FCPORT_SM_STOP:
509 bfa_sm_set_state(pport, bfa_pport_sm_stopped); 519 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
510 break; 520 break;
511 521
512 case BFA_PPORT_SM_LINKUP: 522 case BFA_FCPORT_SM_LINKUP:
513 case BFA_PPORT_SM_LINKDOWN: 523 case BFA_FCPORT_SM_LINKDOWN:
514 /** 524 /**
515 * Possible to get link events when doing back-to-back 525 * Possible to get link events when doing back-to-back
516 * enable/disables. 526 * enable/disables.
517 */ 527 */
518 break; 528 break;
519 529
520 case BFA_PPORT_SM_HWFAIL: 530 case BFA_FCPORT_SM_HWFAIL:
521 bfa_sm_set_state(pport, bfa_pport_sm_iocfail); 531 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
522 break; 532 break;
523 533
524 default: 534 default:
525 bfa_sm_fault(pport->bfa, event); 535 bfa_sm_fault(fcport->bfa, event);
526 } 536 }
527} 537}
528 538
529static void 539static void
530bfa_pport_sm_disabled(struct bfa_pport_s *pport, enum bfa_pport_sm_event event) 540bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
541 enum bfa_fcport_sm_event event)
531{ 542{
532 bfa_trc(pport->bfa, event); 543 bfa_trc(fcport->bfa, event);
533 544
534 switch (event) { 545 switch (event) {
535 case BFA_PPORT_SM_START: 546 case BFA_FCPORT_SM_START:
536 /** 547 /**
537 * Ignore start event for a port that is disabled. 548 * Ignore start event for a port that is disabled.
538 */ 549 */
539 break; 550 break;
540 551
541 case BFA_PPORT_SM_STOP: 552 case BFA_FCPORT_SM_STOP:
542 bfa_sm_set_state(pport, bfa_pport_sm_stopped); 553 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
543 break; 554 break;
544 555
545 case BFA_PPORT_SM_ENABLE: 556 case BFA_FCPORT_SM_ENABLE:
546 if (bfa_pport_send_enable(pport)) 557 if (bfa_fcport_send_enable(fcport))
547 bfa_sm_set_state(pport, bfa_pport_sm_enabling); 558 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
548 else 559 else
549 bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait); 560 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
550 561
551 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL, 562 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
552 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable"); 563 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
553 bfa_pport_aen_post(pport, BFA_PORT_AEN_ENABLE); 564 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
554 break; 565 break;
555 566
556 case BFA_PPORT_SM_DISABLE: 567 case BFA_FCPORT_SM_DISABLE:
557 /** 568 /**
558 * Already disabled. 569 * Already disabled.
559 */ 570 */
560 break; 571 break;
561 572
562 case BFA_PPORT_SM_HWFAIL: 573 case BFA_FCPORT_SM_HWFAIL:
563 bfa_sm_set_state(pport, bfa_pport_sm_iocfail); 574 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
564 break; 575 break;
565 576
566 default: 577 default:
567 bfa_sm_fault(pport->bfa, event); 578 bfa_sm_fault(fcport->bfa, event);
568 } 579 }
569} 580}
570 581
571static void 582static void
572bfa_pport_sm_stopped(struct bfa_pport_s *pport, enum bfa_pport_sm_event event) 583bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
584 enum bfa_fcport_sm_event event)
573{ 585{
574 bfa_trc(pport->bfa, event); 586 bfa_trc(fcport->bfa, event);
575 587
576 switch (event) { 588 switch (event) {
577 case BFA_PPORT_SM_START: 589 case BFA_FCPORT_SM_START:
578 if (bfa_pport_send_enable(pport)) 590 if (bfa_fcport_send_enable(fcport))
579 bfa_sm_set_state(pport, bfa_pport_sm_enabling); 591 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
580 else 592 else
581 bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait); 593 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
582 break; 594 break;
583 595
584 default: 596 default:
@@ -593,16 +605,17 @@ bfa_pport_sm_stopped(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
593 * Port is enabled. IOC is down/failed. 605 * Port is enabled. IOC is down/failed.
594 */ 606 */
595static void 607static void
596bfa_pport_sm_iocdown(struct bfa_pport_s *pport, enum bfa_pport_sm_event event) 608bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
609 enum bfa_fcport_sm_event event)
597{ 610{
598 bfa_trc(pport->bfa, event); 611 bfa_trc(fcport->bfa, event);
599 612
600 switch (event) { 613 switch (event) {
601 case BFA_PPORT_SM_START: 614 case BFA_FCPORT_SM_START:
602 if (bfa_pport_send_enable(pport)) 615 if (bfa_fcport_send_enable(fcport))
603 bfa_sm_set_state(pport, bfa_pport_sm_enabling); 616 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
604 else 617 else
605 bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait); 618 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
606 break; 619 break;
607 620
608 default: 621 default:
@@ -617,17 +630,18 @@ bfa_pport_sm_iocdown(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
617 * Port is disabled. IOC is down/failed. 630 * Port is disabled. IOC is down/failed.
618 */ 631 */
619static void 632static void
620bfa_pport_sm_iocfail(struct bfa_pport_s *pport, enum bfa_pport_sm_event event) 633bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
634 enum bfa_fcport_sm_event event)
621{ 635{
622 bfa_trc(pport->bfa, event); 636 bfa_trc(fcport->bfa, event);
623 637
624 switch (event) { 638 switch (event) {
625 case BFA_PPORT_SM_START: 639 case BFA_FCPORT_SM_START:
626 bfa_sm_set_state(pport, bfa_pport_sm_disabled); 640 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
627 break; 641 break;
628 642
629 case BFA_PPORT_SM_ENABLE: 643 case BFA_FCPORT_SM_ENABLE:
630 bfa_sm_set_state(pport, bfa_pport_sm_iocdown); 644 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
631 break; 645 break;
632 646
633 default: 647 default:
@@ -642,19 +656,19 @@ bfa_pport_sm_iocfail(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
642 * Link state is down 656 * Link state is down
643 */ 657 */
644static void 658static void
645bfa_pport_ln_sm_dn(struct bfa_pport_ln_s *ln, 659bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
646 enum bfa_pport_ln_sm_event event) 660 enum bfa_fcport_ln_sm_event event)
647{ 661{
648 bfa_trc(ln->pport->bfa, event); 662 bfa_trc(ln->fcport->bfa, event);
649 663
650 switch (event) { 664 switch (event) {
651 case BFA_PPORT_LN_SM_LINKUP: 665 case BFA_FCPORT_LN_SM_LINKUP:
652 bfa_sm_set_state(ln, bfa_pport_ln_sm_up_nf); 666 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
653 bfa_pport_queue_cb(ln, BFA_PPORT_LINKUP); 667 bfa_fcport_queue_cb(ln, BFA_PPORT_LINKUP);
654 break; 668 break;
655 669
656 default: 670 default:
657 bfa_sm_fault(ln->pport->bfa, event); 671 bfa_sm_fault(ln->fcport->bfa, event);
658 } 672 }
659} 673}
660 674
@@ -662,22 +676,22 @@ bfa_pport_ln_sm_dn(struct bfa_pport_ln_s *ln,
662 * Link state is waiting for down notification 676 * Link state is waiting for down notification
663 */ 677 */
664static void 678static void
665bfa_pport_ln_sm_dn_nf(struct bfa_pport_ln_s *ln, 679bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
666 enum bfa_pport_ln_sm_event event) 680 enum bfa_fcport_ln_sm_event event)
667{ 681{
668 bfa_trc(ln->pport->bfa, event); 682 bfa_trc(ln->fcport->bfa, event);
669 683
670 switch (event) { 684 switch (event) {
671 case BFA_PPORT_LN_SM_LINKUP: 685 case BFA_FCPORT_LN_SM_LINKUP:
672 bfa_sm_set_state(ln, bfa_pport_ln_sm_dn_up_nf); 686 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
673 break; 687 break;
674 688
675 case BFA_PPORT_LN_SM_NOTIFICATION: 689 case BFA_FCPORT_LN_SM_NOTIFICATION:
676 bfa_sm_set_state(ln, bfa_pport_ln_sm_dn); 690 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
677 break; 691 break;
678 692
679 default: 693 default:
680 bfa_sm_fault(ln->pport->bfa, event); 694 bfa_sm_fault(ln->fcport->bfa, event);
681 } 695 }
682} 696}
683 697
@@ -685,23 +699,23 @@ bfa_pport_ln_sm_dn_nf(struct bfa_pport_ln_s *ln,
685 * Link state is waiting for down notification and there is a pending up 699 * Link state is waiting for down notification and there is a pending up
686 */ 700 */
687static void 701static void
688bfa_pport_ln_sm_dn_up_nf(struct bfa_pport_ln_s *ln, 702bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
689 enum bfa_pport_ln_sm_event event) 703 enum bfa_fcport_ln_sm_event event)
690{ 704{
691 bfa_trc(ln->pport->bfa, event); 705 bfa_trc(ln->fcport->bfa, event);
692 706
693 switch (event) { 707 switch (event) {
694 case BFA_PPORT_LN_SM_LINKDOWN: 708 case BFA_FCPORT_LN_SM_LINKDOWN:
695 bfa_sm_set_state(ln, bfa_pport_ln_sm_dn_nf); 709 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
696 break; 710 break;
697 711
698 case BFA_PPORT_LN_SM_NOTIFICATION: 712 case BFA_FCPORT_LN_SM_NOTIFICATION:
699 bfa_sm_set_state(ln, bfa_pport_ln_sm_up_nf); 713 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
700 bfa_pport_queue_cb(ln, BFA_PPORT_LINKUP); 714 bfa_fcport_queue_cb(ln, BFA_PPORT_LINKUP);
701 break; 715 break;
702 716
703 default: 717 default:
704 bfa_sm_fault(ln->pport->bfa, event); 718 bfa_sm_fault(ln->fcport->bfa, event);
705 } 719 }
706} 720}
707 721
@@ -709,19 +723,19 @@ bfa_pport_ln_sm_dn_up_nf(struct bfa_pport_ln_s *ln,
709 * Link state is up 723 * Link state is up
710 */ 724 */
711static void 725static void
712bfa_pport_ln_sm_up(struct bfa_pport_ln_s *ln, 726bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
713 enum bfa_pport_ln_sm_event event) 727 enum bfa_fcport_ln_sm_event event)
714{ 728{
715 bfa_trc(ln->pport->bfa, event); 729 bfa_trc(ln->fcport->bfa, event);
716 730
717 switch (event) { 731 switch (event) {
718 case BFA_PPORT_LN_SM_LINKDOWN: 732 case BFA_FCPORT_LN_SM_LINKDOWN:
719 bfa_sm_set_state(ln, bfa_pport_ln_sm_dn_nf); 733 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
720 bfa_pport_queue_cb(ln, BFA_PPORT_LINKDOWN); 734 bfa_fcport_queue_cb(ln, BFA_PPORT_LINKDOWN);
721 break; 735 break;
722 736
723 default: 737 default:
724 bfa_sm_fault(ln->pport->bfa, event); 738 bfa_sm_fault(ln->fcport->bfa, event);
725 } 739 }
726} 740}
727 741
@@ -729,22 +743,22 @@ bfa_pport_ln_sm_up(struct bfa_pport_ln_s *ln,
729 * Link state is waiting for up notification 743 * Link state is waiting for up notification
730 */ 744 */
731static void 745static void
732bfa_pport_ln_sm_up_nf(struct bfa_pport_ln_s *ln, 746bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
733 enum bfa_pport_ln_sm_event event) 747 enum bfa_fcport_ln_sm_event event)
734{ 748{
735 bfa_trc(ln->pport->bfa, event); 749 bfa_trc(ln->fcport->bfa, event);
736 750
737 switch (event) { 751 switch (event) {
738 case BFA_PPORT_LN_SM_LINKDOWN: 752 case BFA_FCPORT_LN_SM_LINKDOWN:
739 bfa_sm_set_state(ln, bfa_pport_ln_sm_up_dn_nf); 753 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
740 break; 754 break;
741 755
742 case BFA_PPORT_LN_SM_NOTIFICATION: 756 case BFA_FCPORT_LN_SM_NOTIFICATION:
743 bfa_sm_set_state(ln, bfa_pport_ln_sm_up); 757 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up);
744 break; 758 break;
745 759
746 default: 760 default:
747 bfa_sm_fault(ln->pport->bfa, event); 761 bfa_sm_fault(ln->fcport->bfa, event);
748 } 762 }
749} 763}
750 764
@@ -752,23 +766,23 @@ bfa_pport_ln_sm_up_nf(struct bfa_pport_ln_s *ln,
752 * Link state is waiting for up notification and there is a pending down 766 * Link state is waiting for up notification and there is a pending down
753 */ 767 */
754static void 768static void
755bfa_pport_ln_sm_up_dn_nf(struct bfa_pport_ln_s *ln, 769bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
756 enum bfa_pport_ln_sm_event event) 770 enum bfa_fcport_ln_sm_event event)
757{ 771{
758 bfa_trc(ln->pport->bfa, event); 772 bfa_trc(ln->fcport->bfa, event);
759 773
760 switch (event) { 774 switch (event) {
761 case BFA_PPORT_LN_SM_LINKUP: 775 case BFA_FCPORT_LN_SM_LINKUP:
762 bfa_sm_set_state(ln, bfa_pport_ln_sm_up_dn_up_nf); 776 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_up_nf);
763 break; 777 break;
764 778
765 case BFA_PPORT_LN_SM_NOTIFICATION: 779 case BFA_FCPORT_LN_SM_NOTIFICATION:
766 bfa_sm_set_state(ln, bfa_pport_ln_sm_dn_nf); 780 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
767 bfa_pport_queue_cb(ln, BFA_PPORT_LINKDOWN); 781 bfa_fcport_queue_cb(ln, BFA_PPORT_LINKDOWN);
768 break; 782 break;
769 783
770 default: 784 default:
771 bfa_sm_fault(ln->pport->bfa, event); 785 bfa_sm_fault(ln->fcport->bfa, event);
772 } 786 }
773} 787}
774 788
@@ -776,23 +790,23 @@ bfa_pport_ln_sm_up_dn_nf(struct bfa_pport_ln_s *ln,
776 * Link state is waiting for up notification and there are pending down and up 790 * Link state is waiting for up notification and there are pending down and up
777 */ 791 */
778static void 792static void
779bfa_pport_ln_sm_up_dn_up_nf(struct bfa_pport_ln_s *ln, 793bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
780 enum bfa_pport_ln_sm_event event) 794 enum bfa_fcport_ln_sm_event event)
781{ 795{
782 bfa_trc(ln->pport->bfa, event); 796 bfa_trc(ln->fcport->bfa, event);
783 797
784 switch (event) { 798 switch (event) {
785 case BFA_PPORT_LN_SM_LINKDOWN: 799 case BFA_FCPORT_LN_SM_LINKDOWN:
786 bfa_sm_set_state(ln, bfa_pport_ln_sm_up_dn_nf); 800 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
787 break; 801 break;
788 802
789 case BFA_PPORT_LN_SM_NOTIFICATION: 803 case BFA_FCPORT_LN_SM_NOTIFICATION:
790 bfa_sm_set_state(ln, bfa_pport_ln_sm_dn_up_nf); 804 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
791 bfa_pport_queue_cb(ln, BFA_PPORT_LINKDOWN); 805 bfa_fcport_queue_cb(ln, BFA_PPORT_LINKDOWN);
792 break; 806 break;
793 807
794 default: 808 default:
795 bfa_sm_fault(ln->pport->bfa, event); 809 bfa_sm_fault(ln->fcport->bfa, event);
796 } 810 }
797} 811}
798 812
@@ -801,36 +815,40 @@ bfa_pport_ln_sm_up_dn_up_nf(struct bfa_pport_ln_s *ln,
801 */ 815 */
802 816
803static void 817static void
804__bfa_cb_port_event(void *cbarg, bfa_boolean_t complete) 818__bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete)
805{ 819{
806 struct bfa_pport_ln_s *ln = cbarg; 820 struct bfa_fcport_ln_s *ln = cbarg;
807 821
808 if (complete) 822 if (complete)
809 ln->pport->event_cbfn(ln->pport->event_cbarg, ln->ln_event); 823 ln->fcport->event_cbfn(ln->fcport->event_cbarg, ln->ln_event);
810 else 824 else
811 bfa_sm_send_event(ln, BFA_PPORT_LN_SM_NOTIFICATION); 825 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
812} 826}
813 827
814#define PPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_pport_stats_u), \ 828#define PPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \
829 BFA_CACHELINE_SZ))
830
831#define FCPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \
815 BFA_CACHELINE_SZ)) 832 BFA_CACHELINE_SZ))
816 833
817static void 834static void
818bfa_pport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len, 835bfa_fcport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
819 u32 *dm_len) 836 u32 *dm_len)
820{ 837{
821 *dm_len += PPORT_STATS_DMA_SZ; 838 *dm_len += PPORT_STATS_DMA_SZ;
839 *dm_len += PPORT_STATS_DMA_SZ;
822} 840}
823 841
824static void 842static void
825bfa_pport_qresume(void *cbarg) 843bfa_fcport_qresume(void *cbarg)
826{ 844{
827 struct bfa_pport_s *port = cbarg; 845 struct bfa_fcport_s *port = cbarg;
828 846
829 bfa_sm_send_event(port, BFA_PPORT_SM_QRESUME); 847 bfa_sm_send_event(port, BFA_FCPORT_SM_QRESUME);
830} 848}
831 849
832static void 850static void
833bfa_pport_mem_claim(struct bfa_pport_s *pport, struct bfa_meminfo_s *meminfo) 851bfa_fcport_mem_claim(struct bfa_fcport_s *fcport, struct bfa_meminfo_s *meminfo)
834{ 852{
835 u8 *dm_kva; 853 u8 *dm_kva;
836 u64 dm_pa; 854 u64 dm_pa;
@@ -838,13 +856,22 @@ bfa_pport_mem_claim(struct bfa_pport_s *pport, struct bfa_meminfo_s *meminfo)
838 dm_kva = bfa_meminfo_dma_virt(meminfo); 856 dm_kva = bfa_meminfo_dma_virt(meminfo);
839 dm_pa = bfa_meminfo_dma_phys(meminfo); 857 dm_pa = bfa_meminfo_dma_phys(meminfo);
840 858
841 pport->stats_kva = dm_kva; 859 fcport->stats_kva = dm_kva;
842 pport->stats_pa = dm_pa; 860 fcport->stats_pa = dm_pa;
843 pport->stats = (union bfa_pport_stats_u *)dm_kva; 861 fcport->stats = (union bfa_pport_stats_u *)dm_kva;
844 862
845 dm_kva += PPORT_STATS_DMA_SZ; 863 dm_kva += PPORT_STATS_DMA_SZ;
846 dm_pa += PPORT_STATS_DMA_SZ; 864 dm_pa += PPORT_STATS_DMA_SZ;
847 865
866 /* FC port stats */
867
868 fcport->fcport_stats_kva = dm_kva;
869 fcport->fcport_stats_pa = dm_pa;
870 fcport->fcport_stats = (union bfa_fcport_stats_u *) dm_kva;
871
872 dm_kva += FCPORT_STATS_DMA_SZ;
873 dm_pa += FCPORT_STATS_DMA_SZ;
874
848 bfa_meminfo_dma_virt(meminfo) = dm_kva; 875 bfa_meminfo_dma_virt(meminfo) = dm_kva;
849 bfa_meminfo_dma_phys(meminfo) = dm_pa; 876 bfa_meminfo_dma_phys(meminfo) = dm_pa;
850} 877}
@@ -853,21 +880,21 @@ bfa_pport_mem_claim(struct bfa_pport_s *pport, struct bfa_meminfo_s *meminfo)
853 * Memory initialization. 880 * Memory initialization.
854 */ 881 */
855static void 882static void
856bfa_pport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg, 883bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
857 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev) 884 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
858{ 885{
859 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 886 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
860 struct bfa_pport_cfg_s *port_cfg = &pport->cfg; 887 struct bfa_pport_cfg_s *port_cfg = &fcport->cfg;
861 struct bfa_pport_ln_s *ln = &pport->ln; 888 struct bfa_fcport_ln_s *ln = &fcport->ln;
862 889
863 bfa_os_memset(pport, 0, sizeof(struct bfa_pport_s)); 890 bfa_os_memset(fcport, 0, sizeof(struct bfa_fcport_s));
864 pport->bfa = bfa; 891 fcport->bfa = bfa;
865 ln->pport = pport; 892 ln->fcport = fcport;
866 893
867 bfa_pport_mem_claim(pport, meminfo); 894 bfa_fcport_mem_claim(fcport, meminfo);
868 895
869 bfa_sm_set_state(pport, bfa_pport_sm_uninit); 896 bfa_sm_set_state(fcport, bfa_fcport_sm_uninit);
870 bfa_sm_set_state(ln, bfa_pport_ln_sm_dn); 897 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
871 898
872 /** 899 /**
873 * initialize and set default configuration 900 * initialize and set default configuration
@@ -879,30 +906,30 @@ bfa_pport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
879 906
880 port_cfg->trl_def_speed = BFA_PPORT_SPEED_1GBPS; 907 port_cfg->trl_def_speed = BFA_PPORT_SPEED_1GBPS;
881 908
882 bfa_reqq_winit(&pport->reqq_wait, bfa_pport_qresume, pport); 909 bfa_reqq_winit(&fcport->reqq_wait, bfa_fcport_qresume, fcport);
883} 910}
884 911
885static void 912static void
886bfa_pport_initdone(struct bfa_s *bfa) 913bfa_fcport_initdone(struct bfa_s *bfa)
887{ 914{
888 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 915 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
889 916
890 /** 917 /**
891 * Initialize port attributes from IOC hardware data. 918 * Initialize port attributes from IOC hardware data.
892 */ 919 */
893 bfa_pport_set_wwns(pport); 920 bfa_fcport_set_wwns(fcport);
894 if (pport->cfg.maxfrsize == 0) 921 if (fcport->cfg.maxfrsize == 0)
895 pport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc); 922 fcport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc);
896 pport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc); 923 fcport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc);
897 pport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc); 924 fcport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc);
898 925
899 bfa_assert(pport->cfg.maxfrsize); 926 bfa_assert(fcport->cfg.maxfrsize);
900 bfa_assert(pport->cfg.rx_bbcredit); 927 bfa_assert(fcport->cfg.rx_bbcredit);
901 bfa_assert(pport->speed_sup); 928 bfa_assert(fcport->speed_sup);
902} 929}
903 930
904static void 931static void
905bfa_pport_detach(struct bfa_s *bfa) 932bfa_fcport_detach(struct bfa_s *bfa)
906{ 933{
907} 934}
908 935
@@ -910,62 +937,63 @@ bfa_pport_detach(struct bfa_s *bfa)
910 * Called when IOC is ready. 937 * Called when IOC is ready.
911 */ 938 */
912static void 939static void
913bfa_pport_start(struct bfa_s *bfa) 940bfa_fcport_start(struct bfa_s *bfa)
914{ 941{
915 bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_START); 942 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_START);
916} 943}
917 944
918/** 945/**
919 * Called before IOC is stopped. 946 * Called before IOC is stopped.
920 */ 947 */
921static void 948static void
922bfa_pport_stop(struct bfa_s *bfa) 949bfa_fcport_stop(struct bfa_s *bfa)
923{ 950{
924 bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_STOP); 951 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_STOP);
925} 952}
926 953
927/** 954/**
928 * Called when IOC failure is detected. 955 * Called when IOC failure is detected.
929 */ 956 */
930static void 957static void
931bfa_pport_iocdisable(struct bfa_s *bfa) 958bfa_fcport_iocdisable(struct bfa_s *bfa)
932{ 959{
933 bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_HWFAIL); 960 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_HWFAIL);
934} 961}
935 962
936static void 963static void
937bfa_pport_update_linkinfo(struct bfa_pport_s *pport) 964bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
938{ 965{
939 struct bfi_pport_event_s *pevent = pport->event_arg.i2hmsg.event; 966 struct bfi_pport_event_s *pevent = fcport->event_arg.i2hmsg.event;
940 967
941 pport->speed = pevent->link_state.speed; 968 fcport->speed = pevent->link_state.speed;
942 pport->topology = pevent->link_state.topology; 969 fcport->topology = pevent->link_state.topology;
943 970
944 if (pport->topology == BFA_PPORT_TOPOLOGY_LOOP) 971 if (fcport->topology == BFA_PPORT_TOPOLOGY_LOOP)
945 pport->myalpa = pevent->link_state.tl.loop_info.myalpa; 972 fcport->myalpa =
973 pevent->link_state.tl.loop_info.myalpa;
946 974
947 /* 975 /*
948 * QoS Details 976 * QoS Details
949 */ 977 */
950 bfa_os_assign(pport->qos_attr, pevent->link_state.qos_attr); 978 bfa_os_assign(fcport->qos_attr, pevent->link_state.qos_attr);
951 bfa_os_assign(pport->qos_vc_attr, pevent->link_state.qos_vc_attr); 979 bfa_os_assign(fcport->qos_vc_attr, pevent->link_state.qos_vc_attr);
952 980
953 bfa_trc(pport->bfa, pport->speed); 981 bfa_trc(fcport->bfa, fcport->speed);
954 bfa_trc(pport->bfa, pport->topology); 982 bfa_trc(fcport->bfa, fcport->topology);
955} 983}
956 984
957static void 985static void
958bfa_pport_reset_linkinfo(struct bfa_pport_s *pport) 986bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport)
959{ 987{
960 pport->speed = BFA_PPORT_SPEED_UNKNOWN; 988 fcport->speed = BFA_PPORT_SPEED_UNKNOWN;
961 pport->topology = BFA_PPORT_TOPOLOGY_NONE; 989 fcport->topology = BFA_PPORT_TOPOLOGY_NONE;
962} 990}
963 991
964/** 992/**
965 * Send port enable message to firmware. 993 * Send port enable message to firmware.
966 */ 994 */
967static bfa_boolean_t 995static bfa_boolean_t
968bfa_pport_send_enable(struct bfa_pport_s *port) 996bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
969{ 997{
970 struct bfi_pport_enable_req_s *m; 998 struct bfi_pport_enable_req_s *m;
971 999
@@ -973,32 +1001,34 @@ bfa_pport_send_enable(struct bfa_pport_s *port)
973 * Increment message tag before queue check, so that responses to old 1001 * Increment message tag before queue check, so that responses to old
974 * requests are discarded. 1002 * requests are discarded.
975 */ 1003 */
976 port->msgtag++; 1004 fcport->msgtag++;
977 1005
978 /** 1006 /**
979 * check for room in queue to send request now 1007 * check for room in queue to send request now
980 */ 1008 */
981 m = bfa_reqq_next(port->bfa, BFA_REQQ_PORT); 1009 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
982 if (!m) { 1010 if (!m) {
983 bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->reqq_wait); 1011 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
1012 &fcport->reqq_wait);
984 return BFA_FALSE; 1013 return BFA_FALSE;
985 } 1014 }
986 1015
987 bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_ENABLE_REQ, 1016 bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_ENABLE_REQ,
988 bfa_lpuid(port->bfa)); 1017 bfa_lpuid(fcport->bfa));
989 m->nwwn = port->nwwn; 1018 m->nwwn = fcport->nwwn;
990 m->pwwn = port->pwwn; 1019 m->pwwn = fcport->pwwn;
991 m->port_cfg = port->cfg; 1020 m->port_cfg = fcport->cfg;
992 m->msgtag = port->msgtag; 1021 m->msgtag = fcport->msgtag;
993 m->port_cfg.maxfrsize = bfa_os_htons(port->cfg.maxfrsize); 1022 m->port_cfg.maxfrsize = bfa_os_htons(fcport->cfg.maxfrsize);
994 bfa_dma_be_addr_set(m->stats_dma_addr, port->stats_pa); 1023 bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa);
995 bfa_trc(port->bfa, m->stats_dma_addr.a32.addr_lo); 1024 bfa_dma_be_addr_set(m->fcport_stats_dma_addr, fcport->fcport_stats_pa);
996 bfa_trc(port->bfa, m->stats_dma_addr.a32.addr_hi); 1025 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo);
1026 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi);
997 1027
998 /** 1028 /**
999 * queue I/O message to firmware 1029 * queue I/O message to firmware
1000 */ 1030 */
1001 bfa_reqq_produce(port->bfa, BFA_REQQ_PORT); 1031 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1002 return BFA_TRUE; 1032 return BFA_TRUE;
1003} 1033}
1004 1034
@@ -1006,7 +1036,7 @@ bfa_pport_send_enable(struct bfa_pport_s *port)
1006 * Send port disable message to firmware. 1036 * Send port disable message to firmware.
1007 */ 1037 */
1008static bfa_boolean_t 1038static bfa_boolean_t
1009bfa_pport_send_disable(struct bfa_pport_s *port) 1039bfa_fcport_send_disable(struct bfa_fcport_s *fcport)
1010{ 1040{
1011 bfi_pport_disable_req_t *m; 1041 bfi_pport_disable_req_t *m;
1012 1042
@@ -1014,63 +1044,64 @@ bfa_pport_send_disable(struct bfa_pport_s *port)
1014 * Increment message tag before queue check, so that responses to old 1044 * Increment message tag before queue check, so that responses to old
1015 * requests are discarded. 1045 * requests are discarded.
1016 */ 1046 */
1017 port->msgtag++; 1047 fcport->msgtag++;
1018 1048
1019 /** 1049 /**
1020 * check for room in queue to send request now 1050 * check for room in queue to send request now
1021 */ 1051 */
1022 m = bfa_reqq_next(port->bfa, BFA_REQQ_PORT); 1052 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
1023 if (!m) { 1053 if (!m) {
1024 bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->reqq_wait); 1054 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
1055 &fcport->reqq_wait);
1025 return BFA_FALSE; 1056 return BFA_FALSE;
1026 } 1057 }
1027 1058
1028 bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_DISABLE_REQ, 1059 bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_DISABLE_REQ,
1029 bfa_lpuid(port->bfa)); 1060 bfa_lpuid(fcport->bfa));
1030 m->msgtag = port->msgtag; 1061 m->msgtag = fcport->msgtag;
1031 1062
1032 /** 1063 /**
1033 * queue I/O message to firmware 1064 * queue I/O message to firmware
1034 */ 1065 */
1035 bfa_reqq_produce(port->bfa, BFA_REQQ_PORT); 1066 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1036 1067
1037 return BFA_TRUE; 1068 return BFA_TRUE;
1038} 1069}
1039 1070
1040static void 1071static void
1041bfa_pport_set_wwns(struct bfa_pport_s *port) 1072bfa_fcport_set_wwns(struct bfa_fcport_s *fcport)
1042{ 1073{
1043 port->pwwn = bfa_ioc_get_pwwn(&port->bfa->ioc); 1074 fcport->pwwn = bfa_ioc_get_pwwn(&fcport->bfa->ioc);
1044 port->nwwn = bfa_ioc_get_nwwn(&port->bfa->ioc); 1075 fcport->nwwn = bfa_ioc_get_nwwn(&fcport->bfa->ioc);
1045 1076
1046 bfa_trc(port->bfa, port->pwwn); 1077 bfa_trc(fcport->bfa, fcport->pwwn);
1047 bfa_trc(port->bfa, port->nwwn); 1078 bfa_trc(fcport->bfa, fcport->nwwn);
1048} 1079}
1049 1080
1050static void 1081static void
1051bfa_port_send_txcredit(void *port_cbarg) 1082bfa_fcport_send_txcredit(void *port_cbarg)
1052{ 1083{
1053 1084
1054 struct bfa_pport_s *port = port_cbarg; 1085 struct bfa_fcport_s *fcport = port_cbarg;
1055 struct bfi_pport_set_svc_params_req_s *m; 1086 struct bfi_pport_set_svc_params_req_s *m;
1056 1087
1057 /** 1088 /**
1058 * check for room in queue to send request now 1089 * check for room in queue to send request now
1059 */ 1090 */
1060 m = bfa_reqq_next(port->bfa, BFA_REQQ_PORT); 1091 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
1061 if (!m) { 1092 if (!m) {
1062 bfa_trc(port->bfa, port->cfg.tx_bbcredit); 1093 bfa_trc(fcport->bfa, fcport->cfg.tx_bbcredit);
1063 return; 1094 return;
1064 } 1095 }
1065 1096
1066 bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_SET_SVC_PARAMS_REQ, 1097 bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_SET_SVC_PARAMS_REQ,
1067 bfa_lpuid(port->bfa)); 1098 bfa_lpuid(fcport->bfa));
1068 m->tx_bbcredit = bfa_os_htons((u16) port->cfg.tx_bbcredit); 1099 m->tx_bbcredit = bfa_os_htons((u16) fcport->cfg.tx_bbcredit);
1069 1100
1070 /** 1101 /**
1071 * queue I/O message to firmware 1102 * queue I/O message to firmware
1072 */ 1103 */
1073 bfa_reqq_produce(port->bfa, BFA_REQQ_PORT); 1104 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1074} 1105}
1075 1106
1076 1107
@@ -1083,32 +1114,32 @@ bfa_port_send_txcredit(void *port_cbarg)
1083 * Firmware message handler. 1114 * Firmware message handler.
1084 */ 1115 */
1085void 1116void
1086bfa_pport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg) 1117bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
1087{ 1118{
1088 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1119 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1089 union bfi_pport_i2h_msg_u i2hmsg; 1120 union bfi_pport_i2h_msg_u i2hmsg;
1090 1121
1091 i2hmsg.msg = msg; 1122 i2hmsg.msg = msg;
1092 pport->event_arg.i2hmsg = i2hmsg; 1123 fcport->event_arg.i2hmsg = i2hmsg;
1093 1124
1094 switch (msg->mhdr.msg_id) { 1125 switch (msg->mhdr.msg_id) {
1095 case BFI_PPORT_I2H_ENABLE_RSP: 1126 case BFI_PPORT_I2H_ENABLE_RSP:
1096 if (pport->msgtag == i2hmsg.enable_rsp->msgtag) 1127 if (fcport->msgtag == i2hmsg.enable_rsp->msgtag)
1097 bfa_sm_send_event(pport, BFA_PPORT_SM_FWRSP); 1128 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
1098 break; 1129 break;
1099 1130
1100 case BFI_PPORT_I2H_DISABLE_RSP: 1131 case BFI_PPORT_I2H_DISABLE_RSP:
1101 if (pport->msgtag == i2hmsg.enable_rsp->msgtag) 1132 if (fcport->msgtag == i2hmsg.enable_rsp->msgtag)
1102 bfa_sm_send_event(pport, BFA_PPORT_SM_FWRSP); 1133 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
1103 break; 1134 break;
1104 1135
1105 case BFI_PPORT_I2H_EVENT: 1136 case BFI_PPORT_I2H_EVENT:
1106 switch (i2hmsg.event->link_state.linkstate) { 1137 switch (i2hmsg.event->link_state.linkstate) {
1107 case BFA_PPORT_LINKUP: 1138 case BFA_PPORT_LINKUP:
1108 bfa_sm_send_event(pport, BFA_PPORT_SM_LINKUP); 1139 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP);
1109 break; 1140 break;
1110 case BFA_PPORT_LINKDOWN: 1141 case BFA_PPORT_LINKDOWN:
1111 bfa_sm_send_event(pport, BFA_PPORT_SM_LINKDOWN); 1142 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKDOWN);
1112 break; 1143 break;
1113 case BFA_PPORT_TRUNK_LINKDOWN: 1144 case BFA_PPORT_TRUNK_LINKDOWN:
1114 /** todo: event notification */ 1145 /** todo: event notification */
@@ -1121,32 +1152,63 @@ bfa_pport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
1121 /* 1152 /*
1122 * check for timer pop before processing the rsp 1153 * check for timer pop before processing the rsp
1123 */ 1154 */
1124 if (pport->stats_busy == BFA_FALSE 1155 if (fcport->stats_busy == BFA_FALSE
1125 || pport->stats_status == BFA_STATUS_ETIMER) 1156 || fcport->stats_status == BFA_STATUS_ETIMER)
1126 break; 1157 break;
1127 1158
1128 bfa_timer_stop(&pport->timer); 1159 bfa_timer_stop(&fcport->timer);
1129 pport->stats_status = i2hmsg.getstats_rsp->status; 1160 fcport->stats_status = i2hmsg.getstats_rsp->status;
1130 bfa_cb_queue(pport->bfa, &pport->hcb_qe, __bfa_cb_port_stats, 1161 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_port_stats,
1131 pport); 1162 fcport);
1132 break; 1163 break;
1133 case BFI_PPORT_I2H_CLEAR_STATS_RSP: 1164 case BFI_PPORT_I2H_CLEAR_STATS_RSP:
1134 case BFI_PPORT_I2H_CLEAR_QOS_STATS_RSP: 1165 case BFI_PPORT_I2H_CLEAR_QOS_STATS_RSP:
1135 /* 1166 /*
1136 * check for timer pop before processing the rsp 1167 * check for timer pop before processing the rsp
1137 */ 1168 */
1138 if (pport->stats_busy == BFA_FALSE 1169 if (fcport->stats_busy == BFA_FALSE
1139 || pport->stats_status == BFA_STATUS_ETIMER) 1170 || fcport->stats_status == BFA_STATUS_ETIMER)
1140 break; 1171 break;
1141 1172
1142 bfa_timer_stop(&pport->timer); 1173 bfa_timer_stop(&fcport->timer);
1143 pport->stats_status = BFA_STATUS_OK; 1174 fcport->stats_status = BFA_STATUS_OK;
1144 bfa_cb_queue(pport->bfa, &pport->hcb_qe, 1175 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
1145 __bfa_cb_port_stats_clr, pport); 1176 __bfa_cb_port_stats_clr, fcport);
1177 break;
1178
1179 case BFI_FCPORT_I2H_GET_STATS_RSP:
1180 /*
1181 * check for timer pop before processing the rsp
1182 */
1183 if (fcport->stats_busy == BFA_FALSE ||
1184 fcport->stats_status == BFA_STATUS_ETIMER) {
1185 break;
1186 }
1187
1188 bfa_timer_stop(&fcport->timer);
1189 fcport->stats_status = i2hmsg.getstats_rsp->status;
1190 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
1191 __bfa_cb_fcport_stats, fcport);
1192 break;
1193
1194 case BFI_FCPORT_I2H_CLEAR_STATS_RSP:
1195 /*
1196 * check for timer pop before processing the rsp
1197 */
1198 if (fcport->stats_busy == BFA_FALSE ||
1199 fcport->stats_status == BFA_STATUS_ETIMER) {
1200 break;
1201 }
1202
1203 bfa_timer_stop(&fcport->timer);
1204 fcport->stats_status = BFA_STATUS_OK;
1205 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
1206 __bfa_cb_fcport_stats_clr, fcport);
1146 break; 1207 break;
1147 1208
1148 default: 1209 default:
1149 bfa_assert(0); 1210 bfa_assert(0);
1211 break;
1150 } 1212 }
1151} 1213}
1152 1214
@@ -1160,35 +1222,35 @@ bfa_pport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
1160 * Registered callback for port events. 1222 * Registered callback for port events.
1161 */ 1223 */
1162void 1224void
1163bfa_pport_event_register(struct bfa_s *bfa, 1225bfa_fcport_event_register(struct bfa_s *bfa,
1164 void (*cbfn) (void *cbarg, bfa_pport_event_t event), 1226 void (*cbfn) (void *cbarg, bfa_pport_event_t event),
1165 void *cbarg) 1227 void *cbarg)
1166{ 1228{
1167 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1229 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1168 1230
1169 pport->event_cbfn = cbfn; 1231 fcport->event_cbfn = cbfn;
1170 pport->event_cbarg = cbarg; 1232 fcport->event_cbarg = cbarg;
1171} 1233}
1172 1234
1173bfa_status_t 1235bfa_status_t
1174bfa_pport_enable(struct bfa_s *bfa) 1236bfa_fcport_enable(struct bfa_s *bfa)
1175{ 1237{
1176 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1238 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1177 1239
1178 if (pport->diag_busy) 1240 if (fcport->diag_busy)
1179 return BFA_STATUS_DIAG_BUSY; 1241 return BFA_STATUS_DIAG_BUSY;
1180 else if (bfa_sm_cmp_state 1242 else if (bfa_sm_cmp_state
1181 (BFA_PORT_MOD(bfa), bfa_pport_sm_disabling_qwait)) 1243 (BFA_FCPORT_MOD(bfa), bfa_fcport_sm_disabling_qwait))
1182 return BFA_STATUS_DEVBUSY; 1244 return BFA_STATUS_DEVBUSY;
1183 1245
1184 bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_ENABLE); 1246 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_ENABLE);
1185 return BFA_STATUS_OK; 1247 return BFA_STATUS_OK;
1186} 1248}
1187 1249
1188bfa_status_t 1250bfa_status_t
1189bfa_pport_disable(struct bfa_s *bfa) 1251bfa_fcport_disable(struct bfa_s *bfa)
1190{ 1252{
1191 bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_DISABLE); 1253 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DISABLE);
1192 return BFA_STATUS_OK; 1254 return BFA_STATUS_OK;
1193} 1255}
1194 1256
@@ -1196,18 +1258,18 @@ bfa_pport_disable(struct bfa_s *bfa)
1196 * Configure port speed. 1258 * Configure port speed.
1197 */ 1259 */
1198bfa_status_t 1260bfa_status_t
1199bfa_pport_cfg_speed(struct bfa_s *bfa, enum bfa_pport_speed speed) 1261bfa_fcport_cfg_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
1200{ 1262{
1201 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1263 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1202 1264
1203 bfa_trc(bfa, speed); 1265 bfa_trc(bfa, speed);
1204 1266
1205 if ((speed != BFA_PPORT_SPEED_AUTO) && (speed > pport->speed_sup)) { 1267 if ((speed != BFA_PPORT_SPEED_AUTO) && (speed > fcport->speed_sup)) {
1206 bfa_trc(bfa, pport->speed_sup); 1268 bfa_trc(bfa, fcport->speed_sup);
1207 return BFA_STATUS_UNSUPP_SPEED; 1269 return BFA_STATUS_UNSUPP_SPEED;
1208 } 1270 }
1209 1271
1210 pport->cfg.speed = speed; 1272 fcport->cfg.speed = speed;
1211 1273
1212 return BFA_STATUS_OK; 1274 return BFA_STATUS_OK;
1213} 1275}
@@ -1216,23 +1278,23 @@ bfa_pport_cfg_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
1216 * Get current speed. 1278 * Get current speed.
1217 */ 1279 */
1218enum bfa_pport_speed 1280enum bfa_pport_speed
1219bfa_pport_get_speed(struct bfa_s *bfa) 1281bfa_fcport_get_speed(struct bfa_s *bfa)
1220{ 1282{
1221 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 1283 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1222 1284
1223 return port->speed; 1285 return fcport->speed;
1224} 1286}
1225 1287
1226/** 1288/**
1227 * Configure port topology. 1289 * Configure port topology.
1228 */ 1290 */
1229bfa_status_t 1291bfa_status_t
1230bfa_pport_cfg_topology(struct bfa_s *bfa, enum bfa_pport_topology topology) 1292bfa_fcport_cfg_topology(struct bfa_s *bfa, enum bfa_pport_topology topology)
1231{ 1293{
1232 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1294 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1233 1295
1234 bfa_trc(bfa, topology); 1296 bfa_trc(bfa, topology);
1235 bfa_trc(bfa, pport->cfg.topology); 1297 bfa_trc(bfa, fcport->cfg.topology);
1236 1298
1237 switch (topology) { 1299 switch (topology) {
1238 case BFA_PPORT_TOPOLOGY_P2P: 1300 case BFA_PPORT_TOPOLOGY_P2P:
@@ -1244,7 +1306,7 @@ bfa_pport_cfg_topology(struct bfa_s *bfa, enum bfa_pport_topology topology)
1244 return BFA_STATUS_EINVAL; 1306 return BFA_STATUS_EINVAL;
1245 } 1307 }
1246 1308
1247 pport->cfg.topology = topology; 1309 fcport->cfg.topology = topology;
1248 return BFA_STATUS_OK; 1310 return BFA_STATUS_OK;
1249} 1311}
1250 1312
@@ -1252,64 +1314,64 @@ bfa_pport_cfg_topology(struct bfa_s *bfa, enum bfa_pport_topology topology)
1252 * Get current topology. 1314 * Get current topology.
1253 */ 1315 */
1254enum bfa_pport_topology 1316enum bfa_pport_topology
1255bfa_pport_get_topology(struct bfa_s *bfa) 1317bfa_fcport_get_topology(struct bfa_s *bfa)
1256{ 1318{
1257 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 1319 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1258 1320
1259 return port->topology; 1321 return fcport->topology;
1260} 1322}
1261 1323
1262bfa_status_t 1324bfa_status_t
1263bfa_pport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa) 1325bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
1264{ 1326{
1265 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1327 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1266 1328
1267 bfa_trc(bfa, alpa); 1329 bfa_trc(bfa, alpa);
1268 bfa_trc(bfa, pport->cfg.cfg_hardalpa); 1330 bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
1269 bfa_trc(bfa, pport->cfg.hardalpa); 1331 bfa_trc(bfa, fcport->cfg.hardalpa);
1270 1332
1271 pport->cfg.cfg_hardalpa = BFA_TRUE; 1333 fcport->cfg.cfg_hardalpa = BFA_TRUE;
1272 pport->cfg.hardalpa = alpa; 1334 fcport->cfg.hardalpa = alpa;
1273 1335
1274 return BFA_STATUS_OK; 1336 return BFA_STATUS_OK;
1275} 1337}
1276 1338
1277bfa_status_t 1339bfa_status_t
1278bfa_pport_clr_hardalpa(struct bfa_s *bfa) 1340bfa_fcport_clr_hardalpa(struct bfa_s *bfa)
1279{ 1341{
1280 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1342 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1281 1343
1282 bfa_trc(bfa, pport->cfg.cfg_hardalpa); 1344 bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
1283 bfa_trc(bfa, pport->cfg.hardalpa); 1345 bfa_trc(bfa, fcport->cfg.hardalpa);
1284 1346
1285 pport->cfg.cfg_hardalpa = BFA_FALSE; 1347 fcport->cfg.cfg_hardalpa = BFA_FALSE;
1286 return BFA_STATUS_OK; 1348 return BFA_STATUS_OK;
1287} 1349}
1288 1350
1289bfa_boolean_t 1351bfa_boolean_t
1290bfa_pport_get_hardalpa(struct bfa_s *bfa, u8 *alpa) 1352bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa)
1291{ 1353{
1292 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 1354 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1293 1355
1294 *alpa = port->cfg.hardalpa; 1356 *alpa = fcport->cfg.hardalpa;
1295 return port->cfg.cfg_hardalpa; 1357 return fcport->cfg.cfg_hardalpa;
1296} 1358}
1297 1359
1298u8 1360u8
1299bfa_pport_get_myalpa(struct bfa_s *bfa) 1361bfa_fcport_get_myalpa(struct bfa_s *bfa)
1300{ 1362{
1301 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 1363 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1302 1364
1303 return port->myalpa; 1365 return fcport->myalpa;
1304} 1366}
1305 1367
1306bfa_status_t 1368bfa_status_t
1307bfa_pport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize) 1369bfa_fcport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
1308{ 1370{
1309 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1371 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1310 1372
1311 bfa_trc(bfa, maxfrsize); 1373 bfa_trc(bfa, maxfrsize);
1312 bfa_trc(bfa, pport->cfg.maxfrsize); 1374 bfa_trc(bfa, fcport->cfg.maxfrsize);
1313 1375
1314 /* 1376 /*
1315 * with in range 1377 * with in range
@@ -1323,41 +1385,41 @@ bfa_pport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
1323 if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1))) 1385 if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1)))
1324 return BFA_STATUS_INVLD_DFSZ; 1386 return BFA_STATUS_INVLD_DFSZ;
1325 1387
1326 pport->cfg.maxfrsize = maxfrsize; 1388 fcport->cfg.maxfrsize = maxfrsize;
1327 return BFA_STATUS_OK; 1389 return BFA_STATUS_OK;
1328} 1390}
1329 1391
1330u16 1392u16
1331bfa_pport_get_maxfrsize(struct bfa_s *bfa) 1393bfa_fcport_get_maxfrsize(struct bfa_s *bfa)
1332{ 1394{
1333 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 1395 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1334 1396
1335 return port->cfg.maxfrsize; 1397 return fcport->cfg.maxfrsize;
1336} 1398}
1337 1399
1338u32 1400u32
1339bfa_pport_mypid(struct bfa_s *bfa) 1401bfa_fcport_mypid(struct bfa_s *bfa)
1340{ 1402{
1341 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 1403 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1342 1404
1343 return port->mypid; 1405 return fcport->mypid;
1344} 1406}
1345 1407
1346u8 1408u8
1347bfa_pport_get_rx_bbcredit(struct bfa_s *bfa) 1409bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa)
1348{ 1410{
1349 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 1411 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1350 1412
1351 return port->cfg.rx_bbcredit; 1413 return fcport->cfg.rx_bbcredit;
1352} 1414}
1353 1415
1354void 1416void
1355bfa_pport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit) 1417bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit)
1356{ 1418{
1357 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 1419 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1358 1420
1359 port->cfg.tx_bbcredit = (u8) tx_bbcredit; 1421 fcport->cfg.tx_bbcredit = (u8) tx_bbcredit;
1360 bfa_port_send_txcredit(port); 1422 bfa_fcport_send_txcredit(fcport);
1361} 1423}
1362 1424
1363/** 1425/**
@@ -1365,78 +1427,79 @@ bfa_pport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit)
1365 */ 1427 */
1366 1428
1367wwn_t 1429wwn_t
1368bfa_pport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node) 1430bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node)
1369{ 1431{
1370 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1432 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1371 if (node) 1433 if (node)
1372 return pport->nwwn; 1434 return fcport->nwwn;
1373 else 1435 else
1374 return pport->pwwn; 1436 return fcport->pwwn;
1375} 1437}
1376 1438
1377void 1439void
1378bfa_pport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr) 1440bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr)
1379{ 1441{
1380 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1442 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1381 1443
1382 bfa_os_memset(attr, 0, sizeof(struct bfa_pport_attr_s)); 1444 bfa_os_memset(attr, 0, sizeof(struct bfa_pport_attr_s));
1383 1445
1384 attr->nwwn = pport->nwwn; 1446 attr->nwwn = fcport->nwwn;
1385 attr->pwwn = pport->pwwn; 1447 attr->pwwn = fcport->pwwn;
1386 1448
1387 bfa_os_memcpy(&attr->pport_cfg, &pport->cfg, 1449 bfa_os_memcpy(&attr->pport_cfg, &fcport->cfg,
1388 sizeof(struct bfa_pport_cfg_s)); 1450 sizeof(struct bfa_pport_cfg_s));
1389 /* 1451 /*
1390 * speed attributes 1452 * speed attributes
1391 */ 1453 */
1392 attr->pport_cfg.speed = pport->cfg.speed; 1454 attr->pport_cfg.speed = fcport->cfg.speed;
1393 attr->speed_supported = pport->speed_sup; 1455 attr->speed_supported = fcport->speed_sup;
1394 attr->speed = pport->speed; 1456 attr->speed = fcport->speed;
1395 attr->cos_supported = FC_CLASS_3; 1457 attr->cos_supported = FC_CLASS_3;
1396 1458
1397 /* 1459 /*
1398 * topology attributes 1460 * topology attributes
1399 */ 1461 */
1400 attr->pport_cfg.topology = pport->cfg.topology; 1462 attr->pport_cfg.topology = fcport->cfg.topology;
1401 attr->topology = pport->topology; 1463 attr->topology = fcport->topology;
1402 1464
1403 /* 1465 /*
1404 * beacon attributes 1466 * beacon attributes
1405 */ 1467 */
1406 attr->beacon = pport->beacon; 1468 attr->beacon = fcport->beacon;
1407 attr->link_e2e_beacon = pport->link_e2e_beacon; 1469 attr->link_e2e_beacon = fcport->link_e2e_beacon;
1408 attr->plog_enabled = bfa_plog_get_setting(pport->bfa->plog); 1470 attr->plog_enabled = bfa_plog_get_setting(fcport->bfa->plog);
1409 1471
1410 attr->pport_cfg.path_tov = bfa_fcpim_path_tov_get(bfa); 1472 attr->pport_cfg.path_tov = bfa_fcpim_path_tov_get(bfa);
1411 attr->pport_cfg.q_depth = bfa_fcpim_qdepth_get(bfa); 1473 attr->pport_cfg.q_depth = bfa_fcpim_qdepth_get(bfa);
1412 attr->port_state = bfa_sm_to_state(hal_pport_sm_table, pport->sm); 1474 attr->port_state = bfa_sm_to_state(hal_pport_sm_table, fcport->sm);
1413 if (bfa_ioc_is_disabled(&pport->bfa->ioc)) 1475 if (bfa_ioc_is_disabled(&fcport->bfa->ioc))
1414 attr->port_state = BFA_PPORT_ST_IOCDIS; 1476 attr->port_state = BFA_PPORT_ST_IOCDIS;
1415 else if (bfa_ioc_fw_mismatch(&pport->bfa->ioc)) 1477 else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc))
1416 attr->port_state = BFA_PPORT_ST_FWMISMATCH; 1478 attr->port_state = BFA_PPORT_ST_FWMISMATCH;
1417} 1479}
1418 1480
1419static void 1481static void
1420bfa_port_stats_query(void *cbarg) 1482bfa_port_stats_query(void *cbarg)
1421{ 1483{
1422 struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg; 1484 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
1423 bfi_pport_get_stats_req_t *msg; 1485 bfi_pport_get_stats_req_t *msg;
1424 1486
1425 msg = bfa_reqq_next(port->bfa, BFA_REQQ_PORT); 1487 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
1426 1488
1427 if (!msg) { 1489 if (!msg) {
1428 port->stats_qfull = BFA_TRUE; 1490 fcport->stats_qfull = BFA_TRUE;
1429 bfa_reqq_winit(&port->stats_reqq_wait, bfa_port_stats_query, 1491 bfa_reqq_winit(&fcport->stats_reqq_wait, bfa_port_stats_query,
1430 port); 1492 fcport);
1431 bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->stats_reqq_wait); 1493 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
1494 &fcport->stats_reqq_wait);
1432 return; 1495 return;
1433 } 1496 }
1434 port->stats_qfull = BFA_FALSE; 1497 fcport->stats_qfull = BFA_FALSE;
1435 1498
1436 bfa_os_memset(msg, 0, sizeof(bfi_pport_get_stats_req_t)); 1499 bfa_os_memset(msg, 0, sizeof(bfi_pport_get_stats_req_t));
1437 bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_GET_STATS_REQ, 1500 bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_GET_STATS_REQ,
1438 bfa_lpuid(port->bfa)); 1501 bfa_lpuid(fcport->bfa));
1439 bfa_reqq_produce(port->bfa, BFA_REQQ_PORT); 1502 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1440 1503
1441 return; 1504 return;
1442} 1505}
@@ -1444,65 +1507,111 @@ bfa_port_stats_query(void *cbarg)
1444static void 1507static void
1445bfa_port_stats_clear(void *cbarg) 1508bfa_port_stats_clear(void *cbarg)
1446{ 1509{
1447 struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg; 1510 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
1448 bfi_pport_clear_stats_req_t *msg; 1511 bfi_pport_clear_stats_req_t *msg;
1449 1512
1450 msg = bfa_reqq_next(port->bfa, BFA_REQQ_PORT); 1513 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
1451 1514
1452 if (!msg) { 1515 if (!msg) {
1453 port->stats_qfull = BFA_TRUE; 1516 fcport->stats_qfull = BFA_TRUE;
1454 bfa_reqq_winit(&port->stats_reqq_wait, bfa_port_stats_clear, 1517 bfa_reqq_winit(&fcport->stats_reqq_wait, bfa_port_stats_clear,
1455 port); 1518 fcport);
1456 bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->stats_reqq_wait); 1519 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
1520 &fcport->stats_reqq_wait);
1457 return; 1521 return;
1458 } 1522 }
1459 port->stats_qfull = BFA_FALSE; 1523 fcport->stats_qfull = BFA_FALSE;
1460 1524
1461 bfa_os_memset(msg, 0, sizeof(bfi_pport_clear_stats_req_t)); 1525 bfa_os_memset(msg, 0, sizeof(bfi_pport_clear_stats_req_t));
1462 bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_CLEAR_STATS_REQ, 1526 bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_CLEAR_STATS_REQ,
1463 bfa_lpuid(port->bfa)); 1527 bfa_lpuid(fcport->bfa));
1464 bfa_reqq_produce(port->bfa, BFA_REQQ_PORT); 1528 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1465 return; 1529 return;
1466} 1530}
1467 1531
1468static void 1532static void
1533bfa_fcport_stats_query(void *cbarg)
1534{
1535 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
1536 bfi_pport_get_stats_req_t *msg;
1537
1538 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
1539
1540 if (!msg) {
1541 fcport->stats_qfull = BFA_TRUE;
1542 bfa_reqq_winit(&fcport->stats_reqq_wait,
1543 bfa_fcport_stats_query, fcport);
1544 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
1545 &fcport->stats_reqq_wait);
1546 return;
1547 }
1548 fcport->stats_qfull = BFA_FALSE;
1549
1550 bfa_os_memset(msg, 0, sizeof(bfi_pport_get_stats_req_t));
1551 bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_FCPORT_H2I_GET_STATS_REQ,
1552 bfa_lpuid(fcport->bfa));
1553 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1554}
1555
1556static void
1557bfa_fcport_stats_clear(void *cbarg)
1558{
1559 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
1560 bfi_pport_clear_stats_req_t *msg;
1561
1562 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
1563
1564 if (!msg) {
1565 fcport->stats_qfull = BFA_TRUE;
1566 bfa_reqq_winit(&fcport->stats_reqq_wait,
1567 bfa_fcport_stats_clear, fcport);
1568 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
1569 &fcport->stats_reqq_wait);
1570 return;
1571 }
1572 fcport->stats_qfull = BFA_FALSE;
1573
1574 bfa_os_memset(msg, 0, sizeof(bfi_pport_clear_stats_req_t));
1575 bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_FCPORT_H2I_CLEAR_STATS_REQ,
1576 bfa_lpuid(fcport->bfa));
1577 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1578}
1579
1580static void
1469bfa_port_qos_stats_clear(void *cbarg) 1581bfa_port_qos_stats_clear(void *cbarg)
1470{ 1582{
1471 struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg; 1583 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
1472 bfi_pport_clear_qos_stats_req_t *msg; 1584 bfi_pport_clear_qos_stats_req_t *msg;
1473 1585
1474 msg = bfa_reqq_next(port->bfa, BFA_REQQ_PORT); 1586 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
1475 1587
1476 if (!msg) { 1588 if (!msg) {
1477 port->stats_qfull = BFA_TRUE; 1589 fcport->stats_qfull = BFA_TRUE;
1478 bfa_reqq_winit(&port->stats_reqq_wait, bfa_port_qos_stats_clear, 1590 bfa_reqq_winit(&fcport->stats_reqq_wait,
1479 port); 1591 bfa_port_qos_stats_clear, fcport);
1480 bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->stats_reqq_wait); 1592 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
1593 &fcport->stats_reqq_wait);
1481 return; 1594 return;
1482 } 1595 }
1483 port->stats_qfull = BFA_FALSE; 1596 fcport->stats_qfull = BFA_FALSE;
1484 1597
1485 bfa_os_memset(msg, 0, sizeof(bfi_pport_clear_qos_stats_req_t)); 1598 bfa_os_memset(msg, 0, sizeof(bfi_pport_clear_qos_stats_req_t));
1486 bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_CLEAR_QOS_STATS_REQ, 1599 bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_CLEAR_QOS_STATS_REQ,
1487 bfa_lpuid(port->bfa)); 1600 bfa_lpuid(fcport->bfa));
1488 bfa_reqq_produce(port->bfa, BFA_REQQ_PORT); 1601 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1489 return; 1602 return;
1490} 1603}
1491 1604
1492static void 1605static void
1493bfa_pport_stats_swap(union bfa_pport_stats_u *d, union bfa_pport_stats_u *s) 1606bfa_fcport_stats_swap(union bfa_fcport_stats_u *d, union bfa_fcport_stats_u *s)
1494{ 1607{
1495 u32 *dip = (u32 *) d; 1608 u32 *dip = (u32 *) d;
1496 u32 *sip = (u32 *) s; 1609 u32 *sip = (u32 *) s;
1497 int i; 1610 int i;
1498 1611
1499 /* 1612 /* Do 64 bit fields swap first */
1500 * Do 64 bit fields swap first 1613 for (i = 0; i < ((sizeof(union bfa_fcport_stats_u) -
1501 */ 1614 sizeof(struct bfa_qos_stats_s))/sizeof(u32)); i = i + 2) {
1502 for (i = 0;
1503 i <
1504 ((sizeof(union bfa_pport_stats_u) -
1505 sizeof(struct bfa_qos_stats_s)) / sizeof(u32)); i = i + 2) {
1506#ifdef __BIGENDIAN 1615#ifdef __BIGENDIAN
1507 dip[i] = bfa_os_ntohl(sip[i]); 1616 dip[i] = bfa_os_ntohl(sip[i]);
1508 dip[i + 1] = bfa_os_ntohl(sip[i + 1]); 1617 dip[i + 1] = bfa_os_ntohl(sip[i + 1]);
@@ -1512,56 +1621,88 @@ bfa_pport_stats_swap(union bfa_pport_stats_u *d, union bfa_pport_stats_u *s)
1512#endif 1621#endif
1513 } 1622 }
1514 1623
1515 /* 1624 /* Now swap the 32 bit fields */
1516 * Now swap the 32 bit fields 1625 for (; i < (sizeof(union bfa_fcport_stats_u)/sizeof(u32)); ++i)
1517 */ 1626 dip[i] = bfa_os_ntohl(sip[i]);
1518 for (; i < (sizeof(union bfa_pport_stats_u) / sizeof(u32)); ++i) 1627}
1628
1629static void
1630bfa_port_stats_swap(union bfa_pport_stats_u *d, union bfa_pport_stats_u *s)
1631{
1632 u32 *dip = (u32 *) d;
1633 u32 *sip = (u32 *) s;
1634 int i;
1635
1636 /* Do 64 bit fields swap first */
1637 for (i = 0; i < (sizeof(union bfa_pport_stats_u) / sizeof(u32));
1638 i = i + 2) {
1639#ifdef __BIGENDIAN
1519 dip[i] = bfa_os_ntohl(sip[i]); 1640 dip[i] = bfa_os_ntohl(sip[i]);
1641 dip[i + 1] = bfa_os_ntohl(sip[i + 1]);
1642#else
1643 dip[i] = bfa_os_ntohl(sip[i + 1]);
1644 dip[i + 1] = bfa_os_ntohl(sip[i]);
1645#endif
1646 }
1520} 1647}
1521 1648
1522static void 1649static void
1523__bfa_cb_port_stats_clr(void *cbarg, bfa_boolean_t complete) 1650__bfa_cb_port_stats_clr(void *cbarg, bfa_boolean_t complete)
1524{ 1651{
1525 struct bfa_pport_s *port = cbarg; 1652 struct bfa_fcport_s *fcport = cbarg;
1526 1653
1527 if (complete) { 1654 if (complete) {
1528 port->stats_cbfn(port->stats_cbarg, port->stats_status); 1655 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
1529 } else { 1656 } else {
1530 port->stats_busy = BFA_FALSE; 1657 fcport->stats_busy = BFA_FALSE;
1531 port->stats_status = BFA_STATUS_OK; 1658 fcport->stats_status = BFA_STATUS_OK;
1659 }
1660}
1661
1662static void
1663__bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
1664{
1665 struct bfa_fcport_s *fcport = cbarg;
1666
1667 if (complete) {
1668 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
1669 } else {
1670 fcport->stats_busy = BFA_FALSE;
1671 fcport->stats_status = BFA_STATUS_OK;
1532 } 1672 }
1533} 1673}
1534 1674
1535static void 1675static void
1536bfa_port_stats_clr_timeout(void *cbarg) 1676bfa_port_stats_clr_timeout(void *cbarg)
1537{ 1677{
1538 struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg; 1678 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
1539 1679
1540 bfa_trc(port->bfa, port->stats_qfull); 1680 bfa_trc(fcport->bfa, fcport->stats_qfull);
1541 1681
1542 if (port->stats_qfull) { 1682 if (fcport->stats_qfull) {
1543 bfa_reqq_wcancel(&port->stats_reqq_wait); 1683 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
1544 port->stats_qfull = BFA_FALSE; 1684 fcport->stats_qfull = BFA_FALSE;
1545 } 1685 }
1546 1686
1547 port->stats_status = BFA_STATUS_ETIMER; 1687 fcport->stats_status = BFA_STATUS_ETIMER;
1548 bfa_cb_queue(port->bfa, &port->hcb_qe, __bfa_cb_port_stats_clr, port); 1688 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
1689 __bfa_cb_port_stats_clr, fcport);
1549} 1690}
1550 1691
1551static void 1692static void
1552bfa_pport_callback(struct bfa_pport_s *pport, enum bfa_pport_linkstate event) 1693bfa_fcport_callback(struct bfa_fcport_s *fcport, enum bfa_pport_linkstate event)
1553{ 1694{
1554 if (pport->bfa->fcs) { 1695 if (fcport->bfa->fcs) {
1555 pport->event_cbfn(pport->event_cbarg, event); 1696 fcport->event_cbfn(fcport->event_cbarg, event);
1556 return; 1697 return;
1557 } 1698 }
1558 1699
1559 switch (event) { 1700 switch (event) {
1560 case BFA_PPORT_LINKUP: 1701 case BFA_PPORT_LINKUP:
1561 bfa_sm_send_event(&pport->ln, BFA_PPORT_LN_SM_LINKUP); 1702 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKUP);
1562 break; 1703 break;
1563 case BFA_PPORT_LINKDOWN: 1704 case BFA_PPORT_LINKDOWN:
1564 bfa_sm_send_event(&pport->ln, BFA_PPORT_LN_SM_LINKDOWN); 1705 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN);
1565 break; 1706 break;
1566 default: 1707 default:
1567 bfa_assert(0); 1708 bfa_assert(0);
@@ -1569,41 +1710,92 @@ bfa_pport_callback(struct bfa_pport_s *pport, enum bfa_pport_linkstate event)
1569} 1710}
1570 1711
1571static void 1712static void
1572bfa_pport_queue_cb(struct bfa_pport_ln_s *ln, enum bfa_pport_linkstate event) 1713bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, enum bfa_pport_linkstate event)
1573{ 1714{
1574 ln->ln_event = event; 1715 ln->ln_event = event;
1575 bfa_cb_queue(ln->pport->bfa, &ln->ln_qe, __bfa_cb_port_event, ln); 1716 bfa_cb_queue(ln->fcport->bfa, &ln->ln_qe, __bfa_cb_fcport_event, ln);
1717}
1718
1719static void
1720bfa_fcport_stats_clr_timeout(void *cbarg)
1721{
1722 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
1723
1724 bfa_trc(fcport->bfa, fcport->stats_qfull);
1725
1726 if (fcport->stats_qfull) {
1727 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
1728 fcport->stats_qfull = BFA_FALSE;
1729 }
1730
1731 fcport->stats_status = BFA_STATUS_ETIMER;
1732 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_fcport_stats_clr,
1733 fcport);
1576} 1734}
1577 1735
1578static void 1736static void
1579__bfa_cb_port_stats(void *cbarg, bfa_boolean_t complete) 1737__bfa_cb_port_stats(void *cbarg, bfa_boolean_t complete)
1580{ 1738{
1581 struct bfa_pport_s *port = cbarg; 1739 struct bfa_fcport_s *fcport = cbarg;
1582 1740
1583 if (complete) { 1741 if (complete) {
1584 if (port->stats_status == BFA_STATUS_OK) 1742 if (fcport->stats_status == BFA_STATUS_OK)
1585 bfa_pport_stats_swap(port->stats_ret, port->stats); 1743 bfa_port_stats_swap(fcport->stats_ret, fcport->stats);
1586 port->stats_cbfn(port->stats_cbarg, port->stats_status); 1744 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
1587 } else { 1745 } else {
1588 port->stats_busy = BFA_FALSE; 1746 fcport->stats_busy = BFA_FALSE;
1589 port->stats_status = BFA_STATUS_OK; 1747 fcport->stats_status = BFA_STATUS_OK;
1590 } 1748 }
1591} 1749}
1592 1750
1593static void 1751static void
1594bfa_port_stats_timeout(void *cbarg) 1752bfa_port_stats_timeout(void *cbarg)
1595{ 1753{
1596 struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg; 1754 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
1597 1755
1598 bfa_trc(port->bfa, port->stats_qfull); 1756 bfa_trc(fcport->bfa, fcport->stats_qfull);
1599 1757
1600 if (port->stats_qfull) { 1758 if (fcport->stats_qfull) {
1601 bfa_reqq_wcancel(&port->stats_reqq_wait); 1759 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
1602 port->stats_qfull = BFA_FALSE; 1760 fcport->stats_qfull = BFA_FALSE;
1603 } 1761 }
1604 1762
1605 port->stats_status = BFA_STATUS_ETIMER; 1763 fcport->stats_status = BFA_STATUS_ETIMER;
1606 bfa_cb_queue(port->bfa, &port->hcb_qe, __bfa_cb_port_stats, port); 1764 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_port_stats, fcport);
1765}
1766
1767static void
1768__bfa_cb_fcport_stats(void *cbarg, bfa_boolean_t complete)
1769{
1770 struct bfa_fcport_s *fcport = cbarg;
1771
1772 if (complete) {
1773 if (fcport->stats_status == BFA_STATUS_OK) {
1774 bfa_fcport_stats_swap(fcport->fcport_stats_ret,
1775 fcport->fcport_stats);
1776 }
1777 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
1778 } else {
1779 fcport->stats_busy = BFA_FALSE;
1780 fcport->stats_status = BFA_STATUS_OK;
1781 }
1782}
1783
1784static void
1785bfa_fcport_stats_timeout(void *cbarg)
1786{
1787 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
1788
1789 bfa_trc(fcport->bfa, fcport->stats_qfull);
1790
1791 if (fcport->stats_qfull) {
1792 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
1793 fcport->stats_qfull = BFA_FALSE;
1794 }
1795
1796 fcport->stats_status = BFA_STATUS_ETIMER;
1797 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_fcport_stats,
1798 fcport);
1607} 1799}
1608 1800
1609#define BFA_PORT_STATS_TOV 1000 1801#define BFA_PORT_STATS_TOV 1000
@@ -1615,21 +1807,21 @@ bfa_status_t
1615bfa_pport_get_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats, 1807bfa_pport_get_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
1616 bfa_cb_pport_t cbfn, void *cbarg) 1808 bfa_cb_pport_t cbfn, void *cbarg)
1617{ 1809{
1618 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 1810 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1619 1811
1620 if (port->stats_busy) { 1812 if (fcport->stats_busy) {
1621 bfa_trc(bfa, port->stats_busy); 1813 bfa_trc(bfa, fcport->stats_busy);
1622 return BFA_STATUS_DEVBUSY; 1814 return BFA_STATUS_DEVBUSY;
1623 } 1815 }
1624 1816
1625 port->stats_busy = BFA_TRUE; 1817 fcport->stats_busy = BFA_TRUE;
1626 port->stats_ret = stats; 1818 fcport->stats_ret = stats;
1627 port->stats_cbfn = cbfn; 1819 fcport->stats_cbfn = cbfn;
1628 port->stats_cbarg = cbarg; 1820 fcport->stats_cbarg = cbarg;
1629 1821
1630 bfa_port_stats_query(port); 1822 bfa_port_stats_query(fcport);
1631 1823
1632 bfa_timer_start(bfa, &port->timer, bfa_port_stats_timeout, port, 1824 bfa_timer_start(bfa, &fcport->timer, bfa_port_stats_timeout, fcport,
1633 BFA_PORT_STATS_TOV); 1825 BFA_PORT_STATS_TOV);
1634 return BFA_STATUS_OK; 1826 return BFA_STATUS_OK;
1635} 1827}
@@ -1637,57 +1829,111 @@ bfa_pport_get_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
1637bfa_status_t 1829bfa_status_t
1638bfa_pport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg) 1830bfa_pport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
1639{ 1831{
1640 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 1832 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1833
1834 if (fcport->stats_busy) {
1835 bfa_trc(bfa, fcport->stats_busy);
1836 return BFA_STATUS_DEVBUSY;
1837 }
1838
1839 fcport->stats_busy = BFA_TRUE;
1840 fcport->stats_cbfn = cbfn;
1841 fcport->stats_cbarg = cbarg;
1842
1843 bfa_port_stats_clear(fcport);
1844
1845 bfa_timer_start(bfa, &fcport->timer, bfa_port_stats_clr_timeout,
1846 fcport, BFA_PORT_STATS_TOV);
1847 return BFA_STATUS_OK;
1848}
1849
1850/**
1851 * @brief
1852 * Fetch FCPort statistics.
1853 * Todo TBD: sharing timer,stats_busy and other resources of fcport for now -
1854 * ideally we want to create seperate ones for fcport once bfa_fcport_s is
1855 * decided.
1856 *
1857 */
1858bfa_status_t
1859bfa_fcport_get_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
1860 bfa_cb_pport_t cbfn, void *cbarg)
1861{
1862 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1641 1863
1642 if (port->stats_busy) { 1864 if (fcport->stats_busy) {
1643 bfa_trc(bfa, port->stats_busy); 1865 bfa_trc(bfa, fcport->stats_busy);
1644 return BFA_STATUS_DEVBUSY; 1866 return BFA_STATUS_DEVBUSY;
1645 } 1867 }
1646 1868
1647 port->stats_busy = BFA_TRUE; 1869 fcport->stats_busy = BFA_TRUE;
1648 port->stats_cbfn = cbfn; 1870 fcport->fcport_stats_ret = stats;
1649 port->stats_cbarg = cbarg; 1871 fcport->stats_cbfn = cbfn;
1872 fcport->stats_cbarg = cbarg;
1650 1873
1651 bfa_port_stats_clear(port); 1874 bfa_fcport_stats_query(fcport);
1652 1875
1653 bfa_timer_start(bfa, &port->timer, bfa_port_stats_clr_timeout, port, 1876 bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_timeout, fcport,
1654 BFA_PORT_STATS_TOV); 1877 BFA_PORT_STATS_TOV);
1878
1879 return BFA_STATUS_OK;
1880}
1881
1882bfa_status_t
1883bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
1884{
1885 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1886
1887 if (fcport->stats_busy) {
1888 bfa_trc(bfa, fcport->stats_busy);
1889 return BFA_STATUS_DEVBUSY;
1890 }
1891
1892 fcport->stats_busy = BFA_TRUE;
1893 fcport->stats_cbfn = cbfn;
1894 fcport->stats_cbarg = cbarg;
1895
1896 bfa_fcport_stats_clear(fcport);
1897
1898 bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_clr_timeout,
1899 fcport, BFA_PORT_STATS_TOV);
1900
1655 return BFA_STATUS_OK; 1901 return BFA_STATUS_OK;
1656} 1902}
1657 1903
1658bfa_status_t 1904bfa_status_t
1659bfa_pport_trunk_enable(struct bfa_s *bfa, u8 bitmap) 1905bfa_fcport_trunk_enable(struct bfa_s *bfa, u8 bitmap)
1660{ 1906{
1661 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1907 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1662 1908
1663 bfa_trc(bfa, bitmap); 1909 bfa_trc(bfa, bitmap);
1664 bfa_trc(bfa, pport->cfg.trunked); 1910 bfa_trc(bfa, fcport->cfg.trunked);
1665 bfa_trc(bfa, pport->cfg.trunk_ports); 1911 bfa_trc(bfa, fcport->cfg.trunk_ports);
1666 1912
1667 if (!bitmap || (bitmap & (bitmap - 1))) 1913 if (!bitmap || (bitmap & (bitmap - 1)))
1668 return BFA_STATUS_EINVAL; 1914 return BFA_STATUS_EINVAL;
1669 1915
1670 pport->cfg.trunked = BFA_TRUE; 1916 fcport->cfg.trunked = BFA_TRUE;
1671 pport->cfg.trunk_ports = bitmap; 1917 fcport->cfg.trunk_ports = bitmap;
1672 1918
1673 return BFA_STATUS_OK; 1919 return BFA_STATUS_OK;
1674} 1920}
1675 1921
1676void 1922void
1677bfa_pport_qos_get_attr(struct bfa_s *bfa, struct bfa_qos_attr_s *qos_attr) 1923bfa_fcport_qos_get_attr(struct bfa_s *bfa, struct bfa_qos_attr_s *qos_attr)
1678{ 1924{
1679 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1925 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1680 1926
1681 qos_attr->state = bfa_os_ntohl(pport->qos_attr.state); 1927 qos_attr->state = bfa_os_ntohl(fcport->qos_attr.state);
1682 qos_attr->total_bb_cr = bfa_os_ntohl(pport->qos_attr.total_bb_cr); 1928 qos_attr->total_bb_cr = bfa_os_ntohl(fcport->qos_attr.total_bb_cr);
1683} 1929}
1684 1930
1685void 1931void
1686bfa_pport_qos_get_vc_attr(struct bfa_s *bfa, 1932bfa_fcport_qos_get_vc_attr(struct bfa_s *bfa,
1687 struct bfa_qos_vc_attr_s *qos_vc_attr) 1933 struct bfa_qos_vc_attr_s *qos_vc_attr)
1688{ 1934{
1689 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 1935 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1690 struct bfa_qos_vc_attr_s *bfa_vc_attr = &pport->qos_vc_attr; 1936 struct bfa_qos_vc_attr_s *bfa_vc_attr = &fcport->qos_vc_attr;
1691 u32 i = 0; 1937 u32 i = 0;
1692 1938
1693 qos_vc_attr->total_vc_count = bfa_os_ntohs(bfa_vc_attr->total_vc_count); 1939 qos_vc_attr->total_vc_count = bfa_os_ntohs(bfa_vc_attr->total_vc_count);
@@ -1713,7 +1959,7 @@ bfa_pport_qos_get_vc_attr(struct bfa_s *bfa,
1713 * Fetch QoS Stats. 1959 * Fetch QoS Stats.
1714 */ 1960 */
1715bfa_status_t 1961bfa_status_t
1716bfa_pport_get_qos_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats, 1962bfa_fcport_get_qos_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
1717 bfa_cb_pport_t cbfn, void *cbarg) 1963 bfa_cb_pport_t cbfn, void *cbarg)
1718{ 1964{
1719 /* 1965 /*
@@ -1723,23 +1969,23 @@ bfa_pport_get_qos_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
1723} 1969}
1724 1970
1725bfa_status_t 1971bfa_status_t
1726bfa_pport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg) 1972bfa_fcport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
1727{ 1973{
1728 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 1974 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1729 1975
1730 if (port->stats_busy) { 1976 if (fcport->stats_busy) {
1731 bfa_trc(bfa, port->stats_busy); 1977 bfa_trc(bfa, fcport->stats_busy);
1732 return BFA_STATUS_DEVBUSY; 1978 return BFA_STATUS_DEVBUSY;
1733 } 1979 }
1734 1980
1735 port->stats_busy = BFA_TRUE; 1981 fcport->stats_busy = BFA_TRUE;
1736 port->stats_cbfn = cbfn; 1982 fcport->stats_cbfn = cbfn;
1737 port->stats_cbarg = cbarg; 1983 fcport->stats_cbarg = cbarg;
1738 1984
1739 bfa_port_qos_stats_clear(port); 1985 bfa_port_qos_stats_clear(fcport);
1740 1986
1741 bfa_timer_start(bfa, &port->timer, bfa_port_stats_clr_timeout, port, 1987 bfa_timer_start(bfa, &fcport->timer, bfa_port_stats_clr_timeout,
1742 BFA_PORT_STATS_TOV); 1988 fcport, BFA_PORT_STATS_TOV);
1743 return BFA_STATUS_OK; 1989 return BFA_STATUS_OK;
1744} 1990}
1745 1991
@@ -1747,82 +1993,82 @@ bfa_pport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
1747 * Fetch port attributes. 1993 * Fetch port attributes.
1748 */ 1994 */
1749bfa_status_t 1995bfa_status_t
1750bfa_pport_trunk_disable(struct bfa_s *bfa) 1996bfa_fcport_trunk_disable(struct bfa_s *bfa)
1751{ 1997{
1752 return BFA_STATUS_OK; 1998 return BFA_STATUS_OK;
1753} 1999}
1754 2000
1755bfa_boolean_t 2001bfa_boolean_t
1756bfa_pport_trunk_query(struct bfa_s *bfa, u32 *bitmap) 2002bfa_fcport_trunk_query(struct bfa_s *bfa, u32 *bitmap)
1757{ 2003{
1758 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 2004 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1759 2005
1760 *bitmap = port->cfg.trunk_ports; 2006 *bitmap = fcport->cfg.trunk_ports;
1761 return port->cfg.trunked; 2007 return fcport->cfg.trunked;
1762} 2008}
1763 2009
1764bfa_boolean_t 2010bfa_boolean_t
1765bfa_pport_is_disabled(struct bfa_s *bfa) 2011bfa_fcport_is_disabled(struct bfa_s *bfa)
1766{ 2012{
1767 struct bfa_pport_s *port = BFA_PORT_MOD(bfa); 2013 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1768 2014
1769 return bfa_sm_to_state(hal_pport_sm_table, port->sm) == 2015 return bfa_sm_to_state(hal_pport_sm_table, fcport->sm) ==
1770 BFA_PPORT_ST_DISABLED; 2016 BFA_PPORT_ST_DISABLED;
1771 2017
1772} 2018}
1773 2019
1774bfa_boolean_t 2020bfa_boolean_t
1775bfa_pport_is_ratelim(struct bfa_s *bfa) 2021bfa_fcport_is_ratelim(struct bfa_s *bfa)
1776{ 2022{
1777 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 2023 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1778 2024
1779 return pport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE; 2025 return fcport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE;
1780 2026
1781} 2027}
1782 2028
1783void 2029void
1784bfa_pport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off) 2030bfa_fcport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off)
1785{ 2031{
1786 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 2032 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1787 2033
1788 bfa_trc(bfa, on_off); 2034 bfa_trc(bfa, on_off);
1789 bfa_trc(bfa, pport->cfg.qos_enabled); 2035 bfa_trc(bfa, fcport->cfg.qos_enabled);
1790 2036
1791 pport->cfg.qos_enabled = on_off; 2037 fcport->cfg.qos_enabled = on_off;
1792} 2038}
1793 2039
1794void 2040void
1795bfa_pport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off) 2041bfa_fcport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off)
1796{ 2042{
1797 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 2043 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1798 2044
1799 bfa_trc(bfa, on_off); 2045 bfa_trc(bfa, on_off);
1800 bfa_trc(bfa, pport->cfg.ratelimit); 2046 bfa_trc(bfa, fcport->cfg.ratelimit);
1801 2047
1802 pport->cfg.ratelimit = on_off; 2048 fcport->cfg.ratelimit = on_off;
1803 if (pport->cfg.trl_def_speed == BFA_PPORT_SPEED_UNKNOWN) 2049 if (fcport->cfg.trl_def_speed == BFA_PPORT_SPEED_UNKNOWN)
1804 pport->cfg.trl_def_speed = BFA_PPORT_SPEED_1GBPS; 2050 fcport->cfg.trl_def_speed = BFA_PPORT_SPEED_1GBPS;
1805} 2051}
1806 2052
1807/** 2053/**
1808 * Configure default minimum ratelim speed 2054 * Configure default minimum ratelim speed
1809 */ 2055 */
1810bfa_status_t 2056bfa_status_t
1811bfa_pport_cfg_ratelim_speed(struct bfa_s *bfa, enum bfa_pport_speed speed) 2057bfa_fcport_cfg_ratelim_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
1812{ 2058{
1813 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 2059 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1814 2060
1815 bfa_trc(bfa, speed); 2061 bfa_trc(bfa, speed);
1816 2062
1817 /* 2063 /*
1818 * Auto and speeds greater than the supported speed, are invalid 2064 * Auto and speeds greater than the supported speed, are invalid
1819 */ 2065 */
1820 if ((speed == BFA_PPORT_SPEED_AUTO) || (speed > pport->speed_sup)) { 2066 if ((speed == BFA_PPORT_SPEED_AUTO) || (speed > fcport->speed_sup)) {
1821 bfa_trc(bfa, pport->speed_sup); 2067 bfa_trc(bfa, fcport->speed_sup);
1822 return BFA_STATUS_UNSUPP_SPEED; 2068 return BFA_STATUS_UNSUPP_SPEED;
1823 } 2069 }
1824 2070
1825 pport->cfg.trl_def_speed = speed; 2071 fcport->cfg.trl_def_speed = speed;
1826 2072
1827 return BFA_STATUS_OK; 2073 return BFA_STATUS_OK;
1828} 2074}
@@ -1831,45 +2077,45 @@ bfa_pport_cfg_ratelim_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
1831 * Get default minimum ratelim speed 2077 * Get default minimum ratelim speed
1832 */ 2078 */
1833enum bfa_pport_speed 2079enum bfa_pport_speed
1834bfa_pport_get_ratelim_speed(struct bfa_s *bfa) 2080bfa_fcport_get_ratelim_speed(struct bfa_s *bfa)
1835{ 2081{
1836 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 2082 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1837 2083
1838 bfa_trc(bfa, pport->cfg.trl_def_speed); 2084 bfa_trc(bfa, fcport->cfg.trl_def_speed);
1839 return pport->cfg.trl_def_speed; 2085 return fcport->cfg.trl_def_speed;
1840 2086
1841} 2087}
1842 2088
1843void 2089void
1844bfa_pport_busy(struct bfa_s *bfa, bfa_boolean_t status) 2090bfa_fcport_busy(struct bfa_s *bfa, bfa_boolean_t status)
1845{ 2091{
1846 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 2092 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1847 2093
1848 bfa_trc(bfa, status); 2094 bfa_trc(bfa, status);
1849 bfa_trc(bfa, pport->diag_busy); 2095 bfa_trc(bfa, fcport->diag_busy);
1850 2096
1851 pport->diag_busy = status; 2097 fcport->diag_busy = status;
1852} 2098}
1853 2099
1854void 2100void
1855bfa_pport_beacon(struct bfa_s *bfa, bfa_boolean_t beacon, 2101bfa_fcport_beacon(struct bfa_s *bfa, bfa_boolean_t beacon,
1856 bfa_boolean_t link_e2e_beacon) 2102 bfa_boolean_t link_e2e_beacon)
1857{ 2103{
1858 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa); 2104 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1859 2105
1860 bfa_trc(bfa, beacon); 2106 bfa_trc(bfa, beacon);
1861 bfa_trc(bfa, link_e2e_beacon); 2107 bfa_trc(bfa, link_e2e_beacon);
1862 bfa_trc(bfa, pport->beacon); 2108 bfa_trc(bfa, fcport->beacon);
1863 bfa_trc(bfa, pport->link_e2e_beacon); 2109 bfa_trc(bfa, fcport->link_e2e_beacon);
1864 2110
1865 pport->beacon = beacon; 2111 fcport->beacon = beacon;
1866 pport->link_e2e_beacon = link_e2e_beacon; 2112 fcport->link_e2e_beacon = link_e2e_beacon;
1867} 2113}
1868 2114
1869bfa_boolean_t 2115bfa_boolean_t
1870bfa_pport_is_linkup(struct bfa_s *bfa) 2116bfa_fcport_is_linkup(struct bfa_s *bfa)
1871{ 2117{
1872 return bfa_sm_cmp_state(BFA_PORT_MOD(bfa), bfa_pport_sm_linkup); 2118 return bfa_sm_cmp_state(BFA_FCPORT_MOD(bfa), bfa_fcport_sm_linkup);
1873} 2119}
1874 2120
1875 2121
diff --git a/drivers/scsi/bfa/bfa_fcs_port.c b/drivers/scsi/bfa/bfa_fcs_port.c
index 53808d0418a1..3c27788cd527 100644
--- a/drivers/scsi/bfa/bfa_fcs_port.c
+++ b/drivers/scsi/bfa/bfa_fcs_port.c
@@ -57,5 +57,5 @@ bfa_fcs_pport_event_handler(void *cbarg, bfa_pport_event_t event)
57void 57void
58bfa_fcs_pport_attach(struct bfa_fcs_s *fcs) 58bfa_fcs_pport_attach(struct bfa_fcs_s *fcs)
59{ 59{
60 bfa_pport_event_register(fcs->bfa, bfa_fcs_pport_event_handler, fcs); 60 bfa_fcport_event_register(fcs->bfa, bfa_fcs_pport_event_handler, fcs);
61} 61}
diff --git a/drivers/scsi/bfa/bfa_module.c b/drivers/scsi/bfa/bfa_module.c
index 32eda8e1ec65..a7fcc80c177e 100644
--- a/drivers/scsi/bfa/bfa_module.c
+++ b/drivers/scsi/bfa/bfa_module.c
@@ -24,7 +24,7 @@
24 */ 24 */
25struct bfa_module_s *hal_mods[] = { 25struct bfa_module_s *hal_mods[] = {
26 &hal_mod_sgpg, 26 &hal_mod_sgpg,
27 &hal_mod_pport, 27 &hal_mod_fcport,
28 &hal_mod_fcxp, 28 &hal_mod_fcxp,
29 &hal_mod_lps, 29 &hal_mod_lps,
30 &hal_mod_uf, 30 &hal_mod_uf,
@@ -45,7 +45,7 @@ bfa_isr_func_t bfa_isrs[BFI_MC_MAX] = {
45 bfa_isr_unhandled, /* BFI_MC_DIAG */ 45 bfa_isr_unhandled, /* BFI_MC_DIAG */
46 bfa_isr_unhandled, /* BFI_MC_FLASH */ 46 bfa_isr_unhandled, /* BFI_MC_FLASH */
47 bfa_isr_unhandled, /* BFI_MC_CEE */ 47 bfa_isr_unhandled, /* BFI_MC_CEE */
48 bfa_pport_isr, /* BFI_MC_PORT */ 48 bfa_fcport_isr, /* BFI_MC_FCPORT */
49 bfa_isr_unhandled, /* BFI_MC_IOCFC */ 49 bfa_isr_unhandled, /* BFI_MC_IOCFC */
50 bfa_isr_unhandled, /* BFI_MC_LL */ 50 bfa_isr_unhandled, /* BFI_MC_LL */
51 bfa_uf_isr, /* BFI_MC_UF */ 51 bfa_uf_isr, /* BFI_MC_UF */
diff --git a/drivers/scsi/bfa/bfa_modules_priv.h b/drivers/scsi/bfa/bfa_modules_priv.h
index 96f70534593c..f554c2fad6a9 100644
--- a/drivers/scsi/bfa/bfa_modules_priv.h
+++ b/drivers/scsi/bfa/bfa_modules_priv.h
@@ -29,7 +29,7 @@
29 29
30 30
31struct bfa_modules_s { 31struct bfa_modules_s {
32 struct bfa_pport_s pport; /* physical port module */ 32 struct bfa_fcport_s fcport; /* fc port module */
33 struct bfa_fcxp_mod_s fcxp_mod; /* fcxp module */ 33 struct bfa_fcxp_mod_s fcxp_mod; /* fcxp module */
34 struct bfa_lps_mod_s lps_mod; /* fcxp module */ 34 struct bfa_lps_mod_s lps_mod; /* fcxp module */
35 struct bfa_uf_mod_s uf_mod; /* unsolicited frame module */ 35 struct bfa_uf_mod_s uf_mod; /* unsolicited frame module */
diff --git a/drivers/scsi/bfa/bfa_port_priv.h b/drivers/scsi/bfa/bfa_port_priv.h
index f29701bd2369..6d315ffb1e99 100644
--- a/drivers/scsi/bfa/bfa_port_priv.h
+++ b/drivers/scsi/bfa/bfa_port_priv.h
@@ -25,17 +25,17 @@
25/** 25/**
26 * Link notification data structure 26 * Link notification data structure
27 */ 27 */
28struct bfa_pport_ln_s { 28struct bfa_fcport_ln_s {
29 struct bfa_pport_s *pport; 29 struct bfa_fcport_s *fcport;
30 bfa_sm_t sm; 30 bfa_sm_t sm;
31 struct bfa_cb_qe_s ln_qe; /* BFA callback queue elem for ln */ 31 struct bfa_cb_qe_s ln_qe; /* BFA callback queue elem for ln */
32 enum bfa_pport_linkstate ln_event; /* ln event for callback */ 32 enum bfa_pport_linkstate ln_event; /* ln event for callback */
33}; 33};
34 34
35/** 35/**
36 * BFA physical port data structure 36 * BFA FC port data structure
37 */ 37 */
38struct bfa_pport_s { 38struct bfa_fcport_s {
39 struct bfa_s *bfa; /* parent BFA instance */ 39 struct bfa_s *bfa; /* parent BFA instance */
40 bfa_sm_t sm; /* port state machine */ 40 bfa_sm_t sm; /* port state machine */
41 wwn_t nwwn; /* node wwn of physical port */ 41 wwn_t nwwn; /* node wwn of physical port */
@@ -62,7 +62,7 @@ struct bfa_pport_s {
62 union bfi_pport_i2h_msg_u i2hmsg; 62 union bfi_pport_i2h_msg_u i2hmsg;
63 } event_arg; 63 } event_arg;
64 void *bfad; /* BFA driver handle */ 64 void *bfad; /* BFA driver handle */
65 struct bfa_pport_ln_s ln; /* Link Notification */ 65 struct bfa_fcport_ln_s ln; /* Link Notification */
66 struct bfa_cb_qe_s hcb_qe; /* BFA callback queue elem */ 66 struct bfa_cb_qe_s hcb_qe; /* BFA callback queue elem */
67 u32 msgtag; /* fimrware msg tag for reply */ 67 u32 msgtag; /* fimrware msg tag for reply */
68 u8 *stats_kva; 68 u8 *stats_kva;
@@ -88,12 +88,17 @@ struct bfa_pport_s {
88 /* driver callback function */ 88 /* driver callback function */
89 void *stats_cbarg; 89 void *stats_cbarg;
90 /* *!< user callback arg */ 90 /* *!< user callback arg */
91 /* FCport stats */
92 u8 *fcport_stats_kva;
93 u64 fcport_stats_pa;
94 union bfa_fcport_stats_u *fcport_stats;
95 union bfa_fcport_stats_u *fcport_stats_ret;
91}; 96};
92 97
93#define BFA_PORT_MOD(__bfa) (&(__bfa)->modules.pport) 98#define BFA_FCPORT_MOD(__bfa) (&(__bfa)->modules.fcport)
94 99
95/* 100/*
96 * public functions 101 * public functions
97 */ 102 */
98void bfa_pport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg); 103void bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg);
99#endif /* __BFA_PORT_PRIV_H__ */ 104#endif /* __BFA_PORT_PRIV_H__ */
diff --git a/drivers/scsi/bfa/bfa_priv.h b/drivers/scsi/bfa/bfa_priv.h
index 0747a6b26f7b..be80fc7e1b0e 100644
--- a/drivers/scsi/bfa/bfa_priv.h
+++ b/drivers/scsi/bfa/bfa_priv.h
@@ -101,7 +101,7 @@ extern bfa_boolean_t bfa_auto_recover;
101extern struct bfa_module_s hal_mod_flash; 101extern struct bfa_module_s hal_mod_flash;
102extern struct bfa_module_s hal_mod_fcdiag; 102extern struct bfa_module_s hal_mod_fcdiag;
103extern struct bfa_module_s hal_mod_sgpg; 103extern struct bfa_module_s hal_mod_sgpg;
104extern struct bfa_module_s hal_mod_pport; 104extern struct bfa_module_s hal_mod_fcport;
105extern struct bfa_module_s hal_mod_fcxp; 105extern struct bfa_module_s hal_mod_fcxp;
106extern struct bfa_module_s hal_mod_lps; 106extern struct bfa_module_s hal_mod_lps;
107extern struct bfa_module_s hal_mod_uf; 107extern struct bfa_module_s hal_mod_uf;
diff --git a/drivers/scsi/bfa/bfa_trcmod_priv.h b/drivers/scsi/bfa/bfa_trcmod_priv.h
index 3d947d47b837..a7a82610db85 100644
--- a/drivers/scsi/bfa/bfa_trcmod_priv.h
+++ b/drivers/scsi/bfa/bfa_trcmod_priv.h
@@ -37,7 +37,7 @@ enum {
37 BFA_TRC_HAL_IOIM = 6, 37 BFA_TRC_HAL_IOIM = 6,
38 BFA_TRC_HAL_TSKIM = 7, 38 BFA_TRC_HAL_TSKIM = 7,
39 BFA_TRC_HAL_ITNIM = 8, 39 BFA_TRC_HAL_ITNIM = 8,
40 BFA_TRC_HAL_PPORT = 9, 40 BFA_TRC_HAL_FCPORT = 9,
41 BFA_TRC_HAL_SGPG = 10, 41 BFA_TRC_HAL_SGPG = 10,
42 BFA_TRC_HAL_FLASH = 11, 42 BFA_TRC_HAL_FLASH = 11,
43 BFA_TRC_HAL_DEBUG = 12, 43 BFA_TRC_HAL_DEBUG = 12,
diff --git a/drivers/scsi/bfa/bfad.c b/drivers/scsi/bfa/bfad.c
index 79956c152af9..a8a529d5fea4 100644
--- a/drivers/scsi/bfa/bfad.c
+++ b/drivers/scsi/bfa/bfad.c
@@ -664,7 +664,7 @@ bfad_fcs_port_cfg(struct bfad_s *bfad)
664 664
665 sprintf(symname, "%s-%d", BFAD_DRIVER_NAME, bfad->inst_no); 665 sprintf(symname, "%s-%d", BFAD_DRIVER_NAME, bfad->inst_no);
666 memcpy(port_cfg.sym_name.symname, symname, strlen(symname)); 666 memcpy(port_cfg.sym_name.symname, symname, strlen(symname));
667 bfa_pport_get_attr(&bfad->bfa, &attr); 667 bfa_fcport_get_attr(&bfad->bfa, &attr);
668 port_cfg.nwwn = attr.nwwn; 668 port_cfg.nwwn = attr.nwwn;
669 port_cfg.pwwn = attr.pwwn; 669 port_cfg.pwwn = attr.pwwn;
670 670
diff --git a/drivers/scsi/bfa/bfad_attr.c b/drivers/scsi/bfa/bfad_attr.c
index adf801dbfa15..a691133c31a2 100644
--- a/drivers/scsi/bfa/bfad_attr.c
+++ b/drivers/scsi/bfa/bfad_attr.c
@@ -141,7 +141,7 @@ bfad_im_get_host_port_type(struct Scsi_Host *shost)
141 struct bfad_s *bfad = im_port->bfad; 141 struct bfad_s *bfad = im_port->bfad;
142 struct bfa_pport_attr_s attr; 142 struct bfa_pport_attr_s attr;
143 143
144 bfa_pport_get_attr(&bfad->bfa, &attr); 144 bfa_fcport_get_attr(&bfad->bfa, &attr);
145 145
146 switch (attr.port_type) { 146 switch (attr.port_type) {
147 case BFA_PPORT_TYPE_NPORT: 147 case BFA_PPORT_TYPE_NPORT:
@@ -173,7 +173,7 @@ bfad_im_get_host_port_state(struct Scsi_Host *shost)
173 struct bfad_s *bfad = im_port->bfad; 173 struct bfad_s *bfad = im_port->bfad;
174 struct bfa_pport_attr_s attr; 174 struct bfa_pport_attr_s attr;
175 175
176 bfa_pport_get_attr(&bfad->bfa, &attr); 176 bfa_fcport_get_attr(&bfad->bfa, &attr);
177 177
178 switch (attr.port_state) { 178 switch (attr.port_state) {
179 case BFA_PPORT_ST_LINKDOWN: 179 case BFA_PPORT_ST_LINKDOWN:
@@ -232,7 +232,7 @@ bfad_im_get_host_speed(struct Scsi_Host *shost)
232 unsigned long flags; 232 unsigned long flags;
233 233
234 spin_lock_irqsave(shost->host_lock, flags); 234 spin_lock_irqsave(shost->host_lock, flags);
235 bfa_pport_get_attr(&bfad->bfa, &attr); 235 bfa_fcport_get_attr(&bfad->bfa, &attr);
236 switch (attr.speed) { 236 switch (attr.speed) {
237 case BFA_PPORT_SPEED_8GBPS: 237 case BFA_PPORT_SPEED_8GBPS:
238 fc_host_speed(shost) = FC_PORTSPEED_8GBIT; 238 fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
diff --git a/drivers/scsi/bfa/bfad_im.c b/drivers/scsi/bfa/bfad_im.c
index f788c2a0ab07..23390b40b9c3 100644
--- a/drivers/scsi/bfa/bfad_im.c
+++ b/drivers/scsi/bfa/bfad_im.c
@@ -966,7 +966,7 @@ bfad_os_fc_host_init(struct bfad_im_port_s *im_port)
966 FC_PORTSPEED_1GBIT; 966 FC_PORTSPEED_1GBIT;
967 967
968 memset(&attr.pattr, 0, sizeof(attr.pattr)); 968 memset(&attr.pattr, 0, sizeof(attr.pattr));
969 bfa_pport_get_attr(&bfad->bfa, &attr.pattr); 969 bfa_fcport_get_attr(&bfad->bfa, &attr.pattr);
970 fc_host_maxframe_size(host) = attr.pattr.pport_cfg.maxfrsize; 970 fc_host_maxframe_size(host) = attr.pattr.pport_cfg.maxfrsize;
971} 971}
972 972
diff --git a/drivers/scsi/bfa/fabric.c b/drivers/scsi/bfa/fabric.c
index b02ed7653eb6..e1a4b312e9d4 100644
--- a/drivers/scsi/bfa/fabric.c
+++ b/drivers/scsi/bfa/fabric.c
@@ -37,7 +37,7 @@ BFA_TRC_FILE(FCS, FABRIC);
37#define BFA_FCS_FABRIC_CLEANUP_DELAY (10000) /* Milliseconds */ 37#define BFA_FCS_FABRIC_CLEANUP_DELAY (10000) /* Milliseconds */
38 38
39#define bfa_fcs_fabric_set_opertype(__fabric) do { \ 39#define bfa_fcs_fabric_set_opertype(__fabric) do { \
40 if (bfa_pport_get_topology((__fabric)->fcs->bfa) \ 40 if (bfa_fcport_get_topology((__fabric)->fcs->bfa) \
41 == BFA_PPORT_TOPOLOGY_P2P) \ 41 == BFA_PPORT_TOPOLOGY_P2P) \
42 (__fabric)->oper_type = BFA_PPORT_TYPE_NPORT; \ 42 (__fabric)->oper_type = BFA_PPORT_TYPE_NPORT; \
43 else \ 43 else \
@@ -160,7 +160,7 @@ bfa_fcs_fabric_sm_created(struct bfa_fcs_fabric_s *fabric,
160 160
161 switch (event) { 161 switch (event) {
162 case BFA_FCS_FABRIC_SM_START: 162 case BFA_FCS_FABRIC_SM_START:
163 if (bfa_pport_is_linkup(fabric->fcs->bfa)) { 163 if (bfa_fcport_is_linkup(fabric->fcs->bfa)) {
164 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_flogi); 164 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_flogi);
165 bfa_fcs_fabric_login(fabric); 165 bfa_fcs_fabric_login(fabric);
166 } else 166 } else
@@ -224,7 +224,7 @@ bfa_fcs_fabric_sm_flogi(struct bfa_fcs_fabric_s *fabric,
224 switch (event) { 224 switch (event) {
225 case BFA_FCS_FABRIC_SM_CONT_OP: 225 case BFA_FCS_FABRIC_SM_CONT_OP:
226 226
227 bfa_pport_set_tx_bbcredit(fabric->fcs->bfa, fabric->bb_credit); 227 bfa_fcport_set_tx_bbcredit(fabric->fcs->bfa, fabric->bb_credit);
228 fabric->fab_type = BFA_FCS_FABRIC_SWITCHED; 228 fabric->fab_type = BFA_FCS_FABRIC_SWITCHED;
229 229
230 if (fabric->auth_reqd && fabric->is_auth) { 230 if (fabric->auth_reqd && fabric->is_auth) {
@@ -251,7 +251,7 @@ bfa_fcs_fabric_sm_flogi(struct bfa_fcs_fabric_s *fabric,
251 251
252 case BFA_FCS_FABRIC_SM_NO_FABRIC: 252 case BFA_FCS_FABRIC_SM_NO_FABRIC:
253 fabric->fab_type = BFA_FCS_FABRIC_N2N; 253 fabric->fab_type = BFA_FCS_FABRIC_N2N;
254 bfa_pport_set_tx_bbcredit(fabric->fcs->bfa, fabric->bb_credit); 254 bfa_fcport_set_tx_bbcredit(fabric->fcs->bfa, fabric->bb_credit);
255 bfa_fcs_fabric_notify_online(fabric); 255 bfa_fcs_fabric_notify_online(fabric);
256 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_nofabric); 256 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_nofabric);
257 break; 257 break;
@@ -418,7 +418,7 @@ bfa_fcs_fabric_sm_nofabric(struct bfa_fcs_fabric_s *fabric,
418 418
419 case BFA_FCS_FABRIC_SM_NO_FABRIC: 419 case BFA_FCS_FABRIC_SM_NO_FABRIC:
420 bfa_trc(fabric->fcs, fabric->bb_credit); 420 bfa_trc(fabric->fcs, fabric->bb_credit);
421 bfa_pport_set_tx_bbcredit(fabric->fcs->bfa, fabric->bb_credit); 421 bfa_fcport_set_tx_bbcredit(fabric->fcs->bfa, fabric->bb_credit);
422 break; 422 break;
423 423
424 default: 424 default:
@@ -718,10 +718,10 @@ bfa_fcs_fabric_login(struct bfa_fcs_fabric_s *fabric)
718 struct bfa_port_cfg_s *pcfg = &fabric->bport.port_cfg; 718 struct bfa_port_cfg_s *pcfg = &fabric->bport.port_cfg;
719 u8 alpa = 0; 719 u8 alpa = 0;
720 720
721 if (bfa_pport_get_topology(bfa) == BFA_PPORT_TOPOLOGY_LOOP) 721 if (bfa_fcport_get_topology(bfa) == BFA_PPORT_TOPOLOGY_LOOP)
722 alpa = bfa_pport_get_myalpa(bfa); 722 alpa = bfa_fcport_get_myalpa(bfa);
723 723
724 bfa_lps_flogi(fabric->lps, fabric, alpa, bfa_pport_get_maxfrsize(bfa), 724 bfa_lps_flogi(fabric->lps, fabric, alpa, bfa_fcport_get_maxfrsize(bfa),
725 pcfg->pwwn, pcfg->nwwn, fabric->auth_reqd); 725 pcfg->pwwn, pcfg->nwwn, fabric->auth_reqd);
726 726
727 fabric->stats.flogi_sent++; 727 fabric->stats.flogi_sent++;
@@ -1176,8 +1176,8 @@ bfa_fcs_fabric_send_flogi_acc(struct bfa_fcs_fabric_s *fabric)
1176 reqlen = fc_flogi_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 1176 reqlen = fc_flogi_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
1177 bfa_os_hton3b(FC_FABRIC_PORT), 1177 bfa_os_hton3b(FC_FABRIC_PORT),
1178 n2n_port->reply_oxid, pcfg->pwwn, 1178 n2n_port->reply_oxid, pcfg->pwwn,
1179 pcfg->nwwn, bfa_pport_get_maxfrsize(bfa), 1179 pcfg->nwwn, bfa_fcport_get_maxfrsize(bfa),
1180 bfa_pport_get_rx_bbcredit(bfa)); 1180 bfa_fcport_get_rx_bbcredit(bfa));
1181 1181
1182 bfa_fcxp_send(fcxp, NULL, fabric->vf_id, bfa_lps_get_tag(fabric->lps), 1182 bfa_fcxp_send(fcxp, NULL, fabric->vf_id, bfa_lps_get_tag(fabric->lps),
1183 BFA_FALSE, FC_CLASS_3, reqlen, &fchs, 1183 BFA_FALSE, FC_CLASS_3, reqlen, &fchs,
diff --git a/drivers/scsi/bfa/fdmi.c b/drivers/scsi/bfa/fdmi.c
index e8120868701b..2c9e7132a368 100644
--- a/drivers/scsi/bfa/fdmi.c
+++ b/drivers/scsi/bfa/fdmi.c
@@ -1175,7 +1175,7 @@ bfa_fcs_fdmi_get_portattr(struct bfa_fcs_port_fdmi_s *fdmi,
1175 /* 1175 /*
1176 * get pport attributes from hal 1176 * get pport attributes from hal
1177 */ 1177 */
1178 bfa_pport_get_attr(port->fcs->bfa, &pport_attr); 1178 bfa_fcport_get_attr(port->fcs->bfa, &pport_attr);
1179 1179
1180 /* 1180 /*
1181 * get FC4 type Bitmask 1181 * get FC4 type Bitmask
diff --git a/drivers/scsi/bfa/include/bfa_svc.h b/drivers/scsi/bfa/include/bfa_svc.h
index 71ffb75a71ca..f2c30858900b 100644
--- a/drivers/scsi/bfa/include/bfa_svc.h
+++ b/drivers/scsi/bfa/include/bfa_svc.h
@@ -26,6 +26,7 @@ struct bfa_fcxp_s;
26#include <defs/bfa_defs_pport.h> 26#include <defs/bfa_defs_pport.h>
27#include <defs/bfa_defs_rport.h> 27#include <defs/bfa_defs_rport.h>
28#include <defs/bfa_defs_qos.h> 28#include <defs/bfa_defs_qos.h>
29#include <defs/bfa_defs_fcport.h>
29#include <cs/bfa_sm.h> 30#include <cs/bfa_sm.h>
30#include <bfa.h> 31#include <bfa.h>
31 32
@@ -151,60 +152,67 @@ struct bfa_lps_s {
151 bfa_eproto_status_t ext_status; 152 bfa_eproto_status_t ext_status;
152}; 153};
153 154
155#define BFA_FCPORT(_bfa) (&((_bfa)->modules.port))
156
154/* 157/*
155 * bfa pport API functions 158 * bfa pport API functions
156 */ 159 */
157bfa_status_t bfa_pport_enable(struct bfa_s *bfa); 160bfa_status_t bfa_fcport_enable(struct bfa_s *bfa);
158bfa_status_t bfa_pport_disable(struct bfa_s *bfa); 161bfa_status_t bfa_fcport_disable(struct bfa_s *bfa);
159bfa_status_t bfa_pport_cfg_speed(struct bfa_s *bfa, 162bfa_status_t bfa_fcport_cfg_speed(struct bfa_s *bfa,
160 enum bfa_pport_speed speed); 163 enum bfa_pport_speed speed);
161enum bfa_pport_speed bfa_pport_get_speed(struct bfa_s *bfa); 164enum bfa_pport_speed bfa_fcport_get_speed(struct bfa_s *bfa);
162bfa_status_t bfa_pport_cfg_topology(struct bfa_s *bfa, 165bfa_status_t bfa_fcport_cfg_topology(struct bfa_s *bfa,
163 enum bfa_pport_topology topo); 166 enum bfa_pport_topology topo);
164enum bfa_pport_topology bfa_pport_get_topology(struct bfa_s *bfa); 167enum bfa_pport_topology bfa_fcport_get_topology(struct bfa_s *bfa);
165bfa_status_t bfa_pport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa); 168bfa_status_t bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa);
166bfa_boolean_t bfa_pport_get_hardalpa(struct bfa_s *bfa, u8 *alpa); 169bfa_boolean_t bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa);
167u8 bfa_pport_get_myalpa(struct bfa_s *bfa); 170u8 bfa_fcport_get_myalpa(struct bfa_s *bfa);
168bfa_status_t bfa_pport_clr_hardalpa(struct bfa_s *bfa); 171bfa_status_t bfa_fcport_clr_hardalpa(struct bfa_s *bfa);
169bfa_status_t bfa_pport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxsize); 172bfa_status_t bfa_fcport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxsize);
170u16 bfa_pport_get_maxfrsize(struct bfa_s *bfa); 173u16 bfa_fcport_get_maxfrsize(struct bfa_s *bfa);
171u32 bfa_pport_mypid(struct bfa_s *bfa); 174u32 bfa_fcport_mypid(struct bfa_s *bfa);
172u8 bfa_pport_get_rx_bbcredit(struct bfa_s *bfa); 175u8 bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa);
173bfa_status_t bfa_pport_trunk_enable(struct bfa_s *bfa, u8 bitmap); 176bfa_status_t bfa_fcport_trunk_enable(struct bfa_s *bfa, u8 bitmap);
174bfa_status_t bfa_pport_trunk_disable(struct bfa_s *bfa); 177bfa_status_t bfa_fcport_trunk_disable(struct bfa_s *bfa);
175bfa_boolean_t bfa_pport_trunk_query(struct bfa_s *bfa, u32 *bitmap); 178bfa_boolean_t bfa_fcport_trunk_query(struct bfa_s *bfa, u32 *bitmap);
176void bfa_pport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr); 179void bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr);
177wwn_t bfa_pport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node); 180wwn_t bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node);
178bfa_status_t bfa_pport_get_stats(struct bfa_s *bfa, 181bfa_status_t bfa_pport_get_stats(struct bfa_s *bfa,
179 union bfa_pport_stats_u *stats, 182 union bfa_pport_stats_u *stats,
180 bfa_cb_pport_t cbfn, void *cbarg); 183 bfa_cb_pport_t cbfn, void *cbarg);
181bfa_status_t bfa_pport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, 184bfa_status_t bfa_pport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn,
182 void *cbarg); 185 void *cbarg);
183void bfa_pport_event_register(struct bfa_s *bfa, 186void bfa_fcport_event_register(struct bfa_s *bfa,
184 void (*event_cbfn) (void *cbarg, 187 void (*event_cbfn) (void *cbarg,
185 bfa_pport_event_t event), void *event_cbarg); 188 bfa_pport_event_t event), void *event_cbarg);
186bfa_boolean_t bfa_pport_is_disabled(struct bfa_s *bfa); 189bfa_boolean_t bfa_fcport_is_disabled(struct bfa_s *bfa);
187void bfa_pport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off); 190void bfa_fcport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off);
188void bfa_pport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off); 191void bfa_fcport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off);
189bfa_status_t bfa_pport_cfg_ratelim_speed(struct bfa_s *bfa, 192bfa_status_t bfa_fcport_cfg_ratelim_speed(struct bfa_s *bfa,
190 enum bfa_pport_speed speed); 193 enum bfa_pport_speed speed);
191enum bfa_pport_speed bfa_pport_get_ratelim_speed(struct bfa_s *bfa); 194enum bfa_pport_speed bfa_fcport_get_ratelim_speed(struct bfa_s *bfa);
192 195
193void bfa_pport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit); 196void bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit);
194void bfa_pport_busy(struct bfa_s *bfa, bfa_boolean_t status); 197void bfa_fcport_busy(struct bfa_s *bfa, bfa_boolean_t status);
195void bfa_pport_beacon(struct bfa_s *bfa, bfa_boolean_t beacon, 198void bfa_fcport_beacon(struct bfa_s *bfa, bfa_boolean_t beacon,
196 bfa_boolean_t link_e2e_beacon); 199 bfa_boolean_t link_e2e_beacon);
197void bfa_cb_pport_event(void *cbarg, bfa_pport_event_t event); 200void bfa_cb_pport_event(void *cbarg, bfa_pport_event_t event);
198void bfa_pport_qos_get_attr(struct bfa_s *bfa, struct bfa_qos_attr_s *qos_attr); 201void bfa_fcport_qos_get_attr(struct bfa_s *bfa, struct bfa_qos_attr_s *qos_attr);
199void bfa_pport_qos_get_vc_attr(struct bfa_s *bfa, 202void bfa_fcport_qos_get_vc_attr(struct bfa_s *bfa,
200 struct bfa_qos_vc_attr_s *qos_vc_attr); 203 struct bfa_qos_vc_attr_s *qos_vc_attr);
201bfa_status_t bfa_pport_get_qos_stats(struct bfa_s *bfa, 204bfa_status_t bfa_fcport_get_qos_stats(struct bfa_s *bfa,
202 union bfa_pport_stats_u *stats, 205 union bfa_pport_stats_u *stats,
203 bfa_cb_pport_t cbfn, void *cbarg); 206 bfa_cb_pport_t cbfn, void *cbarg);
204bfa_status_t bfa_pport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, 207bfa_status_t bfa_fcport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn,
205 void *cbarg); 208 void *cbarg);
206bfa_boolean_t bfa_pport_is_ratelim(struct bfa_s *bfa); 209bfa_boolean_t bfa_fcport_is_ratelim(struct bfa_s *bfa);
207bfa_boolean_t bfa_pport_is_linkup(struct bfa_s *bfa); 210bfa_boolean_t bfa_fcport_is_linkup(struct bfa_s *bfa);
211bfa_status_t bfa_fcport_get_stats(struct bfa_s *bfa,
212 union bfa_fcport_stats_u *stats,
213 bfa_cb_pport_t cbfn, void *cbarg);
214bfa_status_t bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn,
215 void *cbarg);
208 216
209/* 217/*
210 * bfa rport API functions 218 * bfa rport API functions
diff --git a/drivers/scsi/bfa/include/bfi/bfi_pport.h b/drivers/scsi/bfa/include/bfi/bfi_pport.h
index c96d246851af..5c3d289d986d 100644
--- a/drivers/scsi/bfa/include/bfi/bfi_pport.h
+++ b/drivers/scsi/bfa/include/bfi/bfi_pport.h
@@ -32,6 +32,8 @@ enum bfi_pport_h2i {
32 BFI_PPORT_H2I_ENABLE_TX_VF_TAG_REQ = (7), 32 BFI_PPORT_H2I_ENABLE_TX_VF_TAG_REQ = (7),
33 BFI_PPORT_H2I_GET_QOS_STATS_REQ = (8), 33 BFI_PPORT_H2I_GET_QOS_STATS_REQ = (8),
34 BFI_PPORT_H2I_CLEAR_QOS_STATS_REQ = (9), 34 BFI_PPORT_H2I_CLEAR_QOS_STATS_REQ = (9),
35 BFI_FCPORT_H2I_GET_STATS_REQ = (10),
36 BFI_FCPORT_H2I_CLEAR_STATS_REQ = (11),
35}; 37};
36 38
37enum bfi_pport_i2h { 39enum bfi_pport_i2h {
@@ -45,6 +47,8 @@ enum bfi_pport_i2h {
45 BFI_PPORT_I2H_EVENT = BFA_I2HM(8), 47 BFI_PPORT_I2H_EVENT = BFA_I2HM(8),
46 BFI_PPORT_I2H_GET_QOS_STATS_RSP = BFA_I2HM(9), 48 BFI_PPORT_I2H_GET_QOS_STATS_RSP = BFA_I2HM(9),
47 BFI_PPORT_I2H_CLEAR_QOS_STATS_RSP = BFA_I2HM(10), 49 BFI_PPORT_I2H_CLEAR_QOS_STATS_RSP = BFA_I2HM(10),
50 BFI_FCPORT_I2H_GET_STATS_RSP = BFA_I2HM(11),
51 BFI_FCPORT_I2H_CLEAR_STATS_RSP = BFA_I2HM(12),
48}; 52};
49 53
50/** 54/**
@@ -75,6 +79,7 @@ struct bfi_pport_enable_req_s {
75 wwn_t pwwn; /* port wwn of physical port */ 79 wwn_t pwwn; /* port wwn of physical port */
76 struct bfa_pport_cfg_s port_cfg; /* port configuration */ 80 struct bfa_pport_cfg_s port_cfg; /* port configuration */
77 union bfi_addr_u stats_dma_addr; /* DMA address for stats */ 81 union bfi_addr_u stats_dma_addr; /* DMA address for stats */
82 union bfi_addr_u fcport_stats_dma_addr;/*!< DMA address for stats */
78 u32 msgtag; /* msgtag for reply */ 83 u32 msgtag; /* msgtag for reply */
79 u32 rsvd2; 84 u32 rsvd2;
80}; 85};
diff --git a/drivers/scsi/bfa/include/cs/bfa_sm.h b/drivers/scsi/bfa/include/cs/bfa_sm.h
index b0a92baf6657..11fba9082f05 100644
--- a/drivers/scsi/bfa/include/cs/bfa_sm.h
+++ b/drivers/scsi/bfa/include/cs/bfa_sm.h
@@ -23,6 +23,14 @@
23#define __BFA_SM_H__ 23#define __BFA_SM_H__
24 24
25typedef void (*bfa_sm_t)(void *sm, int event); 25typedef void (*bfa_sm_t)(void *sm, int event);
26/**
27 * oc - object class eg. bfa_ioc
28 * st - state, eg. reset
29 * otype - object type, eg. struct bfa_ioc_s
30 * etype - object type, eg. enum ioc_event
31 */
32#define bfa_sm_state_decl(oc, st, otype, etype) \
33 static void oc ## _sm_ ## st(otype * fsm, etype event)
26 34
27#define bfa_sm_set_state(_sm, _state) ((_sm)->sm = (bfa_sm_t)(_state)) 35#define bfa_sm_set_state(_sm, _state) ((_sm)->sm = (bfa_sm_t)(_state))
28#define bfa_sm_send_event(_sm, _event) ((_sm)->sm((_sm), (_event))) 36#define bfa_sm_send_event(_sm, _event) ((_sm)->sm((_sm), (_event)))
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_ethport.h b/drivers/scsi/bfa/include/defs/bfa_defs_ethport.h
index 79f9b3e146f7..b4fa0923aa89 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_ethport.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_ethport.h
@@ -19,6 +19,7 @@
19#define __BFA_DEFS_ETHPORT_H__ 19#define __BFA_DEFS_ETHPORT_H__
20 20
21#include <defs/bfa_defs_status.h> 21#include <defs/bfa_defs_status.h>
22#include <defs/bfa_defs_port.h>
22#include <protocol/types.h> 23#include <protocol/types.h>
23#include <cna/pstats/phyport_defs.h> 24#include <cna/pstats/phyport_defs.h>
24#include <cna/pstats/ethport_defs.h> 25#include <cna/pstats/ethport_defs.h>
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_fcport.h b/drivers/scsi/bfa/include/defs/bfa_defs_fcport.h
new file mode 100644
index 000000000000..a07ef4a3cd78
--- /dev/null
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_fcport.h
@@ -0,0 +1,94 @@
1/*
2 * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
3 * All rights reserved
4 * www.brocade.com
5 *
6 * bfa_defs_fcport.h
7 *
8 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License (GPL) Version 2 as
12 * published by the Free Software Foundation
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 */
19#ifndef __BFA_DEFS_FCPORT_H__
20#define __BFA_DEFS_FCPORT_H__
21
22#include <defs/bfa_defs_types.h>
23#include <protocol/types.h>
24
25#pragma pack(1)
26
27/**
28 * FCoE statistics
29 */
30struct bfa_fcoe_stats_s {
31 u64 secs_reset; /* Seconds since stats reset */
32 u64 cee_linkups; /* CEE link up */
33 u64 cee_linkdns; /* CEE link down */
34 u64 fip_linkups; /* FIP link up */
35 u64 fip_linkdns; /* FIP link down */
36 u64 fip_fails; /* FIP failures */
37 u64 mac_invalids; /* Invalid mac assignments */
38 u64 vlan_req; /* Vlan requests */
39 u64 vlan_notify; /* Vlan notifications */
40 u64 vlan_err; /* Vlan notification errors */
41 u64 vlan_timeouts; /* Vlan request timeouts */
42 u64 vlan_invalids; /* Vlan invalids */
43 u64 disc_req; /* Discovery requests */
44 u64 disc_rsp; /* Discovery responses */
45 u64 disc_err; /* Discovery error frames */
46 u64 disc_unsol; /* Discovery unsolicited */
47 u64 disc_timeouts; /* Discovery timeouts */
48 u64 disc_fcf_unavail; /* Discovery FCF not avail */
49 u64 linksvc_unsupp; /* FIP link service req unsupp. */
50 u64 linksvc_err; /* FIP link service req errors */
51 u64 logo_req; /* FIP logo */
52 u64 clrvlink_req; /* Clear virtual link requests */
53 u64 op_unsupp; /* FIP operation unsupp. */
54 u64 untagged; /* FIP untagged frames */
55 u64 txf_ucast; /* Tx FCoE unicast frames */
56 u64 txf_ucast_vlan; /* Tx FCoE unicast vlan frames */
57 u64 txf_ucast_octets; /* Tx FCoE unicast octets */
58 u64 txf_mcast; /* Tx FCoE mutlicast frames */
59 u64 txf_mcast_vlan; /* Tx FCoE mutlicast vlan frames */
60 u64 txf_mcast_octets; /* Tx FCoE multicast octets */
61 u64 txf_bcast; /* Tx FCoE broadcast frames */
62 u64 txf_bcast_vlan; /* Tx FCoE broadcast vlan frames */
63 u64 txf_bcast_octets; /* Tx FCoE broadcast octets */
64 u64 txf_timeout; /* Tx timeouts */
65 u64 txf_parity_errors; /* Transmit parity err */
66 u64 txf_fid_parity_errors; /* Transmit FID parity err */
67 u64 tx_pause; /* Tx pause frames */
68 u64 tx_zero_pause; /* Tx zero pause frames */
69 u64 tx_first_pause; /* Tx first pause frames */
70 u64 rx_pause; /* Rx pause frames */
71 u64 rx_zero_pause; /* Rx zero pause frames */
72 u64 rx_first_pause; /* Rx first pause frames */
73 u64 rxf_ucast_octets; /* Rx unicast octets */
74 u64 rxf_ucast; /* Rx unicast frames */
75 u64 rxf_ucast_vlan; /* Rx unicast vlan frames */
76 u64 rxf_mcast_octets; /* Rx multicast octets */
77 u64 rxf_mcast; /* Rx multicast frames */
78 u64 rxf_mcast_vlan; /* Rx multicast vlan frames */
79 u64 rxf_bcast_octets; /* Rx broadcast octests */
80 u64 rxf_bcast; /* Rx broadcast frames */
81 u64 rxf_bcast_vlan; /* Rx broadcast vlan frames */
82};
83
84/**
85 * QoS or FCoE stats (fcport stats excluding physical FC port stats)
86 */
87union bfa_fcport_stats_u {
88 struct bfa_qos_stats_s fcqos;
89 struct bfa_fcoe_stats_s fcoe;
90};
91
92#pragma pack()
93
94#endif /* __BFA_DEFS_FCPORT_H__ */
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_iocfc.h b/drivers/scsi/bfa/include/defs/bfa_defs_iocfc.h
index 87f0401c6439..c290fb13d2d1 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_iocfc.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_iocfc.h
@@ -236,6 +236,7 @@ struct bfa_fw_fip_stats_s {
236 u32 disc_err; /* Discovery advt. parse errors */ 236 u32 disc_err; /* Discovery advt. parse errors */
237 u32 disc_unsol; /* Discovery unsolicited */ 237 u32 disc_unsol; /* Discovery unsolicited */
238 u32 disc_timeouts; /* Discovery timeouts */ 238 u32 disc_timeouts; /* Discovery timeouts */
239 u32 disc_fcf_unavail; /* Discovery FCF Not Avail. */
239 u32 linksvc_unsupp; /* Unsupported link service req */ 240 u32 linksvc_unsupp; /* Unsupported link service req */
240 u32 linksvc_err; /* Parse error in link service req */ 241 u32 linksvc_err; /* Parse error in link service req */
241 u32 logo_req; /* Number of FIP logos received */ 242 u32 logo_req; /* Number of FIP logos received */
diff --git a/drivers/scsi/bfa/loop.c b/drivers/scsi/bfa/loop.c
index f7c7f4f3c640..f6342efb6a90 100644
--- a/drivers/scsi/bfa/loop.c
+++ b/drivers/scsi/bfa/loop.c
@@ -162,7 +162,7 @@ bfa_fcs_port_loop_send_plogi(struct bfa_fcs_port_s *port, u8 alpa)
162 len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), alpa, 162 len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), alpa,
163 bfa_fcs_port_get_fcid(port), 0, 163 bfa_fcs_port_get_fcid(port), 0,
164 port->port_cfg.pwwn, port->port_cfg.nwwn, 164 port->port_cfg.pwwn, port->port_cfg.nwwn,
165 bfa_pport_get_maxfrsize(port->fcs->bfa)); 165 bfa_fcport_get_maxfrsize(port->fcs->bfa));
166 166
167 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 167 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
168 FC_CLASS_3, len, &fchs, 168 FC_CLASS_3, len, &fchs,
diff --git a/drivers/scsi/bfa/lport_api.c b/drivers/scsi/bfa/lport_api.c
index 4a4ccce99364..d3907d184e2b 100644
--- a/drivers/scsi/bfa/lport_api.c
+++ b/drivers/scsi/bfa/lport_api.c
@@ -156,7 +156,7 @@ bfa_fcs_port_get_rport_max_speed(struct bfa_fcs_port_s *port)
156 /* 156 /*
157 * Get Physical port's current speed 157 * Get Physical port's current speed
158 */ 158 */
159 bfa_pport_get_attr(port->fcs->bfa, &pport_attr); 159 bfa_fcport_get_attr(port->fcs->bfa, &pport_attr);
160 pport_speed = pport_attr.speed; 160 pport_speed = pport_attr.speed;
161 bfa_trc(fcs, pport_speed); 161 bfa_trc(fcs, pport_speed);
162 162
diff --git a/drivers/scsi/bfa/ms.c b/drivers/scsi/bfa/ms.c
index f0275a409fd2..e6db5fd301f2 100644
--- a/drivers/scsi/bfa/ms.c
+++ b/drivers/scsi/bfa/ms.c
@@ -637,7 +637,7 @@ bfa_fcs_port_ms_send_plogi(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
637 bfa_os_hton3b(FC_MGMT_SERVER), 637 bfa_os_hton3b(FC_MGMT_SERVER),
638 bfa_fcs_port_get_fcid(port), 0, 638 bfa_fcs_port_get_fcid(port), 0,
639 port->port_cfg.pwwn, port->port_cfg.nwwn, 639 port->port_cfg.pwwn, port->port_cfg.nwwn,
640 bfa_pport_get_maxfrsize(port->fcs->bfa)); 640 bfa_fcport_get_maxfrsize(port->fcs->bfa));
641 641
642 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 642 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
643 FC_CLASS_3, len, &fchs, bfa_fcs_port_ms_plogi_response, 643 FC_CLASS_3, len, &fchs, bfa_fcs_port_ms_plogi_response,
diff --git a/drivers/scsi/bfa/ns.c b/drivers/scsi/bfa/ns.c
index 6de06a557e2d..d20dd7e15742 100644
--- a/drivers/scsi/bfa/ns.c
+++ b/drivers/scsi/bfa/ns.c
@@ -660,7 +660,7 @@ bfa_fcs_port_ns_send_plogi(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
660 bfa_os_hton3b(FC_NAME_SERVER), 660 bfa_os_hton3b(FC_NAME_SERVER),
661 bfa_fcs_port_get_fcid(port), 0, 661 bfa_fcs_port_get_fcid(port), 0,
662 port->port_cfg.pwwn, port->port_cfg.nwwn, 662 port->port_cfg.pwwn, port->port_cfg.nwwn,
663 bfa_pport_get_maxfrsize(port->fcs->bfa)); 663 bfa_fcport_get_maxfrsize(port->fcs->bfa));
664 664
665 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 665 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
666 FC_CLASS_3, len, &fchs, bfa_fcs_port_ns_plogi_response, 666 FC_CLASS_3, len, &fchs, bfa_fcs_port_ns_plogi_response,
diff --git a/drivers/scsi/bfa/rport.c b/drivers/scsi/bfa/rport.c
index 80592e352226..8c5969c86934 100644
--- a/drivers/scsi/bfa/rport.c
+++ b/drivers/scsi/bfa/rport.c
@@ -1373,7 +1373,7 @@ bfa_fcs_rport_send_plogi(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
1373 len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid, 1373 len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid,
1374 bfa_fcs_port_get_fcid(port), 0, 1374 bfa_fcs_port_get_fcid(port), 0,
1375 port->port_cfg.pwwn, port->port_cfg.nwwn, 1375 port->port_cfg.pwwn, port->port_cfg.nwwn,
1376 bfa_pport_get_maxfrsize(port->fcs->bfa)); 1376 bfa_fcport_get_maxfrsize(port->fcs->bfa));
1377 1377
1378 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 1378 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
1379 FC_CLASS_3, len, &fchs, bfa_fcs_rport_plogi_response, 1379 FC_CLASS_3, len, &fchs, bfa_fcs_rport_plogi_response,
@@ -1485,7 +1485,7 @@ bfa_fcs_rport_send_plogiacc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
1485 len = fc_plogi_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid, 1485 len = fc_plogi_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid,
1486 bfa_fcs_port_get_fcid(port), rport->reply_oxid, 1486 bfa_fcs_port_get_fcid(port), rport->reply_oxid,
1487 port->port_cfg.pwwn, port->port_cfg.nwwn, 1487 port->port_cfg.pwwn, port->port_cfg.nwwn,
1488 bfa_pport_get_maxfrsize(port->fcs->bfa)); 1488 bfa_fcport_get_maxfrsize(port->fcs->bfa));
1489 1489
1490 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 1490 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
1491 FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0); 1491 FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0);
@@ -1820,7 +1820,7 @@ bfa_fcs_rport_process_rpsc(struct bfa_fcs_rport_s *rport,
1820 /* 1820 /*
1821 * get curent speed from pport attributes from BFA 1821 * get curent speed from pport attributes from BFA
1822 */ 1822 */
1823 bfa_pport_get_attr(port->fcs->bfa, &pport_attr); 1823 bfa_fcport_get_attr(port->fcs->bfa, &pport_attr);
1824 1824
1825 speeds.port_op_speed = fc_bfa_speed_to_rpsc_operspeed(pport_attr.speed); 1825 speeds.port_op_speed = fc_bfa_speed_to_rpsc_operspeed(pport_attr.speed);
1826 1826
@@ -2171,7 +2171,7 @@ bfa_fcs_rport_update(struct bfa_fcs_rport_s *rport, struct fc_logi_s *plogi)
2171 bfa_trc(port->fcs, port->fabric->bb_credit); 2171 bfa_trc(port->fcs, port->fabric->bb_credit);
2172 2172
2173 port->fabric->bb_credit = bfa_os_ntohs(plogi->csp.bbcred); 2173 port->fabric->bb_credit = bfa_os_ntohs(plogi->csp.bbcred);
2174 bfa_pport_set_tx_bbcredit(port->fcs->bfa, 2174 bfa_fcport_set_tx_bbcredit(port->fcs->bfa,
2175 port->fabric->bb_credit); 2175 port->fabric->bb_credit);
2176 } 2176 }
2177 2177
diff --git a/drivers/scsi/bfa/rport_api.c b/drivers/scsi/bfa/rport_api.c
index 3dae1774181e..a441f41d2a64 100644
--- a/drivers/scsi/bfa/rport_api.c
+++ b/drivers/scsi/bfa/rport_api.c
@@ -102,7 +102,7 @@ bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
102 rport_attr->qos_attr = qos_attr; 102 rport_attr->qos_attr = qos_attr;
103 103
104 rport_attr->trl_enforced = BFA_FALSE; 104 rport_attr->trl_enforced = BFA_FALSE;
105 if (bfa_pport_is_ratelim(port->fcs->bfa)) { 105 if (bfa_fcport_is_ratelim(port->fcs->bfa)) {
106 if ((rport->rpf.rpsc_speed == BFA_PPORT_SPEED_UNKNOWN) || 106 if ((rport->rpf.rpsc_speed == BFA_PPORT_SPEED_UNKNOWN) ||
107 (rport->rpf.rpsc_speed < 107 (rport->rpf.rpsc_speed <
108 bfa_fcs_port_get_rport_max_speed(port))) 108 bfa_fcs_port_get_rport_max_speed(port)))
diff --git a/drivers/scsi/bfa/vport.c b/drivers/scsi/bfa/vport.c
index 14fb7ac2bfbc..c5e534eb1620 100644
--- a/drivers/scsi/bfa/vport.c
+++ b/drivers/scsi/bfa/vport.c
@@ -478,7 +478,7 @@ static void
478bfa_fcs_vport_do_fdisc(struct bfa_fcs_vport_s *vport) 478bfa_fcs_vport_do_fdisc(struct bfa_fcs_vport_s *vport)
479{ 479{
480 bfa_lps_fdisc(vport->lps, vport, 480 bfa_lps_fdisc(vport->lps, vport,
481 bfa_pport_get_maxfrsize(__vport_bfa(vport)), 481 bfa_fcport_get_maxfrsize(__vport_bfa(vport)),
482 __vport_pwwn(vport), __vport_nwwn(vport)); 482 __vport_pwwn(vport), __vport_nwwn(vport));
483 vport->vport_stats.fdisc_sent++; 483 vport->vport_stats.fdisc_sent++;
484} 484}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-16 23:03:50 -0500