?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: add device IDs for igotu to navman
[linux-2.6.git] / drivers / scsi / bfa / bfa_fcxp.c
blob8258f88bfee62b3ac8964c622acdf18fdea64201
1 /*
2 * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
3 * All rights reserved
4 * www.brocade.com
5 *
6 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License (GPL) Version 2 as
10 * published by the Free Software Foundation
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 */
17
18 #include <bfa.h>
19 #include <bfi/bfi_uf.h>
20 #include <cs/bfa_debug.h>
21
22 BFA_TRC_FILE(HAL, FCXP);
23 BFA_MODULE(fcxp);
24
25 /**
26 * forward declarations
27 */
28 static void __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete);
29 static void hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
30 struct bfi_fcxp_send_rsp_s *fcxp_rsp);
31 static void hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen,
32 struct bfa_fcxp_s *fcxp, struct fchs_s *fchs);
33 static void bfa_fcxp_qresume(void *cbarg);
34 static void bfa_fcxp_queue(struct bfa_fcxp_s *fcxp,
35 struct bfi_fcxp_send_req_s *send_req);
36
37 /**
38 * fcxp_pvt BFA FCXP private functions
39 */
40
41 static void
42 claim_fcxp_req_rsp_mem(struct bfa_fcxp_mod_s *mod, struct bfa_meminfo_s *mi)
43 {
44 u8 *dm_kva = NULL;
45 u64 dm_pa;
46 u32 buf_pool_sz;
47
48 dm_kva = bfa_meminfo_dma_virt(mi);
49 dm_pa = bfa_meminfo_dma_phys(mi);
50
51 buf_pool_sz = mod->req_pld_sz * mod->num_fcxps;
52
53 /*
54 * Initialize the fcxp req payload list
55 */
56 mod->req_pld_list_kva = dm_kva;
57 mod->req_pld_list_pa = dm_pa;
58 dm_kva += buf_pool_sz;
59 dm_pa += buf_pool_sz;
60 bfa_os_memset(mod->req_pld_list_kva, 0, buf_pool_sz);
61
62 /*
63 * Initialize the fcxp rsp payload list
64 */
65 buf_pool_sz = mod->rsp_pld_sz * mod->num_fcxps;
66 mod->rsp_pld_list_kva = dm_kva;
67 mod->rsp_pld_list_pa = dm_pa;
68 dm_kva += buf_pool_sz;
69 dm_pa += buf_pool_sz;
70 bfa_os_memset(mod->rsp_pld_list_kva, 0, buf_pool_sz);
71
72 bfa_meminfo_dma_virt(mi) = dm_kva;
73 bfa_meminfo_dma_phys(mi) = dm_pa;
74 }
75
76 static void
77 claim_fcxps_mem(struct bfa_fcxp_mod_s *mod, struct bfa_meminfo_s *mi)
78 {
79 u16 i;
80 struct bfa_fcxp_s *fcxp;
81
82 fcxp = (struct bfa_fcxp_s *) bfa_meminfo_kva(mi);
83 bfa_os_memset(fcxp, 0, sizeof(struct bfa_fcxp_s) * mod->num_fcxps);
84
85 INIT_LIST_HEAD(&mod->fcxp_free_q);
86 INIT_LIST_HEAD(&mod->fcxp_active_q);
87
88 mod->fcxp_list = fcxp;
89
90 for (i = 0; i < mod->num_fcxps; i++) {
91 fcxp->fcxp_mod = mod;
92 fcxp->fcxp_tag = i;
93
94 list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
95 bfa_reqq_winit(&fcxp->reqq_wqe, bfa_fcxp_qresume, fcxp);
96 fcxp->reqq_waiting = BFA_FALSE;
97
98 fcxp = fcxp + 1;
99 }
100
101 bfa_meminfo_kva(mi) = (void *)fcxp;
102 }
103
104 static void
105 bfa_fcxp_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
106 u32 *dm_len)
107 {
108 u16 num_fcxp_reqs = cfg->fwcfg.num_fcxp_reqs;
109
110 if (num_fcxp_reqs == 0)
111 return;
112
113 /*
114 * Account for req/rsp payload
115 */
116 *dm_len += BFA_FCXP_MAX_IBUF_SZ * num_fcxp_reqs;
117 if (cfg->drvcfg.min_cfg)
118 *dm_len += BFA_FCXP_MAX_IBUF_SZ * num_fcxp_reqs;
119 else
120 *dm_len += BFA_FCXP_MAX_LBUF_SZ * num_fcxp_reqs;
121
122 /*
123 * Account for fcxp structs
124 */
125 *ndm_len += sizeof(struct bfa_fcxp_s) * num_fcxp_reqs;
126 }
127
128 static void
129 bfa_fcxp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
130 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
131 {
132 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
133
134 bfa_os_memset(mod, 0, sizeof(struct bfa_fcxp_mod_s));
135 mod->bfa = bfa;
136 mod->num_fcxps = cfg->fwcfg.num_fcxp_reqs;
137
138 /**
139 * Initialize FCXP request and response payload sizes.
140 */
141 mod->req_pld_sz = mod->rsp_pld_sz = BFA_FCXP_MAX_IBUF_SZ;
142 if (!cfg->drvcfg.min_cfg)
143 mod->rsp_pld_sz = BFA_FCXP_MAX_LBUF_SZ;
144
145 INIT_LIST_HEAD(&mod->wait_q);
146
147 claim_fcxp_req_rsp_mem(mod, meminfo);
148 claim_fcxps_mem(mod, meminfo);
149 }
150
151 static void
152 bfa_fcxp_detach(struct bfa_s *bfa)
153 {
154 }
155
156 static void
157 bfa_fcxp_start(struct bfa_s *bfa)
158 {
159 }
160
161 static void
162 bfa_fcxp_stop(struct bfa_s *bfa)
163 {
164 }
165
166 static void
167 bfa_fcxp_iocdisable(struct bfa_s *bfa)
168 {
169 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
170 struct bfa_fcxp_s *fcxp;
171 struct list_head *qe, *qen;
172
173 list_for_each_safe(qe, qen, &mod->fcxp_active_q) {
174 fcxp = (struct bfa_fcxp_s *) qe;
175 if (fcxp->caller == NULL) {
176 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
177 BFA_STATUS_IOC_FAILURE, 0, 0, NULL);
178 bfa_fcxp_free(fcxp);
179 } else {
180 fcxp->rsp_status = BFA_STATUS_IOC_FAILURE;
181 bfa_cb_queue(bfa, &fcxp->hcb_qe,
182 __bfa_fcxp_send_cbfn, fcxp);
183 }
184 }
185 }
186
187 static struct bfa_fcxp_s *
188 bfa_fcxp_get(struct bfa_fcxp_mod_s *fm)
189 {
190 struct bfa_fcxp_s *fcxp;
191
192 bfa_q_deq(&fm->fcxp_free_q, &fcxp);
193
194 if (fcxp)
195 list_add_tail(&fcxp->qe, &fm->fcxp_active_q);
196
197 return fcxp;
198 }
199
200 static void
201 bfa_fcxp_put(struct bfa_fcxp_s *fcxp)
202 {
203 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
204 struct bfa_fcxp_wqe_s *wqe;
205
206 bfa_q_deq(&mod->wait_q, &wqe);
207 if (wqe) {
208 bfa_trc(mod->bfa, fcxp->fcxp_tag);
209 wqe->alloc_cbfn(wqe->alloc_cbarg, fcxp);
210 return;
211 }
212
213 bfa_assert(bfa_q_is_on_q(&mod->fcxp_active_q, fcxp));
214 list_del(&fcxp->qe);
215 list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
216 }
217
218 static void
219 bfa_fcxp_null_comp(void *bfad_fcxp, struct bfa_fcxp_s *fcxp, void *cbarg,
220 bfa_status_t req_status, u32 rsp_len,
221 u32 resid_len, struct fchs_s *rsp_fchs)
222 {
223 /* discarded fcxp completion */
224 }
225
226 static void
227 __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete)
228 {
229 struct bfa_fcxp_s *fcxp = cbarg;
230
231 if (complete) {
232 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
233 fcxp->rsp_status, fcxp->rsp_len,
234 fcxp->residue_len, &fcxp->rsp_fchs);
235 } else {
236 bfa_fcxp_free(fcxp);
237 }
238 }
239
240 static void
241 hal_fcxp_send_comp(struct bfa_s *bfa, struct bfi_fcxp_send_rsp_s *fcxp_rsp)
242 {
243 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
244 struct bfa_fcxp_s *fcxp;
245 u16 fcxp_tag = bfa_os_ntohs(fcxp_rsp->fcxp_tag);
246
247 bfa_trc(bfa, fcxp_tag);
248
249 fcxp_rsp->rsp_len = bfa_os_ntohl(fcxp_rsp->rsp_len);
250
251 /**
252 * @todo f/w should not set residue to non-0 when everything
253 * is received.
254 */
255 if (fcxp_rsp->req_status == BFA_STATUS_OK)
256 fcxp_rsp->residue_len = 0;
257 else
258 fcxp_rsp->residue_len = bfa_os_ntohl(fcxp_rsp->residue_len);
259
260 fcxp = BFA_FCXP_FROM_TAG(mod, fcxp_tag);
261
262 bfa_assert(fcxp->send_cbfn != NULL);
263
264 hal_fcxp_rx_plog(mod->bfa, fcxp, fcxp_rsp);
265
266 if (fcxp->send_cbfn != NULL) {
267 if (fcxp->caller == NULL) {
268 bfa_trc(mod->bfa, fcxp->fcxp_tag);
269
270 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
271 fcxp_rsp->req_status, fcxp_rsp->rsp_len,
272 fcxp_rsp->residue_len, &fcxp_rsp->fchs);
273 /*
274 * fcxp automatically freed on return from the callback
275 */
276 bfa_fcxp_free(fcxp);
277 } else {
278 bfa_trc(mod->bfa, fcxp->fcxp_tag);
279 fcxp->rsp_status = fcxp_rsp->req_status;
280 fcxp->rsp_len = fcxp_rsp->rsp_len;
281 fcxp->residue_len = fcxp_rsp->residue_len;
282 fcxp->rsp_fchs = fcxp_rsp->fchs;
283
284 bfa_cb_queue(bfa, &fcxp->hcb_qe,
285 __bfa_fcxp_send_cbfn, fcxp);
286 }
287 } else {
288 bfa_trc(bfa, fcxp_tag);
289 }
290 }
291
292 static void
293 hal_fcxp_set_local_sges(struct bfi_sge_s *sge, u32 reqlen, u64 req_pa)
294 {
295 union bfi_addr_u sga_zero = { {0} };
296
297 sge->sg_len = reqlen;
298 sge->flags = BFI_SGE_DATA_LAST;
299 bfa_dma_addr_set(sge[0].sga, req_pa);
300 bfa_sge_to_be(sge);
301 sge++;
302
303 sge->sga = sga_zero;
304 sge->sg_len = reqlen;
305 sge->flags = BFI_SGE_PGDLEN;
306 bfa_sge_to_be(sge);
307 }
308
309 static void
310 hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen, struct bfa_fcxp_s *fcxp,
311 struct fchs_s *fchs)
312 {
313 /*
314 * TODO: TX ox_id
315 */
316 if (reqlen > 0) {
317 if (fcxp->use_ireqbuf) {
318 u32 pld_w0 =
319 *((u32 *) BFA_FCXP_REQ_PLD(fcxp));
320
321 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP,
322 BFA_PL_EID_TX,
323 reqlen + sizeof(struct fchs_s), fchs, pld_w0);
324 } else {
325 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
326 BFA_PL_EID_TX, reqlen + sizeof(struct fchs_s),
327 fchs);
328 }
329 } else {
330 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_TX,
331 reqlen + sizeof(struct fchs_s), fchs);
332 }
333 }
334
335 static void
336 hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
337 struct bfi_fcxp_send_rsp_s *fcxp_rsp)
338 {
339 if (fcxp_rsp->rsp_len > 0) {
340 if (fcxp->use_irspbuf) {
341 u32 pld_w0 =
342 *((u32 *) BFA_FCXP_RSP_PLD(fcxp));
343
344 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP,
345 BFA_PL_EID_RX,
346 (u16) fcxp_rsp->rsp_len,
347 &fcxp_rsp->fchs, pld_w0);
348 } else {
349 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
350 BFA_PL_EID_RX,
351 (u16) fcxp_rsp->rsp_len,
352 &fcxp_rsp->fchs);
353 }
354 } else {
355 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_RX,
356 (u16) fcxp_rsp->rsp_len, &fcxp_rsp->fchs);
357 }
358 }
359
360 /**
361 * Handler to resume sending fcxp when space in available in cpe queue.
362 */
363 static void
364 bfa_fcxp_qresume(void *cbarg)
365 {
366 struct bfa_fcxp_s *fcxp = cbarg;
367 struct bfa_s *bfa = fcxp->fcxp_mod->bfa;
368 struct bfi_fcxp_send_req_s *send_req;
369
370 fcxp->reqq_waiting = BFA_FALSE;
371 send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP);
372 bfa_fcxp_queue(fcxp, send_req);
373 }
374
375 /**
376 * Queue fcxp send request to foimrware.
377 */
378 static void
379 bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, struct bfi_fcxp_send_req_s *send_req)
380 {
381 struct bfa_s *bfa = fcxp->fcxp_mod->bfa;
382 struct bfa_fcxp_req_info_s *reqi = &fcxp->req_info;
383 struct bfa_fcxp_rsp_info_s *rspi = &fcxp->rsp_info;
384 struct bfa_rport_s *rport = reqi->bfa_rport;
385
386 bfi_h2i_set(send_req->mh, BFI_MC_FCXP, BFI_FCXP_H2I_SEND_REQ,
387 bfa_lpuid(bfa));
388
389 send_req->fcxp_tag = bfa_os_htons(fcxp->fcxp_tag);
390 if (rport) {
391 send_req->rport_fw_hndl = rport->fw_handle;
392 send_req->max_frmsz = bfa_os_htons(rport->rport_info.max_frmsz);
393 if (send_req->max_frmsz == 0)
394 send_req->max_frmsz = bfa_os_htons(FC_MAX_PDUSZ);
395 } else {
396 send_req->rport_fw_hndl = 0;
397 send_req->max_frmsz = bfa_os_htons(FC_MAX_PDUSZ);
398 }
399
400 send_req->vf_id = bfa_os_htons(reqi->vf_id);
401 send_req->lp_tag = reqi->lp_tag;
402 send_req->class = reqi->class;
403 send_req->rsp_timeout = rspi->rsp_timeout;
404 send_req->cts = reqi->cts;
405 send_req->fchs = reqi->fchs;
406
407 send_req->req_len = bfa_os_htonl(reqi->req_tot_len);
408 send_req->rsp_maxlen = bfa_os_htonl(rspi->rsp_maxlen);
409
410 /*
411 * setup req sgles
412 */
413 if (fcxp->use_ireqbuf == 1) {
414 hal_fcxp_set_local_sges(send_req->req_sge, reqi->req_tot_len,
415 BFA_FCXP_REQ_PLD_PA(fcxp));
416 } else {
417 if (fcxp->nreq_sgles > 0) {
418 bfa_assert(fcxp->nreq_sgles == 1);
419 hal_fcxp_set_local_sges(send_req->req_sge,
420 reqi->req_tot_len,
421 fcxp->req_sga_cbfn(fcxp->caller,
422 0));
423 } else {
424 bfa_assert(reqi->req_tot_len == 0);
425 hal_fcxp_set_local_sges(send_req->rsp_sge, 0, 0);
426 }
427 }
428
429 /*
430 * setup rsp sgles
431 */
432 if (fcxp->use_irspbuf == 1) {
433 bfa_assert(rspi->rsp_maxlen <= BFA_FCXP_MAX_LBUF_SZ);
434
435 hal_fcxp_set_local_sges(send_req->rsp_sge, rspi->rsp_maxlen,
436 BFA_FCXP_RSP_PLD_PA(fcxp));
437
438 } else {
439 if (fcxp->nrsp_sgles > 0) {
440 bfa_assert(fcxp->nrsp_sgles == 1);
441 hal_fcxp_set_local_sges(send_req->rsp_sge,
442 rspi->rsp_maxlen,
443 fcxp->rsp_sga_cbfn(fcxp->caller,
444 0));
445 } else {
446 bfa_assert(rspi->rsp_maxlen == 0);
447 hal_fcxp_set_local_sges(send_req->rsp_sge, 0, 0);
448 }
449 }
450
451 hal_fcxp_tx_plog(bfa, reqi->req_tot_len, fcxp, &reqi->fchs);
452
453 bfa_reqq_produce(bfa, BFA_REQQ_FCXP);
454
455 bfa_trc(bfa, bfa_reqq_pi(bfa, BFA_REQQ_FCXP));
456 bfa_trc(bfa, bfa_reqq_ci(bfa, BFA_REQQ_FCXP));
457 }
458
459
460 /**
461 * hal_fcxp_api BFA FCXP API
462 */
463
464 /**
465 * Allocate an FCXP instance to send a response or to send a request
466 * that has a response. Request/response buffers are allocated by caller.
467 *
468 * @param[in] bfa BFA bfa instance
469 * @param[in] nreq_sgles Number of SG elements required for request
470 * buffer. 0, if fcxp internal buffers are used.
471 * Use bfa_fcxp_get_reqbuf() to get the
472 * internal req buffer.
473 * @param[in] req_sgles SG elements describing request buffer. Will be
474 * copied in by BFA and hence can be freed on
475 * return from this function.
476 * @param[in] get_req_sga function ptr to be called to get a request SG
477 * Address (given the sge index).
478 * @param[in] get_req_sglen function ptr to be called to get a request SG
479 * len (given the sge index).
480 * @param[in] get_rsp_sga function ptr to be called to get a response SG
481 * Address (given the sge index).
482 * @param[in] get_rsp_sglen function ptr to be called to get a response SG
483 * len (given the sge index).
484 *
485 * @return FCXP instance. NULL on failure.
486 */
487 struct bfa_fcxp_s *
488 bfa_fcxp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
489 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
490 bfa_fcxp_get_sglen_t req_sglen_cbfn,
491 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
492 bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
493 {
494 struct bfa_fcxp_s *fcxp = NULL;
495 u32 nreq_sgpg, nrsp_sgpg;
496
497 bfa_assert(bfa != NULL);
498
499 fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa));
500 if (fcxp == NULL)
501 return NULL;
502
503 bfa_trc(bfa, fcxp->fcxp_tag);
504
505 fcxp->caller = caller;
506
507 if (nreq_sgles == 0) {
508 fcxp->use_ireqbuf = 1;
509 } else {
510 bfa_assert(req_sga_cbfn != NULL);
511 bfa_assert(req_sglen_cbfn != NULL);
512
513 fcxp->use_ireqbuf = 0;
514 fcxp->req_sga_cbfn = req_sga_cbfn;
515 fcxp->req_sglen_cbfn = req_sglen_cbfn;
516
517 fcxp->nreq_sgles = nreq_sgles;
518
519 /*
520 * alloc required sgpgs
521 */
522 if (nreq_sgles > BFI_SGE_INLINE) {
523 nreq_sgpg = BFA_SGPG_NPAGE(nreq_sgles);
524
525 if (bfa_sgpg_malloc(bfa, &fcxp->req_sgpg_q, nreq_sgpg)
526 != BFA_STATUS_OK) {
527 /*
528 * TODO
529 */
530 }
531 }
532 }
533
534 if (nrsp_sgles == 0) {
535 fcxp->use_irspbuf = 1;
536 } else {
537 bfa_assert(rsp_sga_cbfn != NULL);
538 bfa_assert(rsp_sglen_cbfn != NULL);
539
540 fcxp->use_irspbuf = 0;
541 fcxp->rsp_sga_cbfn = rsp_sga_cbfn;
542 fcxp->rsp_sglen_cbfn = rsp_sglen_cbfn;
543
544 fcxp->nrsp_sgles = nrsp_sgles;
545 /*
546 * alloc required sgpgs
547 */
548 if (nrsp_sgles > BFI_SGE_INLINE) {
549 nrsp_sgpg = BFA_SGPG_NPAGE(nreq_sgles);
550
551 if (bfa_sgpg_malloc
552 (bfa, &fcxp->rsp_sgpg_q, nrsp_sgpg)
553 != BFA_STATUS_OK) {
554 /* bfa_sgpg_wait(bfa, &fcxp->rsp_sgpg_wqe,
555 nrsp_sgpg); */
556 /*
557 * TODO
558 */
559 }
560 }
561 }
562
563 return fcxp;
564 }
565
566 /**
567 * Get the internal request buffer pointer
568 *
569 * @param[in] fcxp BFA fcxp pointer
570 *
571 * @return pointer to the internal request buffer
572 */
573 void *
574 bfa_fcxp_get_reqbuf(struct bfa_fcxp_s *fcxp)
575 {
576 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
577 void *reqbuf;
578
579 bfa_assert(fcxp->use_ireqbuf == 1);
580 reqbuf = ((u8 *)mod->req_pld_list_kva) +
581 fcxp->fcxp_tag * mod->req_pld_sz;
582 return reqbuf;
583 }
584
585 u32
586 bfa_fcxp_get_reqbufsz(struct bfa_fcxp_s *fcxp)
587 {
588 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
589
590 return mod->req_pld_sz;
591 }
592
593 /**
594 * Get the internal response buffer pointer
595 *
596 * @param[in] fcxp BFA fcxp pointer
597 *
598 * @return pointer to the internal request buffer
599 */
600 void *
601 bfa_fcxp_get_rspbuf(struct bfa_fcxp_s *fcxp)
602 {
603 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
604 void *rspbuf;
605
606 bfa_assert(fcxp->use_irspbuf == 1);
607
608 rspbuf = ((u8 *)mod->rsp_pld_list_kva) +
609 fcxp->fcxp_tag * mod->rsp_pld_sz;
610 return rspbuf;
611 }
612
613 /**
614 * Free the BFA FCXP
615 *
616 * @param[in] fcxp BFA fcxp pointer
617 *
618 * @return void
619 */
620 void
621 bfa_fcxp_free(struct bfa_fcxp_s *fcxp)
622 {
623 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
624
625 bfa_assert(fcxp != NULL);
626 bfa_trc(mod->bfa, fcxp->fcxp_tag);
627 bfa_fcxp_put(fcxp);
628 }
629
630 /**
631 * Send a FCXP request
632 *
633 * @param[in] fcxp BFA fcxp pointer
634 * @param[in] rport BFA rport pointer. Could be left NULL for WKA rports
635 * @param[in] vf_id virtual Fabric ID
636 * @param[in] lp_tag lport tag
637 * @param[in] cts use Continous sequence
638 * @param[in] cos fc Class of Service
639 * @param[in] reqlen request length, does not include FCHS length
640 * @param[in] fchs fc Header Pointer. The header content will be copied
641 * in by BFA.
642 *
643 * @param[in] cbfn call back function to be called on receiving
644 * the response
645 * @param[in] cbarg arg for cbfn
646 * @param[in] rsp_timeout
647 * response timeout
648 *
649 * @return bfa_status_t
650 */
651 void
652 bfa_fcxp_send(struct bfa_fcxp_s *fcxp, struct bfa_rport_s *rport,
653 u16 vf_id, u8 lp_tag, bfa_boolean_t cts, enum fc_cos cos,
654 u32 reqlen, struct fchs_s *fchs, bfa_cb_fcxp_send_t cbfn,
655 void *cbarg, u32 rsp_maxlen, u8 rsp_timeout)
656 {
657 struct bfa_s *bfa = fcxp->fcxp_mod->bfa;
658 struct bfa_fcxp_req_info_s *reqi = &fcxp->req_info;
659 struct bfa_fcxp_rsp_info_s *rspi = &fcxp->rsp_info;
660 struct bfi_fcxp_send_req_s *send_req;
661
662 bfa_trc(bfa, fcxp->fcxp_tag);
663
664 /**
665 * setup request/response info
666 */
667 reqi->bfa_rport = rport;
668 reqi->vf_id = vf_id;
669 reqi->lp_tag = lp_tag;
670 reqi->class = cos;
671 rspi->rsp_timeout = rsp_timeout;
672 reqi->cts = cts;
673 reqi->fchs = *fchs;
674 reqi->req_tot_len = reqlen;
675 rspi->rsp_maxlen = rsp_maxlen;
676 fcxp->send_cbfn = cbfn ? cbfn : bfa_fcxp_null_comp;
677 fcxp->send_cbarg = cbarg;
678
679 /**
680 * If no room in CPE queue, wait for space in request queue
681 */
682 send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP);
683 if (!send_req) {
684 bfa_trc(bfa, fcxp->fcxp_tag);
685 fcxp->reqq_waiting = BFA_TRUE;
686 bfa_reqq_wait(bfa, BFA_REQQ_FCXP, &fcxp->reqq_wqe);
687 return;
688 }
689
690 bfa_fcxp_queue(fcxp, send_req);
691 }
692
693 /**
694 * Abort a BFA FCXP
695 *
696 * @param[in] fcxp BFA fcxp pointer
697 *
698 * @return void
699 */
700 bfa_status_t
701 bfa_fcxp_abort(struct bfa_fcxp_s *fcxp)
702 {
703 bfa_assert(0);
704 return BFA_STATUS_OK;
705 }
706
707 void
708 bfa_fcxp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
709 bfa_fcxp_alloc_cbfn_t alloc_cbfn, void *alloc_cbarg)
710 {
711 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
712
713 bfa_assert(list_empty(&mod->fcxp_free_q));
714
715 wqe->alloc_cbfn = alloc_cbfn;
716 wqe->alloc_cbarg = alloc_cbarg;
717 list_add_tail(&wqe->qe, &mod->wait_q);
718 }
719
720 void
721 bfa_fcxp_walloc_cancel(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe)
722 {
723 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
724
725 bfa_assert(bfa_q_is_on_q(&mod->wait_q, wqe));
726 list_del(&wqe->qe);
727 }
728
729 void
730 bfa_fcxp_discard(struct bfa_fcxp_s *fcxp)
731 {
732 /**
733 * If waiting for room in request queue, cancel reqq wait
734 * and free fcxp.
735 */
736 if (fcxp->reqq_waiting) {
737 fcxp->reqq_waiting = BFA_FALSE;
738 bfa_reqq_wcancel(&fcxp->reqq_wqe);
739 bfa_fcxp_free(fcxp);
740 return;
741 }
742
743 fcxp->send_cbfn = bfa_fcxp_null_comp;
744 }
745
746
747
748 /**
749 * hal_fcxp_public BFA FCXP public functions
750 */
751
752 void
753 bfa_fcxp_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
754 {
755 switch (msg->mhdr.msg_id) {
756 case BFI_FCXP_I2H_SEND_RSP:
757 hal_fcxp_send_comp(bfa, (struct bfi_fcxp_send_rsp_s *) msg);
758 break;
759
760 default:
761 bfa_trc(bfa, msg->mhdr.msg_id);
762 bfa_assert(0);
763 }
764 }
765
766 u32
767 bfa_fcxp_get_maxrsp(struct bfa_s *bfa)
768 {
769 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
770
771 return mod->rsp_pld_sz;
772 }
773
774
Linus' kernel tree